@standardagents/builder 0.15.0 → 0.15.1

package/dist/index.js

@@ -2,10 +2,10 @@ import { ProviderError, mapReasoningLevel } from '@standardagents/spec';
 export { ProviderError, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel } from '@standardagents/spec';
 import { z } from 'zod';
 import { transform, collect } from '@standardagents/sip';
-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';
@@ -873,8 +873,10 @@ var init_ProviderRegistry = __esm({
     ProviderRegistryImpl = class {
       providerCache = /* @__PURE__ */ new Map();
       providerOverrideFn = null;
+      providerOverrideRevision = 0;
       setProviderOverride(fn) {
         this.providerOverrideFn = fn;
+        this.providerOverrideRevision += 1;
       }
       /**
        * Get provider for a model.
@@ -894,17 +896,6 @@ var init_ProviderRegistry = __esm({
         if (!modelDef) {
           throw new Error(`Model not found: ${modelName}`);
         }
-        if (this.providerOverrideFn) {
-          const overrideFingerprint = this.getProviderFingerprint("override", modelDef);
-          const cached2 = this.providerCache.get(modelName);
-          if (cached2?.fingerprint === overrideFingerprint) {
-            return this.buildResult(cached2.provider, modelDef);
-          }
-          const overrideProvider = this.providerOverrideFn(modelName, modelDef, env);
-          if (overrideProvider) {
-            return this.cacheAndReturn(modelName, overrideProvider, modelDef, overrideFingerprint);
-          }
-        }
         if (typeof modelDef.provider !== "function") {
           throw new Error(
             `Model '${modelName}' has invalid provider. Provider must be a ProviderFactory function imported from a provider package (e.g., @standardagents/openai).`
@@ -912,29 +903,45 @@ var init_ProviderRegistry = __esm({
         }
         const providerFactory = modelDef.provider;
         const providerName = providerFactory({ apiKey: "" }).name;
-        const fingerprint = this.getProviderFingerprint(providerName, modelDef);
-        const cached = this.providerCache.get(modelName);
-        if (cached?.fingerprint === fingerprint) {
-          return this.buildResult(cached.provider, modelDef);
-        }
         if (providerName === "test") {
+          const fingerprint = this.getProviderFingerprint(providerName, modelDef);
+          const cached = this.providerCache.get(modelName);
+          if (cached?.fingerprint === fingerprint) {
+            return this.buildResult(cached.provider, modelDef);
+          }
           return this.cacheAndReturn(modelName, createTestProvider(), modelDef, fingerprint);
         }
         const apiKey = this.getApiKeyForProvider(providerName, env);
-        if (!apiKey) {
-          throw new Error(`No API key found for provider: ${providerName}. Set the appropriate environment variable (e.g., OPENAI_API_KEY, OPENROUTER_API_KEY).`);
-        }
-        const config = { apiKey };
-        if (modelDef.providerOptions?.baseUrl) {
-          config.baseUrl = modelDef.providerOptions.baseUrl;
-        }
-        if (providerName === "cloudflare" && !config.baseUrl && env.CLOUDFLARE_ACCOUNT_ID) {
-          config.baseUrl = `https://api.cloudflare.com/client/v4/accounts/${env.CLOUDFLARE_ACCOUNT_ID}/ai/v1`;
+        if (apiKey) {
+          const config = { apiKey };
+          if (modelDef.providerOptions?.baseUrl) {
+            config.baseUrl = modelDef.providerOptions.baseUrl;
+          }
+          if (providerName === "cloudflare" && !config.baseUrl && env.CLOUDFLARE_ACCOUNT_ID) {
+            config.baseUrl = `https://api.cloudflare.com/client/v4/accounts/${env.CLOUDFLARE_ACCOUNT_ID}/ai/v1`;
+          }
+          if (providerName === "cloudflare" && env.CLOUDFLARE_ACCOUNT_ID) {
+            config.accountId = env.CLOUDFLARE_ACCOUNT_ID;
+          }
+          const fingerprint = this.getProviderFingerprint(providerName, modelDef, config);
+          const cached = this.providerCache.get(modelName);
+          if (cached?.fingerprint === fingerprint) {
+            return this.buildResult(cached.provider, modelDef);
+          }
+          return this.cacheAndReturn(modelName, providerFactory(config), modelDef, fingerprint);
         }
-        if (providerName === "cloudflare" && env.CLOUDFLARE_ACCOUNT_ID) {
-          config.accountId = env.CLOUDFLARE_ACCOUNT_ID;
+        if (this.providerOverrideFn) {
+          const overrideFingerprint = this.getProviderFingerprint(`override:${this.providerOverrideRevision}`, modelDef);
+          const overrideCached = this.providerCache.get(modelName);
+          if (overrideCached?.fingerprint === overrideFingerprint) {
+            return this.buildResult(overrideCached.provider, modelDef);
+          }
+          const overrideProvider = this.providerOverrideFn(modelName, modelDef, env);
+          if (overrideProvider) {
+            return this.cacheAndReturn(modelName, overrideProvider, modelDef, overrideFingerprint);
+          }
         }
-        return this.cacheAndReturn(modelName, providerFactory(config), modelDef, fingerprint);
+        throw new Error(`No API key found for provider: ${providerName}. Set the provider key or STANDARD_AGENTS_API_KEY.`);
       }
       buildResult(provider, modelDef) {
         return { provider, modelName: modelDef.model, modelDef };
@@ -943,10 +950,12 @@ var init_ProviderRegistry = __esm({
         this.providerCache.set(modelName, { provider, fingerprint });
         return this.buildResult(provider, modelDef);
       }
-      getProviderFingerprint(providerName, modelDef) {
+      getProviderFingerprint(providerName, modelDef, config) {
         return JSON.stringify({
           providerName,
-          baseUrl: modelDef.providerOptions?.baseUrl ?? null
+          baseUrl: modelDef.providerOptions?.baseUrl ?? null,
+          apiKey: config?.apiKey ?? null,
+          accountId: config?.accountId ?? null
         });
       }
       /**
@@ -1150,11 +1159,11 @@ function stripBase64FromMessages(messages, imagePathMap) {
             const data = part.data;
             if (typeof data === "string") {
               if (data.startsWith("data:") || data.length > 1e3) {
-                const path19 = imagePathMap?.get(data);
+                const path20 = imagePathMap?.get(data);
                 return {
                   ...part,
                   data: "[base64 omitted]",
-                  ...path19 ? { path: path19 } : {}
+                  ...path20 ? { path: path20 } : {}
                 };
               }
             }
@@ -1831,6 +1840,7 @@ var init_LLMRequest = __esm({
         try {
           const toolsCalled = response.tool_calls ? JSON.stringify(response.tool_calls.map((tc) => tc.function.name)) : null;
           const providerName = response._provider?.name;
+          const standardAgentsRouterUsed = providerName === "platform";
           const resolvedPricing = resolveModelPricing(modelDef, providerName);
           const calculatedCost = calculateUsageCost(response.usage, resolvedPricing);
           const providerReportedCost = typeof response.usage.cost === "number" ? response.usage.cost : typeof response.usage.cost === "string" ? parseFloat(response.usage.cost) : null;
@@ -1904,6 +1914,7 @@ var init_LLMRequest = __esm({
             cost_total: cost_total ?? void 0,
             actual_provider: actualProvider ?? void 0,
             // Store actual provider separately (e.g., from OpenRouter)
+            standard_agents_router_used: standardAgentsRouterUsed,
             is_complete: true,
             // Now complete
             reasoning_content: response.reasoning_content ?? void 0,
@@ -1931,8 +1942,9 @@ var init_LLMRequest = __esm({
               is_complete = ?13,
               reasoning_content = ?14,
               provider_tools = ?15,
-              actual_provider = ?16
-            WHERE id = ?17
+              actual_provider = ?16,
+              standard_agents_router_used = ?17
+            WHERE id = ?18
           `,
                 logData.response_body,
                 logData.input_tokens,
@@ -1950,6 +1962,7 @@ var init_LLMRequest = __esm({
                 logData.reasoning_content,
                 providerToolsJson,
                 actualProvider,
+                standardAgentsRouterUsed ? 1 : 0,
                 logId
               );
             }
@@ -2030,11 +2043,11 @@ var init_LLMRequest = __esm({
               ...choice.message,
               images: choice.message?.images?.map(
                 (img) => {
-                  const path19 = img._id ? imagePathMap.get(img._id) : void 0;
-                  if (path19) {
+                  const path20 = img._id ? imagePathMap.get(img._id) : void 0;
+                  if (path20) {
                     return {
                       type: img.type,
-                      image_url: { url: path19 }
+                      image_url: { url: path20 }
                     };
                   }
                   return img;
@@ -2412,20 +2425,20 @@ function detectStorageBackend(location) {
     return "url";
   return "local";
 }
-function basename2(path19) {
-  const parts = path19.split("/").filter(Boolean);
+function basename2(path20) {
+  const parts = path20.split("/").filter(Boolean);
   return parts[parts.length - 1] || "";
 }
-function normalizePath(path19) {
-  let normalized = path19.replace(/\/+/g, "/");
+function normalizePath(path20) {
+  let normalized = path20.replace(/\/+/g, "/");
   if (!normalized.startsWith("/")) normalized = "/" + normalized;
   if (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
   return normalized;
 }
-function dirname3(path19) {
-  const normalized = normalizePath(path19);
+function dirname3(path20) {
+  const normalized = normalizePath(path20);
   const lastSlash = normalized.lastIndexOf("/");
   if (lastSlash <= 0) return "/";
   return normalized.slice(0, lastSlash);
@@ -2550,8 +2563,8 @@ var init_files = __esm({
        * Write a file to storage.
        * Files > CHUNK_SIZE are automatically chunked into file_chunks table.
        */
-      async writeFile(path19, data, mimeType, options) {
-        const normalizedPath = normalizePath(path19);
+      async writeFile(path20, data, mimeType, options) {
+        const normalizedPath = normalizePath(path20);
         const name = basename2(normalizedPath);
         const isText = isTextMimeType(mimeType);
         const now = Date.now();
@@ -2663,8 +2676,8 @@ var init_files = __esm({
       /**
        * Link to an external file (URL, S3, R2)
        */
-      async linkFile(path19, location, options) {
-        const normalizedPath = normalizePath(path19);
+      async linkFile(path20, location, options) {
+        const normalizedPath = normalizePath(path20);
         const name = basename2(normalizedPath);
         const storage = detectStorageBackend(location);
         const now = Date.now();
@@ -2703,8 +2716,8 @@ var init_files = __esm({
        * WARNING: For large chunked files, this loads the entire file into memory.
        * Use streamFile() for memory-efficient access to large files.
        */
-      async readFile(path19) {
-        const normalizedPath = normalizePath(path19);
+      async readFile(path20) {
+        const normalizedPath = normalizePath(path20);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -2756,8 +2769,8 @@ var init_files = __esm({
        * Memory-efficient way to read large chunked files.
        * Yields one chunk at a time for streaming HTTP responses.
        */
-      async *streamFile(path19) {
-        const normalizedPath = normalizePath(path19);
+      async *streamFile(path20) {
+        const normalizedPath = normalizePath(path20);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -2791,8 +2804,8 @@ var init_files = __esm({
       /**
        * Read text file content
        */
-      async readTextFile(path19) {
-        const normalizedPath = normalizePath(path19);
+      async readTextFile(path20) {
+        const normalizedPath = normalizePath(path20);
         const cursor = await this.sql.exec(
           `SELECT content, data, storage FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -2810,8 +2823,8 @@ var init_files = __esm({
       /**
        * Get file metadata (stat)
        */
-      async stat(path19) {
-        const normalizedPath = normalizePath(path19);
+      async stat(path20) {
+        const normalizedPath = normalizePath(path20);
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at, width, height, is_chunked, chunk_count
        FROM files WHERE path = ?`,
@@ -2824,8 +2837,8 @@ var init_files = __esm({
       /**
        * Check if file or directory exists
        */
-      async exists(path19) {
-        const normalizedPath = normalizePath(path19);
+      async exists(path20) {
+        const normalizedPath = normalizePath(path20);
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path = ?`,
           normalizedPath
@@ -2835,8 +2848,8 @@ var init_files = __esm({
       /**
        * Delete a file
        */
-      async unlink(path19) {
-        const normalizedPath = normalizePath(path19);
+      async unlink(path20) {
+        const normalizedPath = normalizePath(path20);
         await this.sql.exec(
           `DELETE FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -2846,8 +2859,8 @@ var init_files = __esm({
       /**
        * Create a directory marker
        */
-      async mkdir(path19) {
-        const normalizedPath = normalizePath(path19);
+      async mkdir(path20) {
+        const normalizedPath = normalizePath(path20);
         const name = basename2(normalizedPath);
         const now = Date.now();
         await this.sql.exec(
@@ -2872,8 +2885,8 @@ var init_files = __esm({
       /**
        * List directory contents
        */
-      async readdir(path19) {
-        const normalizedPath = normalizePath(path19);
+      async readdir(path20) {
+        const normalizedPath = normalizePath(path20);
         const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
@@ -2891,8 +2904,8 @@ var init_files = __esm({
       /**
        * Remove empty directory
        */
-      async rmdir(path19) {
-        const normalizedPath = normalizePath(path19);
+      async rmdir(path20) {
+        const normalizedPath = normalizePath(path20);
         const prefix = normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path LIKE ? || '%'`,
@@ -2934,8 +2947,8 @@ var init_files = __esm({
       /**
        * Get thumbnail for an image
        */
-      async getThumbnail(path19) {
-        const normalizedPath = normalizePath(path19);
+      async getThumbnail(path20) {
+        const normalizedPath = normalizePath(path20);
         const cursor = await this.sql.exec(
           `SELECT thumbnail FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3276,8 +3289,8 @@ var init_ToolExecutor = __esm({
             const validation = argsSchema.safeParse(args);
             if (!validation.success) {
               const errorMessage = validation.error.issues.map((issue) => {
-                const path19 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-                return `[${path19}] ${issue.message}`;
+                const path20 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+                return `[${path20}] ${issue.message}`;
               }).join("; ");
               return {
                 status: "error",
@@ -4396,8 +4409,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return [];
       }
-      static inferMimeTypeFromPath(path19) {
-        const normalized = path19.toLowerCase();
+      static inferMimeTypeFromPath(path20) {
+        const normalized = path20.toLowerCase();
         if (normalized.endsWith(".png")) return "image/png";
         if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
         if (normalized.endsWith(".webp")) return "image/webp";
@@ -4436,7 +4449,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
           ext: value.slice(lastDot + 1).toLowerCase()
         };
       }
-      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path19) {
+      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path20) {
         const source = sourceMimeType?.trim();
         if (source && source !== "application/octet-stream") {
           return source;
@@ -4445,7 +4458,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (fallback && fallback !== "application/octet-stream") {
           return fallback;
         }
-        return this.inferMimeTypeFromPath(path19) ?? source ?? fallback ?? "application/octet-stream";
+        return this.inferMimeTypeFromPath(path20) ?? source ?? fallback ?? "application/octet-stream";
       }
       static buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
         const safeName = this.sanitizeFilename(preferredName);
@@ -4541,8 +4554,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return copied;
       }
-      static async readAttachmentDataFromSource(sourceThread, path19, sourceFile) {
-        const sourceData = await sourceThread.readFile(path19);
+      static async readAttachmentDataFromSource(sourceThread, path20, sourceFile) {
+        const sourceData = await sourceThread.readFile(path20);
         if (sourceData.success && sourceData.data) {
           return sourceData.data;
         }
@@ -4576,7 +4589,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (!attachments || attachments.length === 0) {
           return "";
         }
-        const paths = attachments.map((attachment) => attachment.path).filter((path19) => typeof path19 === "string" && path19.length > 0);
+        const paths = attachments.map((attachment) => attachment.path).filter((path20) => typeof path20 === "string" && path20.length > 0);
         if (paths.length === 0) {
           return "";
         }
@@ -4872,7 +4885,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
                   mappedAttachmentValue
                 );
                 const resolvedPaths = new Set(mappedRefs.map((ref) => ref.path));
-                const missingPaths = candidatePaths.filter((path19) => !resolvedPaths.has(path19));
+                const missingPaths = candidatePaths.filter((path20) => !resolvedPaths.has(path20));
                 if (candidatePaths.length === 0 || missingPaths.length > 0) {
                   processedResult = {
                     status: "error",
@@ -5026,8 +5039,8 @@ ${attachmentPaths}`;
           if (mimeType.startsWith("image/")) {
             return true;
           }
-          const path19 = ref.path.toLowerCase();
-          return path19.endsWith(".png") || path19.endsWith(".jpg") || path19.endsWith(".jpeg") || path19.endsWith(".webp") || path19.endsWith(".gif") || path19.endsWith(".bmp") || path19.endsWith(".svg");
+          const path20 = ref.path.toLowerCase();
+          return path20.endsWith(".png") || path20.endsWith(".jpg") || path20.endsWith(".jpeg") || path20.endsWith(".webp") || path20.endsWith(".gif") || path20.endsWith(".bmp") || path20.endsWith(".svg");
         });
         if (imageRefs.length === 0) {
           return;
@@ -5093,27 +5106,27 @@ ${attachmentPaths}`;
        */
       static async processToolAttachments(attachments, state) {
         const { FileStorage: FileStorage2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-        const fs17 = new FileStorage2(state.storage.sql);
+        const fs18 = new FileStorage2(state.storage.sql);
         const refs = [];
         for (const attachment of attachments) {
           try {
             const attachmentId = crypto.randomUUID();
             const timestamp = Date.now();
             const ext = attachment.mimeType === "image/png" ? "png" : attachment.mimeType === "image/jpeg" ? "jpg" : attachment.mimeType === "image/gif" ? "gif" : attachment.mimeType === "image/webp" ? "webp" : attachment.name.split(".").pop() || "bin";
-            const path19 = `/attachments/${timestamp}-${attachmentId}.${ext}`;
+            const path20 = `/attachments/${timestamp}-${attachmentId}.${ext}`;
             const binaryString = atob(attachment.data);
             const dataBuffer = new Uint8Array(binaryString.length);
             for (let i = 0; i < binaryString.length; i++) {
               dataBuffer[i] = binaryString.charCodeAt(i);
             }
-            await fs17.writeFile(path19, dataBuffer.buffer, attachment.mimeType, {
+            await fs18.writeFile(path20, dataBuffer.buffer, attachment.mimeType, {
               width: attachment.width,
               height: attachment.height
             });
             const ref = {
               id: attachmentId,
               type: "file",
-              path: path19,
+              path: path20,
               name: attachment.name,
               mimeType: attachment.mimeType,
               size: dataBuffer.byteLength
@@ -8399,16 +8412,16 @@ ${lines.join("\n\n")}`
           const base64Data = match[2];
           const ext = mimeType.split("/")[1] || "png";
           const attachmentId = crypto.randomUUID();
-          const path19 = `/attachments/${Date.now()}-${attachmentId}.${ext}`;
+          const path20 = `/attachments/${Date.now()}-${attachmentId}.${ext}`;
           try {
-            await state.thread.instance.writeFile(path19, base64Data, mimeType);
+            await state.thread.instance.writeFile(path20, base64Data, mimeType);
             if (image.id) {
-              imagePathMap.set(image.id, path19);
+              imagePathMap.set(image.id, path20);
             }
             refs.push({
               id: attachmentId,
               type: "file",
-              path: path19,
+              path: path20,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -8469,13 +8482,13 @@ ${lines.join("\n\n")}`
           const base64Data = imageUrl.slice(base64Index + base64Marker.length);
           const ext = mimeType.split("/")[1] || "png";
           const attachmentId = crypto.randomUUID();
-          const path19 = `/attachments/${Date.now()}-${attachmentId}.${ext}`;
+          const path20 = `/attachments/${Date.now()}-${attachmentId}.${ext}`;
           try {
-            await state.thread.instance.writeFile(path19, base64Data, mimeType);
+            await state.thread.instance.writeFile(path20, base64Data, mimeType);
             const attachmentRef = {
               id: attachmentId,
               type: "file",
-              path: path19,
+              path: path20,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -8538,7 +8551,7 @@ ${lines.join("\n\n")}`
                   content: "Image generated successfully",
                   status: "success",
                   timestamp: Date.now(),
-                  attachment_path: path19
+                  attachment_path: path20
                 });
                 await state.storage.sql.exec(
                   `UPDATE logs SET tool_results = ?1 WHERE id = ?2`,
@@ -8560,7 +8573,7 @@ ${lines.join("\n\n")}`
               }
             }
             if (image.id) {
-              imagePathMap.set(image.id, path19);
+              imagePathMap.set(image.id, path20);
             }
           } catch (error) {
             console.error(`[FlowEngine] Failed to store provider tool result for ${toolName}:`, error);
@@ -9294,7 +9307,7 @@ async function updateThread(thread, params) {
   }
   return result.thread;
 }
-async function writeFile(flow, path19, data, mimeType, options) {
+async function writeFile(flow, path20, data, mimeType, options) {
   const instance = flow.thread.instance;
   let base64Data;
   if (typeof data === "string") {
@@ -9316,7 +9329,7 @@ async function writeFile(flow, path19, data, mimeType, options) {
     }
     base64Thumbnail = btoa(binary);
   }
-  const result = await instance.writeFile(path19, base64Data, mimeType, {
+  const result = await instance.writeFile(path20, base64Data, mimeType, {
     metadata: options?.metadata,
     thumbnail: base64Thumbnail
   });
@@ -9325,20 +9338,20 @@ async function writeFile(flow, path19, data, mimeType, options) {
   }
   return result.file;
 }
-async function writeImage(flow, path19, data, mimeType, options) {
-  return writeFile(flow, path19, data, mimeType, options);
+async function writeImage(flow, path20, data, mimeType, options) {
+  return writeFile(flow, path20, data, mimeType, options);
 }
-async function linkFile(flow, path19, location, options) {
+async function linkFile(flow, path20, location, options) {
   const instance = flow.thread.instance;
-  const result = await instance.linkFile(path19, location, options);
+  const result = await instance.linkFile(path20, location, options);
   if (!result.success) {
     throw new Error(result.error || "Failed to link file");
   }
   return result.file;
 }
-async function readFile(flow, path19) {
+async function readFile(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.readFile(path19);
+  const result = await instance.readFile(path20);
   if (!result.success) {
     return null;
   }
@@ -9349,45 +9362,45 @@ async function readFile(flow, path19) {
   }
   return bytes.buffer;
 }
-async function stat(flow, path19) {
+async function stat(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.statFile(path19);
+  const result = await instance.statFile(path20);
   if (!result.success) {
     return null;
   }
   return result.file;
 }
-async function exists(flow, path19) {
+async function exists(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.fileExists(path19);
+  const result = await instance.fileExists(path20);
   return result.success && result.exists;
 }
-async function unlink(flow, path19) {
+async function unlink(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.unlinkFile(path19);
+  const result = await instance.unlinkFile(path20);
   if (!result.success) {
     throw new Error(result.error || "Failed to delete file");
   }
 }
-async function mkdir(flow, path19) {
+async function mkdir(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.mkdirFile(path19);
+  const result = await instance.mkdirFile(path20);
   if (!result.success) {
     throw new Error(result.error || "Failed to create directory");
   }
   return result.directory;
 }
-async function readdir(flow, path19) {
+async function readdir(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.readdirFile(path19);
+  const result = await instance.readdirFile(path20);
   if (!result.success) {
     throw new Error(result.error || "Failed to read directory");
   }
   return result.files;
 }
-async function rmdir(flow, path19) {
+async function rmdir(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.rmdirFile(path19);
+  const result = await instance.rmdirFile(path20);
   if (!result.success) {
     throw new Error(result.error || "Failed to remove directory");
   }
@@ -9400,9 +9413,9 @@ async function getFileStats(flow) {
   }
   return result.stats;
 }
-async function getThumbnail(flow, path19) {
+async function getThumbnail(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.getFileThumbnail(path19);
+  const result = await instance.getFileThumbnail(path20);
   if (!result.success) {
     return null;
   }
@@ -9413,22 +9426,22 @@ async function getThumbnail(flow, path19) {
   }
   return bytes.buffer;
 }
-async function cat(flow, path19) {
+async function cat(flow, path20) {
   const instance = flow.thread.instance;
-  const result = await instance.readTextFile(path19);
+  const result = await instance.readTextFile(path20);
   if (!result.success) {
     return null;
   }
   return result.content;
 }
-async function head(flow, path19, lines = 10) {
-  const content = await cat(flow, path19);
+async function head(flow, path20, lines = 10) {
+  const content = await cat(flow, path20);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(0, lines).join("\n");
 }
-async function tail(flow, path19, lines = 10) {
-  const content = await cat(flow, path19);
+async function tail(flow, path20, lines = 10) {
+  const content = await cat(flow, path20);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(-lines).join("\n");
@@ -9967,32 +9980,32 @@ function prepareBridge(options, reports, logs) {
     logs
   };
 }
-function prepareNamespaceRecord(value, path19, functions) {
+function prepareNamespaceRecord(value, path20, functions) {
   const out = {};
   for (const [key, namespace] of Object.entries(value)) {
-    out[key] = prepareValueRecord(namespace, `${path19}.${key}`, functions);
+    out[key] = prepareValueRecord(namespace, `${path20}.${key}`, functions);
   }
   return out;
 }
-function prepareValueRecord(value, path19, functions) {
+function prepareValueRecord(value, path20, functions) {
   const out = {};
   for (const [key, item] of Object.entries(value)) {
-    out[key] = prepareBridgeValue(item, `${path19}.${key}`, functions);
+    out[key] = prepareBridgeValue(item, `${path20}.${key}`, functions);
   }
   return out;
 }
-function prepareBridgeValue(value, path19, functions) {
+function prepareBridgeValue(value, path20, functions) {
   if (typeof value === "function") {
-    functions.set(path19, value);
-    return { __agentbuilderType: "function", id: path19 };
+    functions.set(path20, value);
+    return { __agentbuilderType: "function", id: path20 };
   }
   if (isThenable(value)) {
-    const promiseId = `${path19}.__promise`;
+    const promiseId = `${path20}.__promise`;
     functions.set(promiseId, async () => value);
     return { __agentbuilderType: "promise", id: promiseId };
   }
   if (Array.isArray(value)) {
-    return value.map((item, index) => prepareBridgeValue(item, `${path19}.${index}`, functions));
+    return value.map((item, index) => prepareBridgeValue(item, `${path20}.${index}`, functions));
   }
   if (value && typeof value === "object") {
     if (value instanceof Date || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
@@ -10003,7 +10016,7 @@ function prepareBridgeValue(value, path19, functions) {
     }
     const out = {};
     for (const [key, item] of Object.entries(value)) {
-      out[key] = prepareBridgeValue(item, `${path19}.${key}`, functions);
+      out[key] = prepareBridgeValue(item, `${path20}.${key}`, functions);
     }
     return out;
   }
@@ -10878,12 +10891,12 @@ function normalizeVirtualModulePath(basePath, specifier) {
   }
   return normalized;
 }
-function dirnameModulePath(path19) {
-  const index = path19.lastIndexOf("/");
-  return index <= 0 ? "" : path19.slice(0, index);
+function dirnameModulePath(path20) {
+  const index = path20.lastIndexOf("/");
+  return index <= 0 ? "" : path20.slice(0, index);
 }
-function hasModuleExtension(path19) {
-  return /\.[A-Za-z0-9]+$/.test(path19);
+function hasModuleExtension(path20) {
+  return /\.[A-Za-z0-9]+$/.test(path20);
 }
 function resolveGraphModuleSpecifier(fromPath, specifier, modulePaths) {
   const base = normalizeVirtualModulePath(dirnameModulePath(fromPath), specifier);
@@ -11214,9 +11227,9 @@ function isPlainObject2(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function findUntransferableOption(value, path19, seen = /* @__PURE__ */ new WeakSet()) {
+function findUntransferableOption(value, path20, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value === "function" || typeof value === "symbol") {
-    return path19;
+    return path20;
   }
   if (!value || typeof value !== "object") {
     return null;
@@ -11230,7 +11243,7 @@ function findUntransferableOption(value, path19, seen = /* @__PURE__ */ new Weak
   seen.add(value);
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      const found = findUntransferableOption(item, `${path19}.${index}`, seen);
+      const found = findUntransferableOption(item, `${path20}.${index}`, seen);
       if (found) return found;
     }
     return null;
@@ -11238,9 +11251,9 @@ function findUntransferableOption(value, path19, seen = /* @__PURE__ */ new Weak
   if (value instanceof Map) {
     let index = 0;
     for (const [key, item] of value.entries()) {
-      const foundKey = findUntransferableOption(key, `${path19}.mapKey${index}`, seen);
+      const foundKey = findUntransferableOption(key, `${path20}.mapKey${index}`, seen);
       if (foundKey) return foundKey;
-      const foundValue = findUntransferableOption(item, `${path19}.mapValue${index}`, seen);
+      const foundValue = findUntransferableOption(item, `${path20}.mapValue${index}`, seen);
       if (foundValue) return foundValue;
       index += 1;
     }
@@ -11249,17 +11262,17 @@ function findUntransferableOption(value, path19, seen = /* @__PURE__ */ new Weak
   if (value instanceof Set) {
     let index = 0;
     for (const item of value.values()) {
-      const found = findUntransferableOption(item, `${path19}.setValue${index}`, seen);
+      const found = findUntransferableOption(item, `${path20}.setValue${index}`, seen);
       if (found) return found;
       index += 1;
     }
     return null;
   }
   if (!isPlainObject2(value)) {
-    return path19;
+    return path20;
   }
   for (const [key, item] of Object.entries(value)) {
-    const found = findUntransferableOption(item, `${path19}.${key}`, seen);
+    const found = findUntransferableOption(item, `${path20}.${key}`, seen);
     if (found) return found;
   }
   return null;
@@ -11769,7 +11782,7 @@ var init_ThreadStateImpl = __esm({
       // ─────────────────────────────────────────────────────────────────────────
       // File System
       // ─────────────────────────────────────────────────────────────────────────
-      async writeFile(path19, data, mimeType, options) {
+      async writeFile(path20, data, mimeType, options) {
         const isText = this._isTextMimeType(mimeType);
         if (isText) {
           let textContent;
@@ -11778,7 +11791,7 @@ var init_ThreadStateImpl = __esm({
           } else {
             textContent = new TextDecoder().decode(data);
           }
-          const result = await this._threadInstance.writeTextFile(path19, textContent, mimeType, options);
+          const result = await this._threadInstance.writeTextFile(path20, textContent, mimeType, options);
           return this._mapFileRecord(result.file);
         } else {
           let base64Data;
@@ -11798,7 +11811,7 @@ var init_ThreadStateImpl = __esm({
             }
             base64Data = btoa(binary);
           }
-          const result = await this._threadInstance.writeFile(path19, base64Data, mimeType, options);
+          const result = await this._threadInstance.writeFile(path20, base64Data, mimeType, options);
           return this._mapFileRecord(result.file);
         }
       }
@@ -11870,8 +11883,8 @@ var init_ThreadStateImpl = __esm({
           (type) => mimeType === type || mimeType.startsWith(type + ";")
         );
       }
-      async readFile(path19) {
-        const result = await this._threadInstance.readFile(path19);
+      async readFile(path20) {
+        const result = await this._threadInstance.readFile(path20);
         if (!result.success || !result.data) {
           return null;
         }
@@ -11882,8 +11895,8 @@ var init_ThreadStateImpl = __esm({
         }
         return bytes.buffer;
       }
-      async readFileStream(path19, options) {
-        const fileInfo = await this._threadInstance.statFile(path19);
+      async readFileStream(path20, options) {
+        const fileInfo = await this._threadInstance.statFile(path20);
         if (!fileInfo) {
           return null;
         }
@@ -11898,7 +11911,7 @@ var init_ThreadStateImpl = __esm({
         return {
           [Symbol.asyncIterator]: async function* () {
             if (!isChunked) {
-              const result = await threadInstance.readFile(path19);
+              const result = await threadInstance.readFile(path20);
               if (!result.success || !result.data) {
                 return;
               }
@@ -11919,7 +11932,7 @@ var init_ThreadStateImpl = __esm({
               if (signal?.aborted) {
                 return;
               }
-              const result = await threadInstance.readFileChunk(path19, i);
+              const result = await threadInstance.readFileChunk(path20, i);
               if (!result.success || !result.data) {
                 throw new Error(result.error || `Failed to read chunk ${i}`);
               }
@@ -11938,25 +11951,25 @@ var init_ThreadStateImpl = __esm({
           }
         };
       }
-      async statFile(path19) {
-        const result = await this._threadInstance.statFile(path19);
+      async statFile(path20) {
+        const result = await this._threadInstance.statFile(path20);
         return result ? this._mapFileRecord(result) : null;
       }
-      async readdirFile(path19) {
-        const entries = await this._threadInstance.readdirFile(path19);
+      async readdirFile(path20) {
+        const entries = await this._threadInstance.readdirFile(path20);
         return {
           entries: entries.map((e) => this._mapFileRecord(e))
         };
       }
-      async unlinkFile(path19) {
-        await this._threadInstance.unlinkFile(path19);
+      async unlinkFile(path20) {
+        await this._threadInstance.unlinkFile(path20);
       }
-      async mkdirFile(path19) {
-        const result = await this._threadInstance.mkdirFile(path19);
+      async mkdirFile(path20) {
+        const result = await this._threadInstance.mkdirFile(path20);
         return this._mapFileRecord(result);
       }
-      async rmdirFile(path19) {
-        await this._threadInstance.rmdirFile(path19);
+      async rmdirFile(path20) {
+        await this._threadInstance.rmdirFile(path20);
       }
       async getFileStats() {
         const stats = await this._threadInstance.getFileStats();
@@ -11979,8 +11992,8 @@ var init_ThreadStateImpl = __esm({
           paths: Array.isArray(results) ? results : results.paths || []
         };
       }
-      async getFileThumbnail(path19) {
-        return this._threadInstance.getFileThumbnail(path19);
+      async getFileThumbnail(path20) {
+        return this._threadInstance.getFileThumbnail(path20);
       }
       // ─────────────────────────────────────────────────────────────────────────
       // Execution State
@@ -12293,15 +12306,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];
@@ -12317,15 +12330,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];
@@ -12345,15 +12358,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")) {
@@ -12374,18 +12387,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]);
@@ -12852,6 +12865,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;
@@ -13009,44 +13050,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;
         }
@@ -13233,7 +13274,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;
@@ -13244,10 +13285,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")) {
@@ -13399,6 +13440,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) {
@@ -14019,19 +14127,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.`
@@ -14048,7 +14156,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
@@ -14063,13 +14171,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
@@ -14330,26 +14438,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
@@ -14364,13 +14472,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
@@ -14386,25 +14494,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
@@ -14704,15 +14812,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];
@@ -14729,17 +14837,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;
@@ -14755,7 +14863,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
@@ -14770,13 +14878,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
@@ -14792,25 +14900,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
@@ -14824,17 +14932,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);
     }
   }
@@ -14842,13 +14950,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) => {
@@ -14861,7 +14969,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);
     }
   }
@@ -14869,17 +14977,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);
     }
   }
@@ -15006,16 +15114,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;
@@ -15049,7 +15157,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,
@@ -15061,26 +15169,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);
       }
     }
@@ -15088,26 +15196,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;
@@ -15137,7 +15245,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()`;
@@ -15149,15 +15257,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) {
@@ -15184,18 +15292,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) {
@@ -15218,16 +15326,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({
@@ -15269,20 +15377,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;
         }
@@ -15769,7 +15877,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.
@@ -15779,11 +15887,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;
@@ -15796,11 +15904,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.
@@ -15809,8 +15917,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);
     }
   }
   /**
@@ -15891,7 +15999,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;
@@ -16263,9 +16371,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 "*";
@@ -16282,7 +16390,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: "",
@@ -16306,7 +16414,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;
@@ -16317,7 +16425,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;
@@ -16342,13 +16450,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 {
       }
@@ -16372,7 +16480,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)) {
@@ -16394,15 +16502,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;
     }
@@ -16410,8 +16518,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;
@@ -16438,7 +16546,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)) {
@@ -16460,15 +16568,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;
     }
@@ -16476,8 +16584,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;
@@ -16501,7 +16609,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;
@@ -16520,7 +16628,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);
@@ -16546,17 +16654,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;
@@ -16574,7 +16682,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);
@@ -16584,7 +16692,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;
@@ -16603,7 +16711,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);
@@ -16616,7 +16724,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;
@@ -16635,7 +16743,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);
@@ -16645,13 +16753,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);
@@ -16683,19 +16791,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);
@@ -16768,14 +16876,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) {
@@ -16829,13 +16937,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)) {
@@ -16845,12 +16953,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,
@@ -16863,13 +16971,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;
@@ -16877,7 +16985,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(
@@ -16888,21 +16996,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,
@@ -16936,7 +17044,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",
@@ -16945,14 +17053,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`;
             }
           }
@@ -17001,11 +17109,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();
@@ -17430,30 +17538,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,
@@ -17471,11 +17579,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.
@@ -17522,17 +17630,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;
@@ -17544,15 +17652,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);
@@ -17568,7 +17676,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
     };
@@ -17601,19 +17709,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) {
@@ -17621,7 +17729,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);
@@ -17637,12 +17745,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
@@ -17679,21 +17787,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 stat2 = fs7.statSync(pkgDir);
+      const pkgDir = path8.join(this.config.packedDir, entry);
+      const stat2 = fs8.statSync(pkgDir);
       if (!stat2.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);
@@ -17716,12 +17824,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;
       }
@@ -17746,10 +17854,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;
   }
   /**
@@ -17846,29 +17954,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,
@@ -17878,10 +17986,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;
           }
@@ -17984,8 +18092,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;
@@ -18010,17 +18118,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(
@@ -18109,14 +18217,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,
@@ -18128,11 +18236,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,
@@ -18173,18 +18281,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 });
     }
   }
   /**
@@ -18260,8 +18368,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: "",
@@ -18271,7 +18379,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) {
@@ -18281,13 +18389,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");
@@ -18319,8 +18427,8 @@ registry=${registry}
       };
     } finally {
       try {
-        if (fs7.existsSync(npmrcPath)) {
-          fs7.unlinkSync(npmrcPath);
+        if (fs8.existsSync(npmrcPath)) {
+          fs8.unlinkSync(npmrcPath);
         }
       } catch {
       }
@@ -18413,7 +18521,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,
@@ -18466,8 +18574,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");
@@ -18495,8 +18603,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]);
@@ -18552,16 +18660,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, "-")}`
         );
@@ -18573,14 +18681,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();
@@ -18692,6 +18800,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,
@@ -18723,6 +18848,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,
@@ -18753,6 +18891,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;
@@ -18761,13 +18907,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;
@@ -18778,30 +18949,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",
@@ -18836,7 +19004,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;
   };
@@ -19066,7 +19234,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;
   };
@@ -19094,23 +19262,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,
@@ -19228,7 +19396,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(
@@ -19239,20 +19407,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}`;
@@ -19292,12 +19460,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
 ];
 
@@ -19318,6 +19493,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;
 }
 
@@ -19582,12 +19771,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}",
@@ -19757,14 +19946,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]
@@ -19821,14 +20010,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 = {
@@ -19845,11 +20034,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);
   }
@@ -19959,28 +20148,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();
@@ -19989,7 +20178,7 @@ function agentbuilder(options = {}) {
               htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
               content = Buffer.from(htmlContent);
             }
-            fs7__default.writeFileSync(destPath, content);
+            fs8__default.writeFileSync(destPath, content);
           }
         }
       }
@@ -21003,8 +21192,27 @@ var migration29 = {
   }
 };
 
+// src/durable-objects/migrations/030_add_standard_agents_router_used.ts
+var migration30 = {
+  version: 30,
+  name: "add_standard_agents_router_used",
+  async up(sql) {
+    const tableInfo = sql.exec(`PRAGMA table_info(logs)`).toArray();
+    const hasRouterUsed = tableInfo.some((col) => col.name === "standard_agents_router_used");
+    if (!hasRouterUsed) {
+      await sql.exec(`
+        ALTER TABLE logs ADD COLUMN standard_agents_router_used INTEGER NOT NULL DEFAULT 0;
+      `);
+      await sql.exec(`
+        CREATE INDEX IF NOT EXISTS idx_logs_standard_agents_router_used
+          ON logs(standard_agents_router_used);
+      `);
+    }
+  }
+};
+
 // src/durable-objects/migrations/index.ts
-var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16, migration17, migration18, migration19, migration20, migration21, migration22, migration23, migration24, migration25, migration26, migration27, migration28, migration29];
+var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16, migration17, migration18, migration19, migration20, migration21, migration22, migration23, migration24, migration25, migration26, migration27, migration28, migration29, migration30];
 var LATEST_SCHEMA_VERSION = migrations.length;
 
 // src/durable-objects/DurableThread.ts
@@ -21773,12 +21981,12 @@ function isQualifiedName(name) {
 init_sessionTools();
 init_code_execution();
 var RUNTIME_STORAGE_PREFIX = "__agentbuilder_runtime_storage__:";
-function normalizeEndpointThreadPath(path19) {
-  if (!path19 || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path19)) {
+function normalizeEndpointThreadPath(path20) {
+  if (!path20 || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path20)) {
     throw new Error("Use a relative thread filesystem path");
   }
   const parts = [];
-  for (const part of path19.replace(/\\/g, "/").split("/")) {
+  for (const part of path20.replace(/\\/g, "/").split("/")) {
     if (!part || part === ".") continue;
     if (part === "..") {
       if (parts.length === 0) throw new Error("Path cannot escape the thread filesystem root");
@@ -21828,12 +22036,12 @@ function createEndpointFetchBridge() {
 function createEndpointFsBridge(state) {
   const decoder = new TextDecoder();
   return {
-    readFile: async (path19) => {
-      const data = await state.readFile(normalizeEndpointThreadPath(path19));
+    readFile: async (path20) => {
+      const data = await state.readFile(normalizeEndpointThreadPath(path20));
       return data ? decoder.decode(data) : null;
     },
-    writeFile: async (path19, content, mimeType = "text/plain") => {
-      return state.writeFile(normalizeEndpointThreadPath(path19), content, mimeType);
+    writeFile: async (path20, content, mimeType = "text/plain") => {
+      return state.writeFile(normalizeEndpointThreadPath(path20), content, mimeType);
     }
   };
 }
@@ -21901,19 +22109,19 @@ function createEndpointThreadStateBridge(state) {
     emit: (event, data) => state.emit(event, data),
     getValue: (key) => state.getValue(key),
     setValue: (key, value) => state.setValue(key, value),
-    readFile: (path19) => state.readFile(normalizeEndpointThreadPath(path19)),
-    writeFile: (path19, data, mimeType = "application/octet-stream", options) => {
-      return state.writeFile(normalizeEndpointThreadPath(path19), data, mimeType, options);
+    readFile: (path20) => state.readFile(normalizeEndpointThreadPath(path20)),
+    writeFile: (path20, data, mimeType = "application/octet-stream", options) => {
+      return state.writeFile(normalizeEndpointThreadPath(path20), data, mimeType, options);
     },
-    statFile: (path19) => state.statFile(normalizeEndpointThreadPath(path19)),
-    readdirFile: (path19) => state.readdirFile(normalizeEndpointThreadPath(path19)),
-    unlinkFile: (path19) => state.unlinkFile(normalizeEndpointThreadPath(path19)),
-    mkdirFile: (path19) => state.mkdirFile(normalizeEndpointThreadPath(path19)),
-    rmdirFile: (path19) => state.rmdirFile(normalizeEndpointThreadPath(path19)),
+    statFile: (path20) => state.statFile(normalizeEndpointThreadPath(path20)),
+    readdirFile: (path20) => state.readdirFile(normalizeEndpointThreadPath(path20)),
+    unlinkFile: (path20) => state.unlinkFile(normalizeEndpointThreadPath(path20)),
+    mkdirFile: (path20) => state.mkdirFile(normalizeEndpointThreadPath(path20)),
+    rmdirFile: (path20) => state.rmdirFile(normalizeEndpointThreadPath(path20)),
     getFileStats: () => state.getFileStats(),
     grepFiles: (pattern) => state.grepFiles(pattern),
     findFiles: (pattern) => state.findFiles(pattern),
-    getFileThumbnail: (path19) => state.getFileThumbnail(normalizeEndpointThreadPath(path19))
+    getFileThumbnail: (path20) => state.getFileThumbnail(normalizeEndpointThreadPath(path20))
   };
 }
 var DurableThread = class extends DurableObject {
@@ -21941,7 +22149,14 @@ var DurableThread = class extends DurableObject {
             );
             break;
           case "processMessage":
-            await this.processMessage(args.threadId, args.content, args.role, args.attachments);
+            await this.processMessage(
+              args.threadId,
+              args.content,
+              args.role,
+              args.attachments,
+              args.messageId,
+              args.queuedAt
+            );
             break;
           case "testOperation":
             await this.testOperation(args.id, args.label, args.expectedOrder);
@@ -22456,7 +22671,7 @@ var DurableThread = class extends DurableObject {
     this.assertJsonSerializableThreadValue(value, "$", /* @__PURE__ */ new WeakSet());
     return JSON.stringify(value);
   }
-  assertJsonSerializableThreadValue(value, path19, seen) {
+  assertJsonSerializableThreadValue(value, path20, seen) {
     if (value === null) {
       return;
     }
@@ -22466,36 +22681,36 @@ var DurableThread = class extends DurableObject {
         return;
       case "number":
         if (!Number.isFinite(value)) {
-          throw new Error(`Thread value at ${path19} must be a finite number`);
+          throw new Error(`Thread value at ${path20} must be a finite number`);
         }
         return;
       case "object": {
         if (seen.has(value)) {
-          throw new Error(`Thread value at ${path19} cannot contain circular references`);
+          throw new Error(`Thread value at ${path20} cannot contain circular references`);
         }
         seen.add(value);
         if (Array.isArray(value)) {
           for (let i = 0; i < value.length; i += 1) {
-            this.assertJsonSerializableThreadValue(value[i], `${path19}[${i}]`, seen);
+            this.assertJsonSerializableThreadValue(value[i], `${path20}[${i}]`, seen);
           }
           seen.delete(value);
           return;
         }
         const prototype = Object.getPrototypeOf(value);
         if (prototype !== Object.prototype && prototype !== null) {
-          throw new Error(`Thread value at ${path19} must be a JSON object, array, or primitive`);
+          throw new Error(`Thread value at ${path20} must be a JSON object, array, or primitive`);
         }
         if (Object.getOwnPropertySymbols(value).length > 0) {
-          throw new Error(`Thread value at ${path19} cannot contain symbol keys`);
+          throw new Error(`Thread value at ${path20} cannot contain symbol keys`);
         }
         for (const [entryKey, entryValue] of Object.entries(value)) {
-          this.assertJsonSerializableThreadValue(entryValue, `${path19}.${entryKey}`, seen);
+          this.assertJsonSerializableThreadValue(entryValue, `${path20}.${entryKey}`, seen);
         }
         seen.delete(value);
         return;
       }
       default:
-        throw new Error(`Thread value at ${path19} must be JSON-serializable`);
+        throw new Error(`Thread value at ${path20} must be JSON-serializable`);
     }
   }
   // ============================================================
@@ -22720,17 +22935,37 @@ var DurableThread = class extends DurableObject {
     await this.assertNotTerminated();
     const id = crypto.randomUUID();
     const now = Date.now() * 1e3;
+    const attachmentsJson = message.attachments ? JSON.stringify(message.attachments) : null;
+    const metadataJson = message.metadata ? JSON.stringify(message.metadata) : null;
     await this.ctx.storage.sql.exec(
       `INSERT INTO message_queue (id, role, content, attachments, silent, metadata, created_at)
        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)`,
       id,
       message.role,
       message.content,
-      message.attachments ? JSON.stringify(message.attachments) : null,
+      attachmentsJson,
       message.silent ? 1 : 0,
-      message.metadata ? JSON.stringify(message.metadata) : null,
+      metadataJson,
       now
     );
+    if (this.messageSockets?.size > 0) {
+      await this.broadcastMessageWithSubagentProjection({
+        id,
+        role: message.role,
+        content: message.content,
+        attachments: message.attachments ?? null,
+        silent: !!message.silent,
+        created_at: now,
+        status: "pending",
+        depth: 0,
+        metadata: {
+          ...message.metadata ?? {},
+          queued: true,
+          queue_status: "queued"
+        },
+        subagent_id: this.extractSubagentIdFromMetadata(metadataJson)
+      });
+    }
     const side = message.role === "user" ? "a" : "b";
     await this.ensureQueuedMessageExecution(threadId, side);
   }
@@ -22934,9 +23169,9 @@ var DurableThread = class extends DurableObject {
    * Each migration is run in order, starting from the current version + 1.
    */
   async runMigrations(fromVersion) {
-    for (const migration35 of migrations) {
-      if (migration35.version > fromVersion) {
-        await migration35.up(this.ctx.storage.sql);
+    for (const migration37 of migrations) {
+      if (migration37.version > fromVersion) {
+        await migration37.up(this.ctx.storage.sql);
       }
     }
   }
@@ -23182,21 +23417,42 @@ var DurableThread = class extends DurableObject {
     await this.ensureMigrated();
     try {
       await this.assertNotTerminated();
+      const messageId = crypto.randomUUID();
+      const queuedAt = Date.now() * 1e3;
       const queueId = await this.alarmQueue.enqueue(
         "processMessage",
         {
           threadId,
           content,
           role,
-          attachments
+          attachments,
+          messageId,
+          queuedAt
         },
         1
         // Execute almost immediately (1ms)
       );
+      this.broadcastMessage({
+        id: messageId,
+        role,
+        content,
+        attachments: this.parseAttachmentRefsJson(attachments ?? null) ?? null,
+        created_at: queuedAt,
+        status: "pending",
+        depth: 0,
+        silent: false,
+        metadata: {
+          queued: true,
+          queue_status: "queued",
+          queue_source: "alarm_queue",
+          alarm_queue_id: queueId
+        }
+      });
       return Response.json(
         {
           status: "queued",
           queueId,
+          messageId,
           message: "Message queued for processing. Connect via WebSocket for real-time updates."
         },
         { status: 202 }
@@ -23300,6 +23556,78 @@ var DurableThread = class extends DurableObject {
       return void 0;
     }
   }
+  async deleteAttachmentRefsFromJson(raw) {
+    const refs = this.parseAttachmentRefsJson(raw);
+    if (!refs) {
+      return;
+    }
+    for (const ref of refs) {
+      if (ref.path) {
+        await this.unlinkFile(ref.path);
+      }
+    }
+  }
+  async cancelQueuedMessage(messageId) {
+    let cancelled = false;
+    const queuedRows = await this.ctx.storage.sql.exec(
+      `SELECT id, attachments FROM message_queue WHERE id = ?`,
+      messageId
+    ).toArray();
+    for (const row of queuedRows) {
+      await this.deleteAttachmentRefsFromJson(row.attachments);
+      await this.ctx.storage.sql.exec(
+        `DELETE FROM message_queue WHERE id = ?`,
+        row.id
+      );
+      cancelled = true;
+    }
+    const alarmRows = await this.ctx.storage.sql.exec(
+      `
+        SELECT id, args
+        FROM alarm_queue
+        WHERE method = 'processMessage'
+          AND status = 'pending'
+          AND (
+            id = ?
+            OR json_extract(args, '$.messageId') = ?
+          )
+      `,
+      messageId,
+      messageId
+    ).toArray();
+    for (const row of alarmRows) {
+      try {
+        const args = JSON.parse(row.args);
+        if (typeof args.attachments === "string") {
+          await this.deleteAttachmentRefsFromJson(args.attachments);
+        }
+      } catch (error) {
+        console.error("[DurableThread] Failed to parse queued message args:", error);
+      }
+      await this.ctx.storage.sql.exec(
+        `DELETE FROM alarm_queue WHERE id = ? AND status = 'pending'`,
+        row.id
+      );
+      cancelled = true;
+    }
+    return cancelled;
+  }
+  parseMessageMetadata(raw) {
+    if (typeof raw !== "string") {
+      return void 0;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  extractSubagentIdFromMetadata(raw) {
+    const metadata = this.parseMessageMetadata(raw);
+    const value = typeof metadata?.subagent_id === "string" ? metadata.subagent_id : typeof metadata?.subagentId === "string" ? metadata.subagentId : null;
+    return value && value.trim().length > 0 ? value.trim() : null;
+  }
   async getLatestTerminalSessionMessageAfter(messageId, terminalToolNames) {
     const toolNames = Array.from(terminalToolNames);
     if (toolNames.length === 0) {
@@ -23330,8 +23658,8 @@ var DurableThread = class extends DurableObject {
     );
     return terminalCursor.toArray()[0] ?? null;
   }
-  inferMimeTypeFromPath(path19) {
-    const normalized = path19.toLowerCase();
+  inferMimeTypeFromPath(path20) {
+    const normalized = path20.toLowerCase();
     if (normalized.endsWith(".png")) return "image/png";
     if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
     if (normalized.endsWith(".webp")) return "image/webp";
@@ -23370,7 +23698,7 @@ var DurableThread = class extends DurableObject {
       ext: value.slice(lastDot + 1).toLowerCase()
     };
   }
-  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path19) {
+  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path20) {
     const source = sourceMimeType?.trim();
     if (source && source !== "application/octet-stream") {
       return source;
@@ -23379,7 +23707,7 @@ var DurableThread = class extends DurableObject {
     if (fallback && fallback !== "application/octet-stream") {
       return fallback;
     }
-    return this.inferMimeTypeFromPath(path19) ?? source ?? fallback ?? "application/octet-stream";
+    return this.inferMimeTypeFromPath(path20) ?? source ?? fallback ?? "application/octet-stream";
   }
   buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
     const safeName = this.sanitizeFilename(preferredName);
@@ -23474,8 +23802,8 @@ var DurableThread = class extends DurableObject {
     }
     return copied;
   }
-  async readAttachmentDataFromSource(path19, sourceFile) {
-    const sourceData = await this.readFile(path19);
+  async readAttachmentDataFromSource(path20, sourceFile) {
+    const sourceData = await this.readFile(path20);
     if (sourceData.success && sourceData.data) {
       return sourceData.data;
     }
@@ -23509,7 +23837,7 @@ var DurableThread = class extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path19) => typeof path19 === "string" && path19.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path20) => typeof path20 === "string" && path20.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -23852,22 +24180,163 @@ ${resultContent}${attachmentSummary}`;
       }
       whereClauses.push(`(depth <= ${maxDepth} OR depth IS NULL)`);
       const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+      const orderDirection = order === "ASC" ? "ASC" : "DESC";
+      const combinedMessagesSql = `
+        WITH combined_messages AS (
+          SELECT
+            rowid AS source_rowid,
+            0 AS source_order,
+            'message' AS source,
+            id, role, content, name, tool_calls, tool_call_id, tool_status,
+            log_id, created_at, silent, parent_id, depth, status,
+            reasoning_content, reasoning_details, attachments, metadata,
+            subagent_id
+          FROM messages
+          UNION ALL
+          SELECT
+            rowid AS source_rowid,
+            1 AS source_order,
+            'queue' AS source,
+            id, role, content, NULL AS name, NULL AS tool_calls,
+            NULL AS tool_call_id, NULL AS tool_status, NULL AS log_id,
+            created_at, silent, NULL AS parent_id, 0 AS depth,
+            'pending' AS status, NULL AS reasoning_content,
+            NULL AS reasoning_details, attachments, metadata,
+            NULL AS subagent_id
+          FROM message_queue
+          UNION ALL
+          SELECT
+            rowid AS source_rowid,
+            2 AS source_order,
+            'send_queue' AS source,
+            COALESCE(json_extract(args, '$.messageId'), id) AS id,
+            COALESCE(json_extract(args, '$.role'), 'user') AS role,
+            json_extract(args, '$.content') AS content,
+            NULL AS name, NULL AS tool_calls,
+            NULL AS tool_call_id, NULL AS tool_status, NULL AS log_id,
+            created_at, 0 AS silent, NULL AS parent_id, 0 AS depth,
+            'pending' AS status, NULL AS reasoning_content,
+            NULL AS reasoning_details,
+            json_extract(args, '$.attachments') AS attachments,
+            NULL AS metadata,
+            NULL AS subagent_id
+          FROM alarm_queue
+          WHERE method = 'processMessage'
+            AND status IN ('pending', 'processing')
+            AND (
+              status = 'pending'
+              OR json_extract(args, '$.messageId') IS NOT NULL
+            )
+            AND NOT EXISTS (
+              SELECT 1
+              FROM messages persisted
+              WHERE persisted.id = COALESCE(json_extract(alarm_queue.args, '$.messageId'), alarm_queue.id)
+            )
+        )
+      `;
       const countResult = await this.ctx.storage.sql.exec(
-        `SELECT COUNT(*) as total FROM messages ${whereClause}`
+        `
+        ${combinedMessagesSql}
+        SELECT COUNT(*) as total FROM combined_messages ${whereClause}
+      `
       );
       const total = countResult.one().total;
       const result = await this.ctx.storage.sql.exec(
         `
-        SELECT id, role, content, name, tool_calls, tool_call_id, tool_status, log_id, created_at, silent, parent_id, depth, status, reasoning_content, reasoning_details, attachments, metadata, subagent_id
-        FROM messages
+        ${combinedMessagesSql}
+        SELECT source, id, role, content, name, tool_calls, tool_call_id,
+          tool_status, log_id, created_at, silent, parent_id, depth, status,
+          reasoning_content, reasoning_details, attachments, metadata,
+          subagent_id
+        FROM combined_messages
         ${whereClause}
-        ORDER BY created_at ${order === "ASC" ? "ASC" : "DESC"}, rowid ${order === "ASC" ? "ASC" : "DESC"}
+        ORDER BY created_at ${orderDirection}, source_order ${orderDirection}, source_rowid ${orderDirection}
         LIMIT ? OFFSET ?
       `,
         limit,
         offset
       );
       let messages = result.toArray().map((row) => {
+        const metadata = this.parseMessageMetadata(row.metadata);
+        const isQueuedSource = row.source === "queue" || row.source === "send_queue";
+        const messageMetadata = isQueuedSource ? {
+          ...metadata ?? {},
+          queued: true,
+          queue_status: "queued",
+          queue_source: row.source === "send_queue" ? "alarm_queue" : "message_queue"
+        } : metadata;
+        return {
+          id: row.id,
+          role: row.role,
+          content: row.content,
+          name: row.name,
+          tool_calls: row.tool_calls,
+          tool_call_id: row.tool_call_id,
+          tool_status: row.tool_status,
+          log_id: row.log_id,
+          created_at: row.created_at,
+          silent: row.silent === 1,
+          parent_id: row.parent_id,
+          depth: row.depth,
+          status: row.status,
+          reasoning_content: row.reasoning_content,
+          reasoning_details: row.reasoning_details,
+          attachments: row.attachments ? JSON.parse(row.attachments) : null,
+          metadata: messageMetadata,
+          subagent_id: row.subagent_id ?? (row.source === "queue" ? this.extractSubagentIdFromMetadata(row.metadata) : null)
+        };
+      });
+      const subagentIds = Array.from(
+        new Set(
+          messages.map(
+            (message) => typeof message.subagent_id === "string" ? message.subagent_id.trim() : ""
+          ).filter((id) => id.length > 0)
+        )
+      );
+      if (subagentIds.length > 0) {
+        const projectionMap = await this.resolveSubagentMessageProjections(
+          subagentIds
+        );
+        messages = messages.map((message) => {
+          const subagentId = typeof message.subagent_id === "string" ? message.subagent_id.trim() : "";
+          if (!subagentId) {
+            return message;
+          }
+          const projection = projectionMap.get(subagentId);
+          return projection ? { ...message, ...projection } : message;
+        });
+      }
+      if (order === "DESC") {
+        messages = messages.reverse();
+      }
+      const hasMore = offset + messages.length < total;
+      return { messages, total, hasMore };
+    } catch (error) {
+      console.error("Error in getMessages:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get specific messages, optionally expanding any requested tool-call message
+   * to the full contiguous workblock it belongs to.
+   */
+  async getMessagesByIds(ids, includeSilent = false, maxDepth = 0, includeWorkblocks = false) {
+    await this.ensureMigrated();
+    const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    if (uniqueIds.length === 0) {
+      return { messages: [], total: 0, hasMore: false };
+    }
+    if (uniqueIds.length > 200) {
+      throw new Error("Too many message IDs requested");
+    }
+    const whereClauses = [];
+    if (!includeSilent) {
+      whereClauses.push("silent = 0");
+    }
+    whereClauses.push(`(depth <= ${maxDepth} OR depth IS NULL)`);
+    const baseWhereClause = whereClauses.length > 0 ? whereClauses.join(" AND ") : "1 = 1";
+    const mapRows = async (rows) => {
+      let messages2 = rows.map((row) => {
         let metadata;
         if (typeof row.metadata === "string") {
           try {
@@ -23902,7 +24371,7 @@ ${resultContent}${attachmentSummary}`;
       });
       const subagentIds = Array.from(
         new Set(
-          messages.map(
+          messages2.map(
             (message) => typeof message.subagent_id === "string" ? message.subagent_id.trim() : ""
           ).filter((id) => id.length > 0)
         )
@@ -23911,7 +24380,7 @@ ${resultContent}${attachmentSummary}`;
         const projectionMap = await this.resolveSubagentMessageProjections(
           subagentIds
         );
-        messages = messages.map((message) => {
+        messages2 = messages2.map((message) => {
           const subagentId = typeof message.subagent_id === "string" ? message.subagent_id.trim() : "";
           if (!subagentId) {
             return message;
@@ -23920,15 +24389,61 @@ ${resultContent}${attachmentSummary}`;
           return projection ? { ...message, ...projection } : message;
         });
       }
-      if (order === "DESC") {
-        messages = messages.reverse();
+      return messages2;
+    };
+    const selectColumns = `
+      id, role, content, name, tool_calls, tool_call_id, tool_status, log_id,
+      created_at, silent, parent_id, depth, status, reasoning_content,
+      reasoning_details, attachments, metadata, subagent_id
+    `;
+    if (!includeWorkblocks) {
+      const placeholders = uniqueIds.map(() => "?").join(", ");
+      const rows = await this.ctx.storage.sql.exec(
+        `
+          SELECT ${selectColumns}
+          FROM messages
+          WHERE ${baseWhereClause} AND id IN (${placeholders})
+          ORDER BY created_at ASC, rowid ASC
+        `,
+        ...uniqueIds
+      ).toArray();
+      const messages2 = await mapRows(rows);
+      return { messages: messages2, total: messages2.length, hasMore: false };
+    }
+    const allRows = await this.ctx.storage.sql.exec(
+      `
+        SELECT ${selectColumns}
+        FROM messages
+        WHERE ${baseWhereClause}
+        ORDER BY created_at ASC, rowid ASC
+      `
+    ).toArray();
+    const requestedIds = new Set(uniqueIds);
+    const selectedIds = /* @__PURE__ */ new Set();
+    const isWorkblockRow = (row) => row.role === "tool" || row.role === "assistant" && typeof row.tool_calls === "string" && row.tool_calls.length > 0;
+    for (let index = 0; index < allRows.length; index++) {
+      const row = allRows[index];
+      if (!requestedIds.has(row.id)) continue;
+      if (!isWorkblockRow(row)) {
+        selectedIds.add(row.id);
+        continue;
+      }
+      let start = index;
+      while (start > 0 && isWorkblockRow(allRows[start - 1])) {
+        start--;
+      }
+      let end = index;
+      while (end + 1 < allRows.length && isWorkblockRow(allRows[end + 1])) {
+        end++;
+      }
+      for (let i = start; i <= end; i++) {
+        selectedIds.add(allRows[i].id);
       }
-      const hasMore = offset + messages.length < total;
-      return { messages, total, hasMore };
-    } catch (error) {
-      console.error("Error in getMessages:", error);
-      throw error;
     }
+    const messages = await mapRows(
+      allRows.filter((row) => selectedIds.has(row.id))
+    );
+    return { messages, total: messages.length, hasMore: false };
   }
   /**
    * Delete a message (RPC method)
@@ -23937,6 +24452,9 @@ ${resultContent}${attachmentSummary}`;
   async deleteMessage(messageId) {
     await this.ensureMigrated();
     try {
+      if (await this.cancelQueuedMessage(messageId)) {
+        return { success: true };
+      }
       const rows = await this.ctx.storage.sql.exec(
         `SELECT id, attachments FROM messages WHERE id = ?`,
         messageId
@@ -23947,12 +24465,7 @@ ${resultContent}${attachmentSummary}`;
       const attachmentsJson = rows[0].attachments;
       if (attachmentsJson) {
         try {
-          const refs = JSON.parse(attachmentsJson);
-          for (const ref of refs) {
-            if (ref.path) {
-              await this.unlinkFile(ref.path);
-            }
-          }
+          await this.deleteAttachmentRefsFromJson(attachmentsJson);
         } catch (e) {
           console.error("Failed to cleanup attachments:", e);
         }
@@ -24076,7 +24589,7 @@ ${resultContent}${attachmentSummary}`;
       const result = await this.ctx.storage.sql.exec(
         `
         SELECT
-          id, message_id, provider, actual_provider, model, model_name, prompt_name,
+          id, message_id, provider, actual_provider, standard_agents_router_used, model, model_name, prompt_name,
           tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, cost_total,
           is_complete, created_at, request_body
         FROM logs
@@ -24091,6 +24604,7 @@ ${resultContent}${attachmentSummary}`;
         message_id: row.message_id,
         provider: row.provider,
         actual_provider: row.actual_provider,
+        standard_agents_router_used: row.standard_agents_router_used === 1,
         model: row.model,
         model_name: row.model_name,
         prompt_name: row.prompt_name,
@@ -24112,6 +24626,203 @@ ${resultContent}${attachmentSummary}`;
       throw error;
     }
   }
+  /**
+   * Get specific logs, optionally including all descendant logs.
+   */
+  async getLogsByIds(ids, includeDescendants = false, order = "ASC") {
+    await this.ensureMigrated();
+    const uniqueIds = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    if (uniqueIds.length === 0) {
+      return { logs: [], total: 0, hasMore: false };
+    }
+    if (uniqueIds.length > 200) {
+      throw new Error("Too many log IDs requested");
+    }
+    const placeholders = uniqueIds.map(() => "?").join(", ");
+    const sourceQuery = includeDescendants ? `
+        WITH RECURSIVE
+        seed_logs(id) AS (
+          SELECT id FROM logs WHERE id IN (${placeholders})
+        ),
+        descendant_logs(id) AS (
+          SELECT id FROM seed_logs
+          UNION
+          SELECT logs.id
+          FROM logs
+          JOIN descendant_logs ON logs.parent_log_id = descendant_logs.id
+        ),
+        selected_logs(id) AS (
+          SELECT id FROM descendant_logs
+          UNION
+          SELECT logs.parent_log_id
+          FROM logs
+          JOIN selected_logs ON logs.id = selected_logs.id
+          WHERE logs.parent_log_id IS NOT NULL
+        )
+        SELECT
+          id, message_id, provider, actual_provider, model, model_name, prompt_name,
+          tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, cost_total,
+          is_complete, created_at, request_body
+        FROM logs
+        WHERE id IN (SELECT id FROM selected_logs)
+        ORDER BY created_at ${order}, rowid ${order}
+      ` : `
+        SELECT
+          id, message_id, provider, actual_provider, model, model_name, prompt_name,
+          tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, cost_total,
+          is_complete, created_at, request_body
+        FROM logs
+        WHERE id IN (${placeholders})
+        ORDER BY created_at ${order}, rowid ${order}
+      `;
+    const result = await this.ctx.storage.sql.exec(sourceQuery, ...uniqueIds);
+    const logs = result.toArray().map((row) => ({
+      id: row.id,
+      message_id: row.message_id,
+      provider: row.provider,
+      actual_provider: row.actual_provider,
+      model: row.model,
+      model_name: row.model_name,
+      prompt_name: row.prompt_name,
+      tools_called: row.tools_called,
+      queued_tools: row.queued_tools,
+      provider_tools: row.provider_tools,
+      parent_log_id: row.parent_log_id,
+      retry_of_log_id: row.retry_of_log_id,
+      error: row.error,
+      cost_total: row.cost_total,
+      is_complete: row.is_complete === 1,
+      created_at: row.created_at,
+      request_body: row.request_body
+    }));
+    return { logs, total: logs.length, hasMore: false };
+  }
+  /**
+   * Get logs for specific messages, optionally expanding requested messages to
+   * the full contiguous workblock they belong to and including descendant logs.
+   */
+  async getLogsByMessageIds(messageIds, includeWorkblocks = false, includeDescendants = false, order = "ASC") {
+    await this.ensureMigrated();
+    const uniqueMessageIds = Array.from(
+      new Set(messageIds.map((id) => id.trim()).filter(Boolean))
+    );
+    if (uniqueMessageIds.length === 0) {
+      return { logs: [], total: 0, hasMore: false };
+    }
+    if (uniqueMessageIds.length > 200) {
+      throw new Error("Too many message IDs requested");
+    }
+    const selectedMessageIds = /* @__PURE__ */ new Set();
+    if (includeWorkblocks) {
+      const allRows = await this.ctx.storage.sql.exec(
+        `
+          SELECT id, role, tool_calls
+          FROM messages
+          ORDER BY created_at ASC, rowid ASC
+        `
+      ).toArray();
+      const requestedIds = new Set(uniqueMessageIds);
+      const isWorkblockRow = (row) => row.role === "tool" || row.role === "assistant" && typeof row.tool_calls === "string" && row.tool_calls.length > 0;
+      for (let index = 0; index < allRows.length; index++) {
+        const row = allRows[index];
+        if (!requestedIds.has(row.id)) continue;
+        if (!isWorkblockRow(row)) {
+          selectedMessageIds.add(row.id);
+          continue;
+        }
+        let start = index;
+        while (start > 0 && isWorkblockRow(allRows[start - 1])) {
+          start--;
+        }
+        let end = index;
+        while (end + 1 < allRows.length && isWorkblockRow(allRows[end + 1])) {
+          end++;
+        }
+        for (let i = start; i <= end; i++) {
+          selectedMessageIds.add(allRows[i].id);
+        }
+      }
+    } else {
+      uniqueMessageIds.forEach((id) => selectedMessageIds.add(id));
+    }
+    const selectedMessageIdList = Array.from(selectedMessageIds);
+    if (selectedMessageIdList.length === 0) {
+      return { logs: [], total: 0, hasMore: false };
+    }
+    const rowsById = /* @__PURE__ */ new Map();
+    const MESSAGE_ID_CHUNK_SIZE = 80;
+    for (let index = 0; index < selectedMessageIdList.length; index += MESSAGE_ID_CHUNK_SIZE) {
+      const chunk = selectedMessageIdList.slice(index, index + MESSAGE_ID_CHUNK_SIZE);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const sourceQuery = includeDescendants ? `
+          WITH RECURSIVE
+          seed_logs(id) AS (
+            SELECT id FROM logs WHERE message_id IN (${placeholders})
+          ),
+          descendant_logs(id) AS (
+            SELECT id FROM seed_logs
+            UNION
+            SELECT logs.id
+            FROM logs
+            JOIN descendant_logs ON logs.parent_log_id = descendant_logs.id
+          ),
+          selected_logs(id) AS (
+            SELECT id FROM descendant_logs
+            UNION
+            SELECT logs.parent_log_id
+            FROM logs
+            JOIN selected_logs ON logs.id = selected_logs.id
+            WHERE logs.parent_log_id IS NOT NULL
+          )
+          SELECT
+            rowid AS row_index,
+            id, message_id, provider, actual_provider, model, model_name, prompt_name,
+            tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, cost_total,
+            is_complete, created_at, request_body
+          FROM logs
+          WHERE id IN (SELECT id FROM selected_logs)
+          ORDER BY created_at ${order}, rowid ${order}
+        ` : `
+          SELECT
+            rowid AS row_index,
+            id, message_id, provider, actual_provider, model, model_name, prompt_name,
+            tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, cost_total,
+            is_complete, created_at, request_body
+          FROM logs
+          WHERE message_id IN (${placeholders})
+          ORDER BY created_at ${order}, rowid ${order}
+        `;
+      const result = await this.ctx.storage.sql.exec(sourceQuery, ...chunk);
+      for (const row of result.toArray()) {
+        rowsById.set(row.id, row);
+      }
+    }
+    const rows = Array.from(rowsById.values()).sort((left, right) => {
+      const createdAtDelta = left.created_at - right.created_at;
+      const rowDelta = left.row_index - right.row_index;
+      return order === "ASC" ? createdAtDelta || rowDelta : -createdAtDelta || -rowDelta;
+    });
+    const logs = rows.map((row) => ({
+      id: row.id,
+      message_id: row.message_id,
+      provider: row.provider,
+      actual_provider: row.actual_provider,
+      model: row.model,
+      model_name: row.model_name,
+      prompt_name: row.prompt_name,
+      tools_called: row.tools_called,
+      queued_tools: row.queued_tools,
+      provider_tools: row.provider_tools,
+      parent_log_id: row.parent_log_id,
+      retry_of_log_id: row.retry_of_log_id,
+      error: row.error,
+      cost_total: row.cost_total,
+      is_complete: row.is_complete === 1,
+      created_at: row.created_at,
+      request_body: row.request_body
+    }));
+    return { logs, total: logs.length, hasMore: false };
+  }
   /**
    * Get detailed information for a single log (RPC method)
    * This includes all fields including large ones like request/response bodies
@@ -24122,7 +24833,7 @@ ${resultContent}${attachmentSummary}`;
       const result = await this.ctx.storage.sql.exec(
         `
         SELECT
-          l.id, l.message_id, l.provider, l.actual_provider, l.model, l.model_name, l.endpoint,
+          l.id, l.message_id, l.provider, l.actual_provider, l.standard_agents_router_used, l.model, l.model_name, l.endpoint,
           l.request_body, l.request_headers, l.response_body, l.response_headers,
           l.status_code, l.reasoning_content, l.input_tokens, l.cached_tokens, l.output_tokens,
           l.reasoning_tokens, l.total_tokens, l.latency_ms, l.time_to_first_token_ms,
@@ -24194,6 +24905,7 @@ ${resultContent}${attachmentSummary}`;
         message_id: row.message_id,
         provider: row.provider,
         actual_provider: row.actual_provider,
+        standard_agents_router_used: row.standard_agents_router_used === 1,
         model: row.model,
         model_name: row.model_name,
         endpoint: row.endpoint,
@@ -24787,7 +25499,7 @@ ${resultContent}${attachmentSummary}`;
    * Internal method: Process a message (called by alarm queue)
    * This is the actual message processing logic, separate from the public sendMessage() RPC method
    */
-  async processMessage(threadId, content, role = "user", attachments) {
+  async processMessage(threadId, content, role = "user", attachments, queuedMessageId, queuedAt) {
     await this.assertNotTerminated();
     if (role === "user") {
       await this.ctx.storage.sql.exec(
@@ -24863,8 +25575,8 @@ ${resultContent}${attachmentSummary}`;
         side_b_session_status_message_property: sideBSession.status.messageProperty,
         side_b_session_status_attachments_property: sideBSession.status.attachmentsProperty
       };
-      const messageId = crypto.randomUUID();
-      const timestamp = Date.now() * 1e3;
+      const messageId = this.asOptionalString(queuedMessageId) ?? crypto.randomUUID();
+      const timestamp = typeof queuedAt === "number" && Number.isFinite(queuedAt) && queuedAt > 0 ? queuedAt : Date.now() * 1e3;
       let message = {
         id: messageId,
         role,
@@ -25232,11 +25944,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Write a file to storage (RPC method)
    */
-  async writeFile(path19, data, mimeType, options) {
+  async writeFile(path20, data, mimeType, options) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const existingFile = await fs17.stat(path19);
+      const fs18 = this.getFileStorage();
+      const existingFile = await fs18.stat(path20);
       const isUpdate = existingFile !== null;
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
@@ -25258,12 +25970,12 @@ ${resultContent}${attachmentSummary}`;
           }
         }
       }
-      const record = await fs17.writeFile(path19, dataBuffer, mimeType, {
+      const record = await fs18.writeFile(path20, dataBuffer, mimeType, {
         metadata: options?.metadata,
         thumbnail: thumbnailBuffer
       });
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path: path19,
+        path: path20,
         file: record
       });
       return { success: true, file: record };
@@ -25275,15 +25987,15 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Write a text file to storage (RPC method)
    */
-  async writeTextFile(path19, content, mimeType = "text/plain", options) {
+  async writeTextFile(path20, content, mimeType = "text/plain", options) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const existingFile = await fs17.stat(path19);
+      const fs18 = this.getFileStorage();
+      const existingFile = await fs18.stat(path20);
       const isUpdate = existingFile !== null;
-      const record = await fs17.writeFile(path19, content, mimeType, options);
+      const record = await fs18.writeFile(path20, content, mimeType, options);
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path: path19,
+        path: path20,
         file: record
       });
       return { success: true, file: record };
@@ -25320,11 +26032,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Link to an external file (RPC method)
    */
-  async linkFile(path19, location, options) {
+  async linkFile(path20, location, options) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const record = await fs17.linkFile(path19, location, options);
+      const fs18 = this.getFileStorage();
+      const record = await fs18.linkFile(path20, location, options);
       return { success: true, file: record };
     } catch (error) {
       console.error("Error in linkFile:", error);
@@ -25335,11 +26047,11 @@ ${resultContent}${attachmentSummary}`;
    * Read a file from storage (RPC method)
    * Returns base64-encoded data
    */
-  async readFile(path19) {
+  async readFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const data = await fs17.readFile(path19);
+      const fs18 = this.getFileStorage();
+      const data = await fs18.readFile(path20);
       if (data === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -25358,11 +26070,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Read a text file from storage (RPC method)
    */
-  async readTextFile(path19) {
+  async readTextFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const content = await fs17.readTextFile(path19);
+      const fs18 = this.getFileStorage();
+      const content = await fs18.readTextFile(path20);
       if (content === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -25375,11 +26087,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Get file metadata (RPC method)
    */
-  async statFile(path19) {
+  async statFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const record = await fs17.stat(path19);
+      const fs18 = this.getFileStorage();
+      const record = await fs18.stat(path20);
       if (record === null) {
         return { success: false, error: "File not found" };
       }
@@ -25392,11 +26104,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Check if file exists (RPC method)
    */
-  async fileExists(path19) {
+  async fileExists(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const exists2 = await fs17.exists(path19);
+      const fs18 = this.getFileStorage();
+      const exists2 = await fs18.exists(path20);
       return { success: true, exists: exists2 };
     } catch (error) {
       console.error("Error in fileExists:", error);
@@ -25406,12 +26118,12 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Delete a file (RPC method)
    */
-  async unlinkFile(path19) {
+  async unlinkFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      await fs17.unlink(path19);
-      this.broadcastEvent("file_deleted", { path: path19 });
+      const fs18 = this.getFileStorage();
+      await fs18.unlink(path20);
+      this.broadcastEvent("file_deleted", { path: path20 });
       return { success: true };
     } catch (error) {
       console.error("Error in unlinkFile:", error);
@@ -25421,12 +26133,12 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Create a directory (RPC method)
    */
-  async mkdirFile(path19) {
+  async mkdirFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const record = await fs17.mkdir(path19);
-      this.broadcastEvent("file_created", { path: path19, file: record });
+      const fs18 = this.getFileStorage();
+      const record = await fs18.mkdir(path20);
+      this.broadcastEvent("file_created", { path: path20, file: record });
       return { success: true, directory: record };
     } catch (error) {
       console.error("Error in mkdirFile:", error);
@@ -25436,11 +26148,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * List directory contents (RPC method)
    */
-  async readdirFile(path19) {
+  async readdirFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const files = await fs17.readdir(path19);
+      const fs18 = this.getFileStorage();
+      const files = await fs18.readdir(path20);
       return { success: true, files };
     } catch (error) {
       console.error("Error in readdirFile:", error);
@@ -25450,12 +26162,12 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Remove empty directory (RPC method)
    */
-  async rmdirFile(path19) {
+  async rmdirFile(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      await fs17.rmdir(path19);
-      this.broadcastEvent("file_deleted", { path: path19 });
+      const fs18 = this.getFileStorage();
+      await fs18.rmdir(path20);
+      this.broadcastEvent("file_deleted", { path: path20 });
       return { success: true };
     } catch (error) {
       console.error("Error in rmdirFile:", error);
@@ -25468,8 +26180,8 @@ ${resultContent}${attachmentSummary}`;
   async getFileStats() {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const stats = await fs17.getFileStats();
+      const fs18 = this.getFileStorage();
+      const stats = await fs18.getFileStats();
       return { success: true, stats };
     } catch (error) {
       console.error("Error in getFileStats:", error);
@@ -25480,11 +26192,11 @@ ${resultContent}${attachmentSummary}`;
    * Get thumbnail for an image (RPC method)
    * Returns base64-encoded data
    */
-  async getFileThumbnail(path19) {
+  async getFileThumbnail(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const data = await fs17.getThumbnail(path19);
+      const fs18 = this.getFileStorage();
+      const data = await fs18.getThumbnail(path20);
       if (data === null) {
         return { success: false, error: "Thumbnail not found" };
       }
@@ -25506,8 +26218,8 @@ ${resultContent}${attachmentSummary}`;
   async grepFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const results = await fs17.grep(pattern, options);
+      const fs18 = this.getFileStorage();
+      const results = await fs18.grep(pattern, options);
       return { success: true, results };
     } catch (error) {
       console.error("Error in grepFiles:", error);
@@ -25520,8 +26232,8 @@ ${resultContent}${attachmentSummary}`;
   async findFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const files = await fs17.find(pattern, options);
+      const fs18 = this.getFileStorage();
+      const files = await fs18.find(pattern, options);
       return { success: true, files };
     } catch (error) {
       console.error("Error in findFiles:", error);
@@ -25536,11 +26248,11 @@ ${resultContent}${attachmentSummary}`;
    * Creates file record with is_chunked=1 and chunk_count=null.
    * Caller should then use writeFileChunk() to write chunks.
    */
-  async startChunkedUpload(path19, totalSize, mimeType, options) {
+  async startChunkedUpload(path20, totalSize, mimeType, options) {
     await this.ensureMigrated();
     try {
       const { CHUNK_SIZE: CHUNK_SIZE2, normalizePath: normalizePath2, basename: basename3 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path19);
+      const normalizedPath = normalizePath2(path20);
       const name = basename3(normalizedPath);
       const now = Date.now();
       const expectedChunks = Math.ceil(totalSize / CHUNK_SIZE2);
@@ -25577,11 +26289,11 @@ ${resultContent}${attachmentSummary}`;
    * @param chunkIndex - 0-based chunk index
    * @param data - Base64 encoded chunk data
    */
-  async writeFileChunk(path19, chunkIndex, data) {
+  async writeFileChunk(path20, chunkIndex, data) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path19);
+      const normalizedPath = normalizePath2(path20);
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
       for (let i = 0; i < binaryString.length; i++) {
@@ -25603,12 +26315,12 @@ ${resultContent}${attachmentSummary}`;
    * Complete a chunked file upload.
    * Validates all chunks are present and sets chunk_count.
    */
-  async completeChunkedUpload(path19, expectedChunks, options) {
+  async completeChunkedUpload(path20, expectedChunks, options) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs17 = this.getFileStorage();
-      const normalizedPath = normalizePath2(path19);
+      const fs18 = this.getFileStorage();
+      const normalizedPath = normalizePath2(path20);
       const countResult = await this.ctx.storage.sql.exec(
         `SELECT COUNT(*) as count FROM file_chunks WHERE file_path = ?`,
         normalizedPath
@@ -25634,7 +26346,7 @@ ${resultContent}${attachmentSummary}`;
         thumbnailBuffer || null,
         normalizedPath
       );
-      const file = await fs17.stat(normalizedPath);
+      const file = await fs18.stat(normalizedPath);
       if (file) {
         this.broadcastEvent("file_created", { path: normalizedPath, file });
       }
@@ -25648,11 +26360,11 @@ ${resultContent}${attachmentSummary}`;
    * Read a single chunk of a file.
    * Use for streaming large files to client.
    */
-  async readFileChunk(path19, chunkIndex) {
+  async readFileChunk(path20, chunkIndex) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path19);
+      const normalizedPath = normalizePath2(path20);
       const cursor = await this.ctx.storage.sql.exec(
         `SELECT data FROM file_chunks WHERE file_path = ? AND chunk_index = ?`,
         normalizedPath,
@@ -25677,11 +26389,11 @@ ${resultContent}${attachmentSummary}`;
   /**
    * Get file info including chunking metadata.
    */
-  async getFileInfo(path19) {
+  async getFileInfo(path20) {
     await this.ensureMigrated();
     try {
-      const fs17 = this.getFileStorage();
-      const file = await fs17.stat(path19);
+      const fs18 = this.getFileStorage();
+      const file = await fs18.stat(path20);
       if (!file) {
         return { success: false, error: "File not found" };
       }
@@ -25694,7 +26406,7 @@ ${resultContent}${attachmentSummary}`;
 };
 
 // src/durable-objects/agentbuilder-migrations/0001_initial.ts
-var migration30 = {
+var migration31 = {
   version: 1,
   async up(sql) {
     sql.exec(`
@@ -25793,7 +26505,7 @@ var migration30 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0002_add_tenvs_properties.ts
-var migration31 = {
+var migration32 = {
   version: 2,
   async up(sql) {
     sql.exec(`ALTER TABLE threads ADD COLUMN tenvs TEXT`);
@@ -25805,7 +26517,7 @@ var migration31 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0003_add_parent_and_terminated.ts
-var migration32 = {
+var migration33 = {
   version: 3,
   async up(sql) {
     sql.exec(`ALTER TABLE threads ADD COLUMN parent TEXT REFERENCES threads(id)`);
@@ -25818,7 +26530,7 @@ var migration32 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0004_add_env_tables.ts
-var migration33 = {
+var migration34 = {
   version: 4,
   async up(sql) {
     sql.exec(`ALTER TABLE threads ADD COLUMN env TEXT`);
@@ -25842,7 +26554,7 @@ var migration33 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/0005_add_pending_subagent_env_requests.ts
-var migration34 = {
+var migration35 = {
   version: 5,
   async up(sql) {
     sql.exec(`
@@ -25867,9 +26579,24 @@ var migration34 = {
   }
 };
 
+// src/durable-objects/agentbuilder-migrations/0006_add_env_value_types.ts
+var migration36 = {
+  version: 6,
+  async up(sql) {
+    sql.exec(
+      `ALTER TABLE envs
+       ADD COLUMN value_type TEXT NOT NULL DEFAULT 'secret'
+       CHECK (value_type IN ('text', 'secret'))`
+    );
+    sql.exec(`
+      INSERT OR REPLACE INTO _metadata (key, value) VALUES ('schema_version', '6')
+    `);
+  }
+};
+
 // src/durable-objects/agentbuilder-migrations/index.ts
-var migrations2 = [migration30, migration31, migration32, migration33, migration34];
-var LATEST_SCHEMA_VERSION2 = 5;
+var migrations2 = [migration31, migration32, migration33, migration34, migration35, migration36];
+var LATEST_SCHEMA_VERSION2 = 6;
 
 // src/utils/crypto.ts
 var CryptoUtil = class {
@@ -26209,10 +26936,10 @@ var DurableAgentBuilder = class extends DurableObject {
     for (const entry of value) {
       if (!entry || typeof entry !== "object") continue;
       const attachment = entry;
-      const path19 = typeof attachment.path === "string" ? attachment.path.trim() : "";
-      if (!path19) continue;
+      const path20 = typeof attachment.path === "string" ? attachment.path.trim() : "";
+      if (!path20) continue;
       output.push({
-        path: path19,
+        path: path20,
         name: typeof attachment.name === "string" ? attachment.name : void 0,
         mimeType: typeof attachment.mimeType === "string" ? attachment.mimeType : void 0,
         size: typeof attachment.size === "number" ? attachment.size : void 0,
@@ -26229,8 +26956,8 @@ var DurableAgentBuilder = class extends DurableObject {
     const trimmed = sanitized.replace(/^[-.]+|[-.]+$/g, "");
     return trimmed || "attachment";
   }
-  inferMimeTypeFromPath(path19) {
-    const normalized = path19.toLowerCase();
+  inferMimeTypeFromPath(path20) {
+    const normalized = path20.toLowerCase();
     if (normalized.endsWith(".png")) return "image/png";
     if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
     if (normalized.endsWith(".webp")) return "image/webp";
@@ -26268,7 +26995,7 @@ var DurableAgentBuilder = class extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path19) => typeof path19 === "string" && path19.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path20) => typeof path20 === "string" && path20.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -26493,9 +27220,9 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     }
   }
   async runMigrations(fromVersion) {
-    for (const migration35 of migrations2) {
-      if (migration35.version > fromVersion) {
-        await migration35.up(this.ctx.storage.sql);
+    for (const migration37 of migrations2) {
+      if (migration37.version > fromVersion) {
+        await migration37.up(this.ctx.storage.sql);
       }
     }
   }
@@ -26852,23 +27579,49 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     return CryptoUtil.decrypt(encrypted, this.getEncryptionKey());
   }
   async listScopedEnv(scope, userId = "") {
+    const entries = await this.listScopedEnvEntries(scope, userId);
+    const env = {};
+    for (const entry of entries) {
+      env[entry.name] = entry.value;
+    }
+    return env;
+  }
+  async listScopedEnvEntries(scope, userId = "") {
     await this.ensureMigrated();
     const cursor = await this.ctx.storage.sql.exec(
-      `SELECT name, value FROM envs WHERE scope = ? AND user_id = ?`,
+      `SELECT name, value, value_type, created_at, updated_at
+       FROM envs
+       WHERE scope = ? AND user_id = ?`,
       scope,
       userId
     );
-    const env = {};
+    const entries = [];
     const rows = cursor.toArray();
     for (const row of rows) {
       try {
-        env[row.name] = await this.decryptEnvValue(row.value);
+        entries.push({
+          name: row.name,
+          value: await this.decryptEnvValue(row.value),
+          type: row.value_type === "text" ? "text" : "secret",
+          created_at: row.created_at,
+          updated_at: row.updated_at
+        });
       } catch {
       }
     }
-    return env;
+    return entries;
+  }
+  async getScopedEnvTypeRecord(scope, userId = "") {
+    const entries = await this.listScopedEnvEntries(scope, userId);
+    const envTypes = {};
+    for (const entry of entries) {
+      if (entry.type === "text") {
+        envTypes[entry.name] = "text";
+      }
+    }
+    return envTypes;
   }
-  async replaceScopedEnv(scope, userId, env) {
+  async replaceScopedEnv(scope, userId, env, envTypes) {
     await this.ensureMigrated();
     await this.ctx.storage.sql.exec(
       `DELETE FROM envs WHERE scope = ? AND user_id = ?`,
@@ -26876,32 +27629,93 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
       userId
     );
     const now = Math.floor(Date.now() / 1e3);
+    const normalizedEnvTypes = this.normalizeEnvTypeRecord(envTypes ?? null, env) ?? {};
     for (const [name, value] of Object.entries(env)) {
       await this.ctx.storage.sql.exec(
-        `INSERT INTO envs (scope, user_id, name, value, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?)`,
+        `INSERT INTO envs (scope, user_id, name, value, value_type, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
         scope,
         userId,
         name,
         await this.encryptEnvValue(value),
+        normalizedEnvTypes[name] === "text" ? "text" : "secret",
         now,
         now
       );
     }
   }
+  async patchScopedEnv(scope, userId, params) {
+    const currentEnv = await this.listScopedEnv(scope, userId);
+    const currentEnvTypes = await this.getScopedEnvTypeRecord(scope, userId);
+    const nextEnv = { ...currentEnv };
+    const nextEnvTypes = { ...currentEnvTypes };
+    if (params.env_patch) {
+      for (const [key, value] of Object.entries(params.env_patch)) {
+        const property = key.trim();
+        if (!property) {
+          throw new Error("env_patch keys must be non-empty strings");
+        }
+        if (value === void 0 || value === null) {
+          throw new Error(`env_patch.${property} must be a string`);
+        }
+        nextEnv[property] = String(value);
+      }
+    }
+    if (params.env_type_patch) {
+      for (const [key, value] of Object.entries(params.env_type_patch)) {
+        const property = key.trim();
+        if (!property) {
+          throw new Error("env_type_patch keys must be non-empty strings");
+        }
+        if (nextEnv[property] === void 0) {
+          throw new Error(`env_type_patch.${property} has no matching env value`);
+        }
+        if (value === "text") {
+          nextEnvTypes[property] = "text";
+        } else {
+          delete nextEnvTypes[property];
+        }
+      }
+    }
+    for (const key of params.env_delete ?? []) {
+      delete nextEnv[key];
+      delete nextEnvTypes[key];
+    }
+    await this.replaceScopedEnv(scope, userId, nextEnv, nextEnvTypes);
+  }
   async getInstanceEnv() {
     return this.listScopedEnv("instance", "");
   }
-  async setInstanceEnv(env) {
+  async getInstanceEnvTypes() {
+    return this.getScopedEnvTypeRecord("instance", "");
+  }
+  async getInstanceEnvEntries() {
+    return this.listScopedEnvEntries("instance", "");
+  }
+  async setInstanceEnv(env, envTypes) {
     const normalized = this.normalizeEnvRecord(env) ?? {};
-    await this.replaceScopedEnv("instance", "", normalized);
+    const normalizedTypes = this.normalizeEnvTypeRecord(envTypes ?? null, normalized);
+    await this.replaceScopedEnv("instance", "", normalized, normalizedTypes);
+  }
+  async patchInstanceEnv(params) {
+    await this.patchScopedEnv("instance", "", params);
   }
   async getUserEnv(userId) {
     return this.listScopedEnv("user", userId);
   }
-  async setUserEnv(userId, env) {
+  async getUserEnvTypes(userId) {
+    return this.getScopedEnvTypeRecord("user", userId);
+  }
+  async getUserEnvEntries(userId) {
+    return this.listScopedEnvEntries("user", userId);
+  }
+  async setUserEnv(userId, env, envTypes) {
     const normalized = this.normalizeEnvRecord(env) ?? {};
-    await this.replaceScopedEnv("user", userId, normalized);
+    const normalizedTypes = this.normalizeEnvTypeRecord(envTypes ?? null, normalized);
+    await this.replaceScopedEnv("user", userId, normalized, normalizedTypes);
+  }
+  async patchUserEnv(userId, params) {
+    await this.patchScopedEnv("user", userId, params);
   }
   async getMissingRequiredScopedSubagentEnv(params) {
     await this.ensureMigrated();
@@ -26947,10 +27761,10 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     const missing = [];
     for (const property of requiredScoped) {
       if (providedEnv[property] !== void 0) continue;
-      if (userEnv[property] !== void 0) continue;
-      if (instanceEnv[property] !== void 0) continue;
       if (agentEnv[property] !== void 0) continue;
       if (promptEnv[property] !== void 0) continue;
+      if (userEnv[property] !== void 0) continue;
+      if (instanceEnv[property] !== void 0) continue;
       missing.push(property);
     }
     missing.sort((a, b) => a.localeCompare(b));
@@ -27226,16 +28040,6 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     if (thread.env && thread.env[params.property] !== void 0) {
       return thread.env[params.property];
     }
-    if (thread.user_id) {
-      const userEnv = await this.getUserEnv(thread.user_id);
-      if (userEnv[params.property] !== void 0) {
-        return userEnv[params.property];
-      }
-    }
-    const instanceEnv = await this.getInstanceEnv();
-    if (instanceEnv[params.property] !== void 0) {
-      return instanceEnv[params.property];
-    }
     let agentDef = null;
     try {
       agentDef = await this.loadAgent(thread.agent_name);
@@ -27257,6 +28061,16 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
       } catch {
       }
     }
+    if (thread.user_id) {
+      const userEnv = await this.getUserEnv(thread.user_id);
+      if (userEnv[params.property] !== void 0) {
+        return userEnv[params.property];
+      }
+    }
+    const instanceEnv = await this.getInstanceEnv();
+    if (instanceEnv[params.property] !== void 0) {
+      return instanceEnv[params.property];
+    }
     return null;
   }
   async resolveThreadEnvType(params) {
@@ -27265,12 +28079,39 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     if (thread.env && thread.env[params.property] !== void 0) {
       return thread.env_types?.[params.property] === "text" ? "text" : "secret";
     }
+    let agentDef = null;
+    try {
+      agentDef = await this.loadAgent(thread.agent_name);
+    } catch {
+      agentDef = null;
+    }
+    const agentEnv = this.normalizeEnvRecord(agentDef?.env ?? agentDef?.tenvs ?? null);
+    if (agentEnv && agentEnv[params.property] !== void 0) {
+      return "secret";
+    }
+    const fallbackPromptName = params.promptName ?? (typeof agentDef?.sideA?.prompt === "string" ? agentDef.sideA.prompt : void 0);
+    if (fallbackPromptName) {
+      try {
+        const promptDef = await this.loadPrompt(fallbackPromptName);
+        const promptEnv = this.normalizeEnvRecord(promptDef?.env ?? promptDef?.tenvs ?? null);
+        if (promptEnv && promptEnv[params.property] !== void 0) {
+          return "secret";
+        }
+      } catch {
+      }
+    }
     if (thread.user_id) {
       const userEnv = await this.getUserEnv(thread.user_id);
-      if (userEnv[params.property] !== void 0) return "secret";
+      if (userEnv[params.property] !== void 0) {
+        const userEnvTypes = await this.getUserEnvTypes(thread.user_id);
+        return userEnvTypes[params.property] === "text" ? "text" : "secret";
+      }
     }
     const instanceEnv = await this.getInstanceEnv();
-    if (instanceEnv[params.property] !== void 0) return "secret";
+    if (instanceEnv[params.property] !== void 0) {
+      const instanceEnvTypes = await this.getInstanceEnvTypes();
+      return instanceEnvTypes[params.property] === "text" ? "text" : "secret";
+    }
     return "secret";
   }
   async toThreadEventPayload(thread) {
@@ -28289,8 +29130,8 @@ var GitHubClient = class _GitHubClient {
   /**
    * Make an authenticated request to GitHub API.
    */
-  async request(method, path19, body) {
-    const url = `${GITHUB_API_BASE}${path19}`;
+  async request(method, path20, body) {
+    const url = `${GITHUB_API_BASE}${path20}`;
     const response = await fetch(url, {
       method,
       headers: {
@@ -28446,8 +29287,8 @@ var GitHubClient = class _GitHubClient {
     const headSha = branchRef.object.sha;
     const headCommit = await this.getCommit(headSha);
     const baseTreeSha = headCommit.tree.sha;
-    const tree = paths.map((path19) => ({
-      path: path19,
+    const tree = paths.map((path20) => ({
+      path: path20,
       mode: "100644",
       type: "blob",
       sha: null