@standardagents/builder 0.37.0 → 0.37.1

package/dist/index.js

@@ -5,10 +5,10 @@ export { ProviderError, belongsToPackage, defineAgent, defineHook, defineModel,
 import 'virtual:@standardagents-providers';
 import { z } from 'zod';
 import { transform, collect } from '@standardagents/sip';
-import * as fs8 from 'fs';
-import fs8__default from 'fs';
-import * as path8 from 'path';
-import path8__default from 'path';
+import * as fs9 from 'fs';
+import fs9__default from 'fs';
+import * as path9 from 'path';
+import path9__default from 'path';
 import { fileURLToPath } from 'url';
 import MagicString from 'magic-string';
 import { exec } from 'child_process';
@@ -211,8 +211,8 @@ var init_StreamManager = __esm({
           }
         });
         this.beforeCloseHooks = Array.isArray(beforeClose) ? beforeClose : [beforeClose];
-        this.then = new Promise((resolve2) => {
-          this.resolver = resolve2;
+        this.then = new Promise((resolve3) => {
+          this.resolver = resolve3;
         });
       }
       /**
@@ -455,8 +455,8 @@ async function readCompletedArg(partialJson, argName) {
         controller.close();
       }
     }).getReader();
-    for await (const [value, path20] of jsonPathReader(reader, [argName])) {
-      if (path20 === argName) {
+    for await (const [value, path21] of jsonPathReader(reader, [argName])) {
+      if (path21 === argName) {
         return typeof value === "string" ? value : void 0;
       }
     }
@@ -865,7 +865,7 @@ var init_TestProvider = __esm({
         }, 0);
       }
       sleep(ms) {
-        return new Promise((resolve2) => setTimeout(resolve2, ms));
+        return new Promise((resolve3) => setTimeout(resolve3, ms));
       }
       // ============ Test Utility Methods ============
       /**
@@ -1350,12 +1350,12 @@ async function awaitBounded(work, budgetMs, label) {
   let timer;
   work.catch(() => {
   });
-  const timeout = new Promise((resolve2) => {
+  const timeout = new Promise((resolve3) => {
     timer = setTimeout(() => {
       console.error(
         `[LLMRequest] ${label} did not settle within ${budgetMs}ms \u2014 continuing without it`
       );
-      resolve2(void 0);
+      resolve3(void 0);
     }, budgetMs);
   });
   try {
@@ -1533,11 +1533,11 @@ function stripBase64FromMessages(messages, imagePathMap) {
             const data = part.data;
             if (typeof data === "string") {
               if (data.startsWith("data:") || data.length > 1e3) {
-                const path20 = imagePathMap?.get(data);
+                const path21 = imagePathMap?.get(data);
                 return {
                   ...part,
                   data: "[base64 omitted]",
-                  ...path20 ? { path: path20 } : {}
+                  ...path21 ? { path: path21 } : {}
                 };
               }
             }
@@ -2714,7 +2714,7 @@ var init_LLMRequest = __esm({
        * Sleep utility for backoff
        */
       static sleep(ms) {
-        return new Promise((resolve2) => setTimeout(resolve2, ms));
+        return new Promise((resolve3) => setTimeout(resolve3, ms));
       }
       /**
        * Update the response_body in a log record to replace base64 image URLs with file paths
@@ -2753,11 +2753,11 @@ var init_LLMRequest = __esm({
               ...choice.message,
               images: choice.message?.images?.map(
                 (img) => {
-                  const path20 = img._id ? imagePathMap.get(img._id) : void 0;
-                  if (path20) {
+                  const path21 = img._id ? imagePathMap.get(img._id) : void 0;
+                  if (path21) {
                     return {
                       type: img.type,
-                      image_url: { url: path20 }
+                      image_url: { url: path21 }
                     };
                   }
                   return img;
@@ -3166,7 +3166,7 @@ __export(files_exports, {
   FileStorage: () => FileStorage,
   basename: () => basename2,
   detectStorageBackend: () => detectStorageBackend,
-  dirname: () => dirname3,
+  dirname: () => dirname4,
   isTextMimeType: () => isTextMimeType,
   normalizePath: () => normalizePath,
   resolveRenameDestination: () => resolveRenameDestination,
@@ -3186,20 +3186,20 @@ function detectStorageBackend(location) {
     return "url";
   return "local";
 }
-function basename2(path20) {
-  const parts = path20.split("/").filter(Boolean);
+function basename2(path21) {
+  const parts = path21.split("/").filter(Boolean);
   return parts[parts.length - 1] || "";
 }
-function normalizePath(path20) {
-  let normalized = path20.replace(/\/+/g, "/");
+function normalizePath(path21) {
+  let normalized = path21.replace(/\/+/g, "/");
   if (!normalized.startsWith("/")) normalized = "/" + normalized;
   if (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
   return normalized;
 }
-function dirname3(path20) {
-  const normalized = normalizePath(path20);
+function dirname4(path21) {
+  const normalized = normalizePath(path21);
   const lastSlash = normalized.lastIndexOf("/");
   if (lastSlash <= 0) return "/";
   return normalized.slice(0, lastSlash);
@@ -3217,7 +3217,7 @@ function validateMovePaths(source, destination, isDirectory) {
     );
   }
 }
-function resolveRenameDestination(path20, newName) {
+function resolveRenameDestination(path21, newName) {
   if (typeof newName !== "string" || newName.length === 0) {
     throw new Error("New name must be a non-empty string");
   }
@@ -3227,8 +3227,8 @@ function resolveRenameDestination(path20, newName) {
   if (newName === "." || newName === "..") {
     throw new Error("New name must not be '.' or '..'");
   }
-  const normalized = normalizePath(path20);
-  const parent = dirname3(normalized);
+  const normalized = normalizePath(path21);
+  const parent = dirname4(normalized);
   return parent === "/" ? `/${newName}` : `${parent}/${newName}`;
 }
 function rowToFileRecord(row) {
@@ -3351,8 +3351,8 @@ var init_files = __esm({
        * Write a file to storage.
        * Files > CHUNK_SIZE are automatically chunked into file_chunks table.
        */
-      async writeFile(path20, data, mimeType, options) {
-        const normalizedPath = normalizePath(path20);
+      async writeFile(path21, data, mimeType, options) {
+        const normalizedPath = normalizePath(path21);
         const name = basename2(normalizedPath);
         const isText = isTextMimeType(mimeType);
         const now = Date.now();
@@ -3464,8 +3464,8 @@ var init_files = __esm({
       /**
        * Link to an external file (URL, S3, R2)
        */
-      async linkFile(path20, location, options) {
-        const normalizedPath = normalizePath(path20);
+      async linkFile(path21, location, options) {
+        const normalizedPath = normalizePath(path21);
         const name = basename2(normalizedPath);
         const storage = detectStorageBackend(location);
         const now = Date.now();
@@ -3504,8 +3504,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(path20) {
-        const normalizedPath = normalizePath(path20);
+      async readFile(path21) {
+        const normalizedPath = normalizePath(path21);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3557,8 +3557,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(path20) {
-        const normalizedPath = normalizePath(path20);
+      async *streamFile(path21) {
+        const normalizedPath = normalizePath(path21);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3592,8 +3592,8 @@ var init_files = __esm({
       /**
        * Read text file content
        */
-      async readTextFile(path20) {
-        const normalizedPath = normalizePath(path20);
+      async readTextFile(path21) {
+        const normalizedPath = normalizePath(path21);
         const cursor = await this.sql.exec(
           `SELECT content, data, storage FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3611,8 +3611,8 @@ var init_files = __esm({
       /**
        * Get file metadata (stat)
        */
-      async stat(path20) {
-        const normalizedPath = normalizePath(path20);
+      async stat(path21) {
+        const normalizedPath = normalizePath(path21);
         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 = ?`,
@@ -3625,8 +3625,8 @@ var init_files = __esm({
       /**
        * Check if file or directory exists
        */
-      async exists(path20) {
-        const normalizedPath = normalizePath(path20);
+      async exists(path21) {
+        const normalizedPath = normalizePath(path21);
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path = ?`,
           normalizedPath
@@ -3636,8 +3636,8 @@ var init_files = __esm({
       /**
        * Delete a file
        */
-      async unlink(path20) {
-        const normalizedPath = normalizePath(path20);
+      async unlink(path21) {
+        const normalizedPath = normalizePath(path21);
         await this.sql.exec(
           `DELETE FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3647,8 +3647,8 @@ var init_files = __esm({
       /**
        * Create a directory marker
        */
-      async mkdir(path20) {
-        const normalizedPath = normalizePath(path20);
+      async mkdir(path21) {
+        const normalizedPath = normalizePath(path21);
         const name = basename2(normalizedPath);
         const now = Date.now();
         await this.sql.exec(
@@ -3673,8 +3673,8 @@ var init_files = __esm({
       /**
        * List directory contents
        */
-      async readdir(path20) {
-        const normalizedPath = normalizePath(path20);
+      async readdir(path21) {
+        const normalizedPath = normalizePath(path21);
         const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
@@ -3692,8 +3692,8 @@ var init_files = __esm({
       /**
        * Remove empty directory
        */
-      async rmdir(path20) {
-        const normalizedPath = normalizePath(path20);
+      async rmdir(path21) {
+        const normalizedPath = normalizePath(path21);
         const prefix = normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path LIKE ? || '%'`,
@@ -3791,9 +3791,9 @@ var init_files = __esm({
        * Rename a file or directory in place, keeping it in the same parent
        * directory. `newName` must be a bare file name with no path separators.
        */
-      async rename(path20, newName) {
-        const destination = resolveRenameDestination(path20, newName);
-        return this.move(normalizePath(path20), destination);
+      async rename(path21, newName) {
+        const destination = resolveRenameDestination(path21, newName);
+        return this.move(normalizePath(path21), destination);
       }
       /**
        * Get storage statistics
@@ -3823,8 +3823,8 @@ var init_files = __esm({
       /**
        * Get thumbnail for an image
        */
-      async getThumbnail(path20) {
-        const normalizedPath = normalizePath(path20);
+      async getThumbnail(path21) {
+        const normalizedPath = normalizePath(path21);
         const cursor = await this.sql.exec(
           `SELECT thumbnail FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -4256,8 +4256,8 @@ var init_ToolExecutor = __esm({
             const validation = argsSchema.safeParse(args);
             if (!validation.success) {
               const errorMessage = validation.error.issues.map((issue) => {
-                const path20 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-                return `[${path20}] ${issue.message}`;
+                const path21 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+                return `[${path21}] ${issue.message}`;
               }).join("; ");
               return {
                 status: "error",
@@ -5248,13 +5248,13 @@ Message one with subagent_message(referenceId, message).`
             new Set(
               issues.map(
                 (issue) => Array.isArray(issue.path) ? issue.path.map(String).join(".") : String(issue.path ?? "")
-              ).filter((path20) => path20.length > 0)
+              ).filter((path21) => path21.length > 0)
             )
           );
           const detail = issues.map((issue) => {
-            const path20 = Array.isArray(issue.path) ? issue.path.map(String).join(".") : "";
+            const path21 = Array.isArray(issue.path) ? issue.path.map(String).join(".") : "";
             const message = typeof issue.message === "string" ? issue.message : "invalid value";
-            return path20 ? `${path20}: ${message}` : message;
+            return path21 ? `${path21}: ${message}` : message;
           }).join("; ") || parsed.error.message || "invalid arguments";
           const agentLabel = agentDef.title || agentDef.name || options.agentName || qualifiedPromptName;
           return {
@@ -5591,8 +5591,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return [];
       }
-      static inferMimeTypeFromPath(path20) {
-        const normalized = path20.toLowerCase();
+      static inferMimeTypeFromPath(path21) {
+        const normalized = path21.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";
@@ -5631,7 +5631,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
           ext: value.slice(lastDot + 1).toLowerCase()
         };
       }
-      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path20) {
+      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path21) {
         const source = sourceMimeType?.trim();
         if (source && source !== "application/octet-stream") {
           return source;
@@ -5640,7 +5640,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (fallback && fallback !== "application/octet-stream") {
           return fallback;
         }
-        return this.inferMimeTypeFromPath(path20) ?? source ?? fallback ?? "application/octet-stream";
+        return this.inferMimeTypeFromPath(path21) ?? source ?? fallback ?? "application/octet-stream";
       }
       static buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
         const safeName = this.sanitizeFilename(preferredName);
@@ -5736,8 +5736,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return copied;
       }
-      static async readAttachmentDataFromSource(sourceThread, path20, sourceFile) {
-        const sourceData = await sourceThread.readFile(path20);
+      static async readAttachmentDataFromSource(sourceThread, path21, sourceFile) {
+        const sourceData = await sourceThread.readFile(path21);
         if (sourceData.success && sourceData.data) {
           return sourceData.data;
         }
@@ -5771,7 +5771,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (!attachments || attachments.length === 0) {
           return "";
         }
-        const paths = attachments.map((attachment) => attachment.path).filter((path20) => typeof path20 === "string" && path20.length > 0);
+        const paths = attachments.map((attachment) => attachment.path).filter((path21) => typeof path21 === "string" && path21.length > 0);
         if (paths.length === 0) {
           return "";
         }
@@ -6067,7 +6067,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
                   mappedAttachmentValue
                 );
                 const resolvedPaths = new Set(mappedRefs.map((ref) => ref.path));
-                const missingPaths = candidatePaths.filter((path20) => !resolvedPaths.has(path20));
+                const missingPaths = candidatePaths.filter((path21) => !resolvedPaths.has(path21));
                 if (candidatePaths.length === 0 || missingPaths.length > 0) {
                   processedResult = {
                     status: "error",
@@ -6249,8 +6249,8 @@ ${attachmentPaths}`;
           if (mimeType.startsWith("image/")) {
             return true;
           }
-          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");
+          const path21 = ref.path.toLowerCase();
+          return path21.endsWith(".png") || path21.endsWith(".jpg") || path21.endsWith(".jpeg") || path21.endsWith(".webp") || path21.endsWith(".gif") || path21.endsWith(".bmp") || path21.endsWith(".svg");
         });
         if (imageRefs.length === 0) {
           return;
@@ -6316,27 +6316,27 @@ ${attachmentPaths}`;
        */
       static async processToolAttachments(attachments, state) {
         const { FileStorage: FileStorage2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-        const fs18 = new FileStorage2(state.storage.sql);
+        const fs19 = 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 path20 = `/attachments/${timestamp}-${attachmentId.slice(0, 8)}.${ext}`;
+            const path21 = `/attachments/${timestamp}-${attachmentId.slice(0, 8)}.${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 fs18.writeFile(path20, dataBuffer.buffer, attachment.mimeType, {
+            await fs19.writeFile(path21, dataBuffer.buffer, attachment.mimeType, {
               width: attachment.width,
               height: attachment.height
             });
             const ref = {
               id: attachmentId,
               type: "file",
-              path: path20,
+              path: path21,
               name: attachment.name,
               mimeType: attachment.mimeType,
               size: dataBuffer.byteLength
@@ -10113,16 +10113,16 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           const base64Data = match[2];
           const ext = mimeType.split("/")[1] || "png";
           const attachmentId = crypto.randomUUID();
-          const path20 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
+          const path21 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            await state.thread.instance.writeFile(path20, base64Data, mimeType);
+            await state.thread.instance.writeFile(path21, base64Data, mimeType);
             if (image.id) {
-              imagePathMap.set(image.id, path20);
+              imagePathMap.set(image.id, path21);
             }
             refs.push({
               id: attachmentId,
               type: "file",
-              path: path20,
+              path: path21,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -10183,13 +10183,13 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           const base64Data = imageUrl.slice(base64Index + base64Marker.length);
           const ext = mimeType.split("/")[1] || "png";
           const attachmentId = crypto.randomUUID();
-          const path20 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
+          const path21 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            await state.thread.instance.writeFile(path20, base64Data, mimeType);
+            await state.thread.instance.writeFile(path21, base64Data, mimeType);
             const attachmentRef = {
               id: attachmentId,
               type: "file",
-              path: path20,
+              path: path21,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -10252,7 +10252,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
                   content: "Image generated successfully",
                   status: "success",
                   timestamp: Date.now(),
-                  attachment_path: path20
+                  attachment_path: path21
                 });
                 await state.storage.sql.exec(
                   `UPDATE logs SET tool_results = ?1 WHERE id = ?2`,
@@ -10274,7 +10274,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               }
             }
             if (image.id) {
-              imagePathMap.set(image.id, path20);
+              imagePathMap.set(image.id, path21);
             }
           } catch (error) {
             console.error(`[FlowEngine] Failed to store provider tool result for ${toolName}:`, error);
@@ -11017,7 +11017,7 @@ async function updateThread(thread, params) {
   }
   return result.thread;
 }
-async function writeFile(flow, path20, data, mimeType, options) {
+async function writeFile(flow, path21, data, mimeType, options) {
   const instance = flow.thread.instance;
   let base64Data;
   if (typeof data === "string") {
@@ -11039,7 +11039,7 @@ async function writeFile(flow, path20, data, mimeType, options) {
     }
     base64Thumbnail = btoa(binary);
   }
-  const result = await instance.writeFile(path20, base64Data, mimeType, {
+  const result = await instance.writeFile(path21, base64Data, mimeType, {
     metadata: options?.metadata,
     thumbnail: base64Thumbnail
   });
@@ -11048,20 +11048,20 @@ async function writeFile(flow, path20, data, mimeType, options) {
   }
   return result.file;
 }
-async function writeImage(flow, path20, data, mimeType, options) {
-  return writeFile(flow, path20, data, mimeType, options);
+async function writeImage(flow, path21, data, mimeType, options) {
+  return writeFile(flow, path21, data, mimeType, options);
 }
-async function linkFile(flow, path20, location, options) {
+async function linkFile(flow, path21, location, options) {
   const instance = flow.thread.instance;
-  const result = await instance.linkFile(path20, location, options);
+  const result = await instance.linkFile(path21, location, options);
   if (!result.success) {
     throw new Error(result.error || "Failed to link file");
   }
   return result.file;
 }
-async function readFile(flow, path20) {
+async function readFile(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.readFile(path20);
+  const result = await instance.readFile(path21);
   if (!result.success) {
     return null;
   }
@@ -11072,45 +11072,45 @@ async function readFile(flow, path20) {
   }
   return bytes.buffer;
 }
-async function stat(flow, path20) {
+async function stat(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.statFile(path20);
+  const result = await instance.statFile(path21);
   if (!result.success) {
     return null;
   }
   return result.file;
 }
-async function exists(flow, path20) {
+async function exists(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.fileExists(path20);
+  const result = await instance.fileExists(path21);
   return result.success && result.exists;
 }
-async function unlink(flow, path20) {
+async function unlink(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.unlinkFile(path20);
+  const result = await instance.unlinkFile(path21);
   if (!result.success) {
     throw new Error(result.error || "Failed to delete file");
   }
 }
-async function mkdir(flow, path20) {
+async function mkdir(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.mkdirFile(path20);
+  const result = await instance.mkdirFile(path21);
   if (!result.success) {
     throw new Error(result.error || "Failed to create directory");
   }
   return result.directory;
 }
-async function readdir(flow, path20) {
+async function readdir(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.readdirFile(path20);
+  const result = await instance.readdirFile(path21);
   if (!result.success) {
     throw new Error(result.error || "Failed to read directory");
   }
   return result.files;
 }
-async function rmdir(flow, path20) {
+async function rmdir(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.rmdirFile(path20);
+  const result = await instance.rmdirFile(path21);
   if (!result.success) {
     throw new Error(result.error || "Failed to remove directory");
   }
@@ -11123,9 +11123,9 @@ async function move(flow, sourcePath, destinationPath) {
   }
   return result.file;
 }
-async function rename(flow, path20, newName) {
+async function rename(flow, path21, newName) {
   const instance = flow.thread.instance;
-  const result = await instance.renameFile(path20, newName);
+  const result = await instance.renameFile(path21, newName);
   if (!result.success) {
     throw new Error(result.error || "Failed to rename file");
   }
@@ -11139,9 +11139,9 @@ async function getFileStats(flow) {
   }
   return result.stats;
 }
-async function getThumbnail(flow, path20) {
+async function getThumbnail(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.getFileThumbnail(path20);
+  const result = await instance.getFileThumbnail(path21);
   if (!result.success) {
     return null;
   }
@@ -11152,22 +11152,22 @@ async function getThumbnail(flow, path20) {
   }
   return bytes.buffer;
 }
-async function cat(flow, path20) {
+async function cat(flow, path21) {
   const instance = flow.thread.instance;
-  const result = await instance.readTextFile(path20);
+  const result = await instance.readTextFile(path21);
   if (!result.success) {
     return null;
   }
   return result.content;
 }
-async function head(flow, path20, lines = 10) {
-  const content = await cat(flow, path20);
+async function head(flow, path21, lines = 10) {
+  const content = await cat(flow, path21);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(0, lines).join("\n");
 }
-async function tail(flow, path20, lines = 10) {
-  const content = await cat(flow, path20);
+async function tail(flow, path21, lines = 10) {
+  const content = await cat(flow, path21);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(-lines).join("\n");
@@ -11219,8 +11219,8 @@ function runCodeInDynamicWorker(params) {
   let terminated = false;
   let terminateReason = "Code execution terminated";
   let settleTermination = null;
-  const termination = new Promise((resolve2) => {
-    settleTermination = resolve2;
+  const termination = new Promise((resolve3) => {
+    settleTermination = resolve3;
   });
   const execute = async () => {
     const loader = params.threadInstance.env[WORKER_LOADER_BINDING];
@@ -11706,32 +11706,32 @@ function prepareBridge(options, reports, logs) {
     logs
   };
 }
-function prepareNamespaceRecord(value, path20, functions) {
+function prepareNamespaceRecord(value, path21, functions) {
   const out = {};
   for (const [key, namespace] of Object.entries(value)) {
-    out[key] = prepareValueRecord(namespace, `${path20}.${key}`, functions);
+    out[key] = prepareValueRecord(namespace, `${path21}.${key}`, functions);
   }
   return out;
 }
-function prepareValueRecord(value, path20, functions) {
+function prepareValueRecord(value, path21, functions) {
   const out = {};
   for (const [key, item] of Object.entries(value)) {
-    out[key] = prepareBridgeValue(item, `${path20}.${key}`, functions);
+    out[key] = prepareBridgeValue(item, `${path21}.${key}`, functions);
   }
   return out;
 }
-function prepareBridgeValue(value, path20, functions) {
+function prepareBridgeValue(value, path21, functions) {
   if (typeof value === "function") {
-    functions.set(path20, value);
-    return { __agentbuilderType: "function", id: path20 };
+    functions.set(path21, value);
+    return { __agentbuilderType: "function", id: path21 };
   }
   if (isThenable(value)) {
-    const promiseId = `${path20}.__promise`;
+    const promiseId = `${path21}.__promise`;
     functions.set(promiseId, async () => value);
     return { __agentbuilderType: "promise", id: promiseId };
   }
   if (Array.isArray(value)) {
-    return value.map((item, index) => prepareBridgeValue(item, `${path20}.${index}`, functions));
+    return value.map((item, index) => prepareBridgeValue(item, `${path21}.${index}`, functions));
   }
   if (value && typeof value === "object") {
     if (value instanceof Date || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
@@ -11742,7 +11742,7 @@ function prepareBridgeValue(value, path20, functions) {
     }
     const out = {};
     for (const [key, item] of Object.entries(value)) {
-      out[key] = prepareBridgeValue(item, `${path20}.${key}`, functions);
+      out[key] = prepareBridgeValue(item, `${path21}.${key}`, functions);
     }
     return out;
   }
@@ -12617,12 +12617,12 @@ function normalizeVirtualModulePath(basePath, specifier) {
   }
   return normalized;
 }
-function dirnameModulePath(path20) {
-  const index = path20.lastIndexOf("/");
-  return index <= 0 ? "" : path20.slice(0, index);
+function dirnameModulePath(path21) {
+  const index = path21.lastIndexOf("/");
+  return index <= 0 ? "" : path21.slice(0, index);
 }
-function hasModuleExtension(path20) {
-  return /\.[A-Za-z0-9]+$/.test(path20);
+function hasModuleExtension(path21) {
+  return /\.[A-Za-z0-9]+$/.test(path21);
 }
 function resolveGraphModuleSpecifier(fromPath, specifier, modulePaths) {
   const base = normalizeVirtualModulePath(dirnameModulePath(fromPath), specifier);
@@ -12953,9 +12953,9 @@ function isPlainObject2(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function findUntransferableOption(value, path20, seen = /* @__PURE__ */ new WeakSet()) {
+function findUntransferableOption(value, path21, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value === "function" || typeof value === "symbol") {
-    return path20;
+    return path21;
   }
   if (!value || typeof value !== "object") {
     return null;
@@ -12969,7 +12969,7 @@ function findUntransferableOption(value, path20, seen = /* @__PURE__ */ new Weak
   seen.add(value);
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      const found = findUntransferableOption(item, `${path20}.${index}`, seen);
+      const found = findUntransferableOption(item, `${path21}.${index}`, seen);
       if (found) return found;
     }
     return null;
@@ -12977,9 +12977,9 @@ function findUntransferableOption(value, path20, seen = /* @__PURE__ */ new Weak
   if (value instanceof Map) {
     let index = 0;
     for (const [key, item] of value.entries()) {
-      const foundKey = findUntransferableOption(key, `${path20}.mapKey${index}`, seen);
+      const foundKey = findUntransferableOption(key, `${path21}.mapKey${index}`, seen);
       if (foundKey) return foundKey;
-      const foundValue = findUntransferableOption(item, `${path20}.mapValue${index}`, seen);
+      const foundValue = findUntransferableOption(item, `${path21}.mapValue${index}`, seen);
       if (foundValue) return foundValue;
       index += 1;
     }
@@ -12988,17 +12988,17 @@ function findUntransferableOption(value, path20, seen = /* @__PURE__ */ new Weak
   if (value instanceof Set) {
     let index = 0;
     for (const item of value.values()) {
-      const found = findUntransferableOption(item, `${path20}.setValue${index}`, seen);
+      const found = findUntransferableOption(item, `${path21}.setValue${index}`, seen);
       if (found) return found;
       index += 1;
     }
     return null;
   }
   if (!isPlainObject2(value)) {
-    return path20;
+    return path21;
   }
   for (const [key, item] of Object.entries(value)) {
-    const found = findUntransferableOption(item, `${path20}.${key}`, seen);
+    const found = findUntransferableOption(item, `${path21}.${key}`, seen);
     if (found) return found;
   }
   return null;
@@ -13008,8 +13008,8 @@ function createCodeExecutionHandle(execute, reports = [], onTerminate) {
   let running = true;
   let terminated = false;
   let settleTermination = null;
-  const termination = new Promise((resolve2) => {
-    settleTermination = resolve2;
+  const termination = new Promise((resolve3) => {
+    settleTermination = resolve3;
   });
   const promise = Promise.race([execute(), termination]).finally(() => {
     running = false;
@@ -13926,7 +13926,7 @@ var init_ThreadStateImpl = __esm({
       // ─────────────────────────────────────────────────────────────────────────
       // File System
       // ─────────────────────────────────────────────────────────────────────────
-      async writeFile(path20, data, mimeType, options) {
+      async writeFile(path21, data, mimeType, options) {
         const isText = this._isTextMimeType(mimeType);
         if (isText) {
           let textContent;
@@ -13935,7 +13935,7 @@ var init_ThreadStateImpl = __esm({
           } else {
             textContent = new TextDecoder().decode(data);
           }
-          const result = await this._threadInstance.writeTextFile(path20, textContent, mimeType, options);
+          const result = await this._threadInstance.writeTextFile(path21, textContent, mimeType, options);
           return this._mapFileRecord(result.file);
         } else {
           let base64Data;
@@ -13955,7 +13955,7 @@ var init_ThreadStateImpl = __esm({
             }
             base64Data = btoa(binary);
           }
-          const result = await this._threadInstance.writeFile(path20, base64Data, mimeType, options);
+          const result = await this._threadInstance.writeFile(path21, base64Data, mimeType, options);
           return this._mapFileRecord(result.file);
         }
       }
@@ -14027,8 +14027,8 @@ var init_ThreadStateImpl = __esm({
           (type) => mimeType === type || mimeType.startsWith(type + ";")
         );
       }
-      async readFile(path20) {
-        const result = await this._threadInstance.readFile(path20);
+      async readFile(path21) {
+        const result = await this._threadInstance.readFile(path21);
         if (!result.success || !result.data) {
           return null;
         }
@@ -14039,8 +14039,8 @@ var init_ThreadStateImpl = __esm({
         }
         return bytes.buffer;
       }
-      async readFileStream(path20, options) {
-        const fileInfo = await this._threadInstance.statFile(path20);
+      async readFileStream(path21, options) {
+        const fileInfo = await this._threadInstance.statFile(path21);
         if (!fileInfo) {
           return null;
         }
@@ -14055,7 +14055,7 @@ var init_ThreadStateImpl = __esm({
         return {
           [Symbol.asyncIterator]: async function* () {
             if (!isChunked) {
-              const result = await threadInstance.readFile(path20);
+              const result = await threadInstance.readFile(path21);
               if (!result.success || !result.data) {
                 return;
               }
@@ -14076,7 +14076,7 @@ var init_ThreadStateImpl = __esm({
               if (signal?.aborted) {
                 return;
               }
-              const result = await threadInstance.readFileChunk(path20, i);
+              const result = await threadInstance.readFileChunk(path21, i);
               if (!result.success || !result.data) {
                 throw new Error(result.error || `Failed to read chunk ${i}`);
               }
@@ -14095,25 +14095,25 @@ var init_ThreadStateImpl = __esm({
           }
         };
       }
-      async statFile(path20) {
-        const result = await this._threadInstance.statFile(path20);
+      async statFile(path21) {
+        const result = await this._threadInstance.statFile(path21);
         return result ? this._mapFileRecord(result) : null;
       }
-      async readdirFile(path20) {
-        const entries = await this._threadInstance.readdirFile(path20);
+      async readdirFile(path21) {
+        const entries = await this._threadInstance.readdirFile(path21);
         return {
           entries: entries.map((e) => this._mapFileRecord(e))
         };
       }
-      async unlinkFile(path20) {
-        await this._threadInstance.unlinkFile(path20);
+      async unlinkFile(path21) {
+        await this._threadInstance.unlinkFile(path21);
       }
-      async mkdirFile(path20) {
-        const result = await this._threadInstance.mkdirFile(path20);
+      async mkdirFile(path21) {
+        const result = await this._threadInstance.mkdirFile(path21);
         return this._mapFileRecord(result);
       }
-      async rmdirFile(path20) {
-        await this._threadInstance.rmdirFile(path20);
+      async rmdirFile(path21) {
+        await this._threadInstance.rmdirFile(path21);
       }
       async moveFile(sourcePath, destinationPath) {
         const result = await this._threadInstance.moveFile(sourcePath, destinationPath);
@@ -14122,8 +14122,8 @@ var init_ThreadStateImpl = __esm({
         }
         return this._mapFileRecord(result.file);
       }
-      async renameFile(path20, newName) {
-        const result = await this._threadInstance.renameFile(path20, newName);
+      async renameFile(path21, newName) {
+        const result = await this._threadInstance.renameFile(path21, newName);
         if (!result.success || !result.file) {
           throw new Error(result.error || "Failed to rename file");
         }
@@ -14150,8 +14150,8 @@ var init_ThreadStateImpl = __esm({
           paths: Array.isArray(results) ? results : results.paths || []
         };
       }
-      async getFileThumbnail(path20) {
-        return this._threadInstance.getFileThumbnail(path20);
+      async getFileThumbnail(path21) {
+        return this._threadInstance.getFileThumbnail(path21);
       }
       // ─────────────────────────────────────────────────────────────────────────
       // Execution State
@@ -14356,9 +14356,9 @@ var init_ThreadStateImpl = __esm({
                 "Reentrant user-scope call: this ThreadState was raised from user-scope code; state.user().call() is unavailable here."
               );
             }
-            const path20 = endpoint.replace(/^\/+/, "");
+            const path21 = endpoint.replace(/^\/+/, "");
             return hub().fetch(
-              new Request(`https://user-hub/users/${encodeURIComponent(userId)}/endpoints/${path20}`, {
+              new Request(`https://user-hub/users/${encodeURIComponent(userId)}/endpoints/${path21}`, {
                 method: "POST",
                 headers: {
                   "Content-Type": "application/json",
@@ -14426,7 +14426,7 @@ var init_ThreadStateImpl = __esm({
             const skillMd = await stub.getSkillFile(name, "SKILL.md") ?? "";
             return { metadata, skillMd };
           },
-          readFile: (name, path20) => stub.getSkillFile(name, path20),
+          readFile: (name, path21) => stub.getSkillFile(name, path21),
           install: (files) => stub.upsertSkill(files),
           setEnabled: (name, enabled) => stub.setSkillEnabled(name, enabled),
           remove: (name) => stub.deleteSkill(name)
@@ -14619,15 +14619,15 @@ function extractSchemaFields(content) {
 }
 function scanPromptsWithSchemas(dir) {
   const results = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -14643,15 +14643,15 @@ function scanPromptsWithSchemas(dir) {
 }
 function scanAgentsWithSideA(dir) {
   const results = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return results;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
         if (nameMatch) {
           const name = nameMatch[1];
@@ -14671,15 +14671,15 @@ function scanAgentsWithSideA(dir) {
 }
 function scanForNames(dir, useFilename = false) {
   const names = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return names;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         if (useFilename) {
           const toolName = entry.name.replace(/\.ts$/, "");
           if (content.includes("defineTool")) {
@@ -14700,18 +14700,18 @@ function scanForNames(dir, useFilename = false) {
 }
 function scanHooksForIds(dir) {
   const hookIds = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return hookIds;
   }
   try {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
         if (entry.name === "index.ts") {
           continue;
         }
-        const filePath = path8__default.join(dir, entry.name);
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const filePath = path9__default.join(dir, entry.name);
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/defineHook\s*\(\s*\{[^}]*id:\s*['"]([^'"]+)['"]/s);
         if (idMatch) {
           hookIds.push(idMatch[1]);
@@ -15379,44 +15379,44 @@ declare module 'virtual:@standardagents/router' {
 `;
 }
 function ensureDir(dir) {
-  if (!fs8__default.existsSync(dir)) {
-    fs8__default.mkdirSync(dir, { recursive: true });
+  if (!fs9__default.existsSync(dir)) {
+    fs9__default.mkdirSync(dir, { recursive: true });
   }
 }
 function writeFileIfChanged(filePath, content) {
-  if (fs8__default.existsSync(filePath)) {
-    const existing = fs8__default.readFileSync(filePath, "utf-8");
+  if (fs9__default.existsSync(filePath)) {
+    const existing = fs9__default.readFileSync(filePath, "utf-8");
     if (existing === content) {
       return;
     }
   }
-  fs8__default.writeFileSync(filePath, content);
+  fs9__default.writeFileSync(filePath, content);
 }
 function generateTypes(config) {
   ensureDir(config.outputDir);
   const typesContent = generateTypesContent(config);
-  writeFileIfChanged(path8__default.join(config.outputDir, "types.d.ts"), typesContent);
+  writeFileIfChanged(path9__default.join(config.outputDir, "types.d.ts"), typesContent);
   const virtualModuleContent = generateVirtualModuleContent();
-  writeFileIfChanged(path8__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
-  writeFileIfChanged(path8__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
-  writeFileIfChanged(path8__default.join(config.outputDir, ".gitignore"), "*\n");
+  writeFileIfChanged(path9__default.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
+  writeFileIfChanged(path9__default.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
+  writeFileIfChanged(path9__default.join(config.outputDir, ".gitignore"), "*\n");
 }
 function needsRegeneration(config) {
-  const typesPath = path8__default.join(config.outputDir, "types.d.ts");
-  if (!fs8__default.existsSync(typesPath)) {
+  const typesPath = path9__default.join(config.outputDir, "types.d.ts");
+  if (!fs9__default.existsSync(typesPath)) {
     return true;
   }
-  const typesMtime = fs8__default.statSync(typesPath).mtime;
+  const typesMtime = fs9__default.statSync(typesPath).mtime;
   const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir, config.hooksDir];
   for (const dir of dirs) {
-    if (!fs8__default.existsSync(dir)) {
+    if (!fs9__default.existsSync(dir)) {
       continue;
     }
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
-        const filePath = path8__default.join(dir, entry.name);
-        const fileMtime = fs8__default.statSync(filePath).mtime;
+        const filePath = path9__default.join(dir, entry.name);
+        const fileMtime = fs9__default.statSync(filePath).mtime;
         if (fileMtime > typesMtime) {
           return true;
         }
@@ -15622,7 +15622,7 @@ function createHmrReloader() {
     versions,
     invalidateSourceFileModule(server, filePath) {
       if (!filePath) return;
-      const absolutePath = path8__default.resolve(filePath);
+      const absolutePath = path9__default.resolve(filePath);
       for (const [envName, env] of Object.entries(server.environments)) {
         const modules = env.moduleGraph.getModulesByFile(absolutePath);
         if (!modules) continue;
@@ -15633,10 +15633,10 @@ function createHmrReloader() {
       }
     },
     invalidateSourceDirectoryModules(server, dirPath) {
-      if (!fs8__default.existsSync(dirPath)) return;
+      if (!fs9__default.existsSync(dirPath)) return;
       const scan = (currentDir) => {
-        for (const entry of fs8__default.readdirSync(currentDir, { withFileTypes: true })) {
-          const nextPath = path8__default.join(currentDir, entry.name);
+        for (const entry of fs9__default.readdirSync(currentDir, { withFileTypes: true })) {
+          const nextPath = path9__default.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             scan(nextPath);
           } else if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -15800,12 +15800,12 @@ function createHmrReloader() {
   };
   return reloader;
 }
-var STATE_RELATIVE_PATH = path8__default.join(".agents", "bootstrap-session.json");
+var STATE_RELATIVE_PATH = path9__default.join(".agents", "bootstrap-session.json");
 var PROJECT_ROOT_ENV_KEYS = ["INIT_CWD", "PWD", "npm_config_local_prefix"];
 function uniquePaths(paths) {
   return Array.from(
     new Set(
-      paths.filter((value) => !!value?.trim()).map((value) => path8__default.resolve(value))
+      paths.filter((value) => !!value?.trim()).map((value) => path9__default.resolve(value))
     )
   );
 }
@@ -15821,11 +15821,11 @@ function mergeCookieHeader(cookieHeader, injectedCookie) {
   return raw ? `${raw}; ${injectedCookie}` : injectedCookie;
 }
 function loadLocalBootstrapSession(projectRoot) {
-  const statePath = path8__default.join(projectRoot, STATE_RELATIVE_PATH);
-  if (!fs8__default.existsSync(statePath)) return null;
+  const statePath = path9__default.join(projectRoot, STATE_RELATIVE_PATH);
+  if (!fs9__default.existsSync(statePath)) return null;
   try {
     const parsed = JSON.parse(
-      fs8__default.readFileSync(statePath, "utf-8")
+      fs9__default.readFileSync(statePath, "utf-8")
     );
     if (parsed.version !== 1) return null;
     if (!parsed.endpoint || !parsed.user?.id || !parsed.account?.id) return null;
@@ -15842,7 +15842,7 @@ function findLocalBootstrapSession(projectRoot, env) {
   const envSession = loadLocalBootstrapSessionFromEnv();
   if (envSession) {
     return {
-      projectRoot: projectRoot ? path8__default.resolve(projectRoot) : process.cwd(),
+      projectRoot: projectRoot ? path9__default.resolve(projectRoot) : process.cwd(),
       session: envSession
     };
   }
@@ -16487,23 +16487,23 @@ function nameToFilename(name) {
 }
 function getModelFilePath(modelsDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(modelsDir, `${filename}.ts`);
+  return path9__default.join(modelsDir, `${filename}.ts`);
 }
 function getProviderFilePath(providersDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(providersDir, `${filename}.ts`);
+  return path9__default.join(providersDir, `${filename}.ts`);
 }
 function extensionlessImportPath(fromDir, toFile) {
-  let relative2 = path8__default.relative(fromDir, toFile).replace(/\\/g, "/").replace(/\.ts$/, "");
-  if (!relative2.startsWith(".")) {
-    relative2 = `./${relative2}`;
+  let relative4 = path9__default.relative(fromDir, toFile).replace(/\\/g, "/").replace(/\.ts$/, "");
+  if (!relative4.startsWith(".")) {
+    relative4 = `./${relative4}`;
   }
-  return relative2;
+  return relative4;
 }
 function getLocalProviderInfo(modelsDir, providersDir, providerName) {
   if (!providersDir) return null;
   const providerPath = getProviderFilePath(providersDir, providerName);
-  if (!fs8__default.existsSync(providerPath)) return null;
+  if (!fs9__default.existsSync(providerPath)) return null;
   return {
     name: nameToFilename(providerName),
     package: extensionlessImportPath(modelsDir, providerPath),
@@ -16512,15 +16512,15 @@ function getLocalProviderInfo(modelsDir, providersDir, providerName) {
 }
 function modelExists(modelsDir, name) {
   const filePath = getModelFilePath(modelsDir, name);
-  return fs8__default.existsSync(filePath);
+  return fs9__default.existsSync(filePath);
 }
 async function saveModel(modelsDir, data, overwrite = false, providerPackageMap = defaultProviderPackageMap, providersDir) {
   try {
-    if (!fs8__default.existsSync(modelsDir)) {
-      fs8__default.mkdirSync(modelsDir, { recursive: true });
+    if (!fs9__default.existsSync(modelsDir)) {
+      fs9__default.mkdirSync(modelsDir, { recursive: true });
     }
     const filePath = getModelFilePath(modelsDir, data.name);
-    if (!overwrite && fs8__default.existsSync(filePath)) {
+    if (!overwrite && fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file already exists: ${filePath}. Use update to modify existing models.`
@@ -16528,7 +16528,7 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
     }
     const providerInfo = providerPackageMap[data.provider] ?? getLocalProviderInfo(modelsDir, providersDir, data.provider);
     if (!providerInfo) {
-      const localProviderNames = providersDir && fs8__default.existsSync(providersDir) ? fs8__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
+      const localProviderNames = providersDir && fs9__default.existsSync(providersDir) ? fs9__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
       const validProviders = [...Object.keys(providerPackageMap), ...localProviderNames];
       return {
         success: false,
@@ -16540,7 +16540,7 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
       providerPackage: providerInfo.package,
       defaultImport: providerInfo.defaultImport
     });
-    await fs8__default.promises.writeFile(filePath, content, "utf-8");
+    await fs9__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -16555,13 +16555,13 @@ async function saveModel(modelsDir, data, overwrite = false, providerPackageMap
 async function deleteModel(modelsDir, name) {
   try {
     const filePath = getModelFilePath(modelsDir, name);
-    if (!fs8__default.existsSync(filePath)) {
+    if (!fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Model file not found: ${filePath}`
       };
     }
-    await fs8__default.promises.unlink(filePath);
+    await fs9__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -16607,7 +16607,7 @@ function validateModelDataWithProviders(data, providerPackageMap, providersDir)
     const validProviders = Object.keys(providerPackageMap);
     const hasLocalProvider = Boolean(getLocalProviderInfo(process.cwd(), providersDir, data.provider));
     if (!validProviders.includes(data.provider) && !hasLocalProvider) {
-      const localProviderNames = providersDir && fs8__default.existsSync(providersDir) ? fs8__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
+      const localProviderNames = providersDir && fs9__default.existsSync(providersDir) ? fs9__default.readdirSync(providersDir).filter((fileName) => fileName.endsWith(".ts")).map((fileName) => fileName.replace(/\.ts$/, "")) : [];
       errors["provider"] = `Invalid provider '${data.provider}'. Must be one of: ${[...validProviders, ...localProviderNames].join(", ")}`;
     }
   }
@@ -16824,26 +16824,26 @@ function transformPromptData(data) {
 }
 function getPromptFilePath(promptsDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(promptsDir, `${filename}.ts`);
+  return path9__default.join(promptsDir, `${filename}.ts`);
 }
 function promptExists(promptsDir, name) {
   const filePath = getPromptFilePath(promptsDir, name);
-  return fs8__default.existsSync(filePath);
+  return fs9__default.existsSync(filePath);
 }
 async function savePrompt(promptsDir, data, overwrite = false) {
   try {
-    if (!fs8__default.existsSync(promptsDir)) {
-      fs8__default.mkdirSync(promptsDir, { recursive: true });
+    if (!fs9__default.existsSync(promptsDir)) {
+      fs9__default.mkdirSync(promptsDir, { recursive: true });
     }
     const filePath = getPromptFilePath(promptsDir, data.name);
-    if (!overwrite && fs8__default.existsSync(filePath)) {
+    if (!overwrite && fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${filePath}. Use update to modify existing prompts.`
       };
     }
     const content = generatePromptFile(data);
-    await fs8__default.promises.writeFile(filePath, content, "utf-8");
+    await fs9__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -16858,13 +16858,13 @@ async function savePrompt(promptsDir, data, overwrite = false) {
 async function deletePrompt(promptsDir, name) {
   try {
     const filePath = getPromptFilePath(promptsDir, name);
-    if (!fs8__default.existsSync(filePath)) {
+    if (!fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${filePath}`
       };
     }
-    await fs8__default.promises.unlink(filePath);
+    await fs9__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -16880,25 +16880,25 @@ async function renamePrompt(promptsDir, oldName, newName) {
   try {
     const oldFilePath = getPromptFilePath(promptsDir, oldName);
     const newFilePath = getPromptFilePath(promptsDir, newName);
-    if (!fs8__default.existsSync(oldFilePath)) {
+    if (!fs9__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Prompt file not found: ${oldFilePath}`
       };
     }
-    if (fs8__default.existsSync(newFilePath)) {
+    if (fs9__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Prompt file already exists: ${newFilePath}`
       };
     }
-    const content = await fs8__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs9__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs8__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs8__default.promises.unlink(oldFilePath);
+    await fs9__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs9__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -17198,15 +17198,15 @@ function transformAgentData(data) {
 }
 function getAgentFilePath(agentsDir, name) {
   const filename = nameToFilename(name);
-  return path8__default.join(agentsDir, `${filename}.ts`);
+  return path9__default.join(agentsDir, `${filename}.ts`);
 }
 function agentExists(agentsDir, name) {
   const filePath = getAgentFilePath(agentsDir, name);
-  return fs8__default.existsSync(filePath);
+  return fs9__default.existsSync(filePath);
 }
 function extractAgentMetadata(filePath) {
   try {
-    const content = fs8__default.readFileSync(filePath, "utf-8");
+    const content = fs9__default.readFileSync(filePath, "utf-8");
     const metadata = {};
     const packageNameMatch = content.match(/packageName:\s*['"]([^'"]+)['"]/);
     if (packageNameMatch) metadata.packageName = packageNameMatch[1];
@@ -17223,17 +17223,17 @@ function extractAgentMetadata(filePath) {
 }
 async function saveAgent(agentsDir, data, overwrite = false) {
   try {
-    if (!fs8__default.existsSync(agentsDir)) {
-      fs8__default.mkdirSync(agentsDir, { recursive: true });
+    if (!fs9__default.existsSync(agentsDir)) {
+      fs9__default.mkdirSync(agentsDir, { recursive: true });
     }
     const filePath = getAgentFilePath(agentsDir, data.name);
-    if (!overwrite && fs8__default.existsSync(filePath)) {
+    if (!overwrite && fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file already exists: ${filePath}. Use update to modify existing agents.`
       };
     }
-    if (overwrite && fs8__default.existsSync(filePath)) {
+    if (overwrite && fs9__default.existsSync(filePath)) {
       const existingMetadata = extractAgentMetadata(filePath);
       if (existingMetadata.packageName && !data.packageName) {
         data.packageName = existingMetadata.packageName;
@@ -17249,7 +17249,7 @@ async function saveAgent(agentsDir, data, overwrite = false) {
       }
     }
     const content = generateAgentFile(data);
-    await fs8__default.promises.writeFile(filePath, content, "utf-8");
+    await fs9__default.promises.writeFile(filePath, content, "utf-8");
     return {
       success: true,
       filePath
@@ -17264,13 +17264,13 @@ async function saveAgent(agentsDir, data, overwrite = false) {
 async function deleteAgent(agentsDir, name) {
   try {
     const filePath = getAgentFilePath(agentsDir, name);
-    if (!fs8__default.existsSync(filePath)) {
+    if (!fs9__default.existsSync(filePath)) {
       return {
         success: false,
         error: `Agent file not found: ${filePath}`
       };
     }
-    await fs8__default.promises.unlink(filePath);
+    await fs9__default.promises.unlink(filePath);
     return {
       success: true,
       filePath
@@ -17286,25 +17286,25 @@ async function renameModel(modelsDir, oldName, newName) {
   try {
     const oldFilePath = getModelFilePath(modelsDir, oldName);
     const newFilePath = getModelFilePath(modelsDir, newName);
-    if (!fs8__default.existsSync(oldFilePath)) {
+    if (!fs9__default.existsSync(oldFilePath)) {
       return {
         success: false,
         error: `Model file not found: ${oldFilePath}`
       };
     }
-    if (fs8__default.existsSync(newFilePath)) {
+    if (fs9__default.existsSync(newFilePath)) {
       return {
         success: false,
         error: `Model file already exists: ${newFilePath}`
       };
     }
-    const content = await fs8__default.promises.readFile(oldFilePath, "utf-8");
+    const content = await fs9__default.promises.readFile(oldFilePath, "utf-8");
     const updatedContent = content.replace(
       /name:\s*['"]([^'"]+)['"]/,
       `name: '${newName}'`
     );
-    await fs8__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
-    await fs8__default.promises.unlink(oldFilePath);
+    await fs9__default.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs9__default.promises.unlink(oldFilePath);
     return {
       success: true,
       filePath: newFilePath
@@ -17318,17 +17318,17 @@ async function renameModel(modelsDir, oldName, newName) {
 }
 async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModelName) {
   const updatedFiles = [];
-  if (!fs8__default.existsSync(promptsDir)) {
+  if (!fs9__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs8__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs9__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path8__default.join(promptsDir, file);
-    let content = await fs8__default.promises.readFile(filePath, "utf-8");
+    const filePath = path9__default.join(promptsDir, file);
+    let content = await fs9__default.promises.readFile(filePath, "utf-8");
     const modelRegex = new RegExp(`model:\\s*['"]${escapeRegExp(oldModelName)}['"]`, "g");
     if (modelRegex.test(content)) {
       content = content.replace(modelRegex, `model: '${newModelName}'`);
-      await fs8__default.promises.writeFile(filePath, content, "utf-8");
+      await fs9__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -17336,13 +17336,13 @@ async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModel
 }
 async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs8__default.existsSync(promptsDir)) {
+  if (!fs9__default.existsSync(promptsDir)) {
     return updatedFiles;
   }
-  const files = fs8__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs9__default.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path8__default.join(promptsDir, file);
-    let content = await fs8__default.promises.readFile(filePath, "utf-8");
+    const filePath = path9__default.join(promptsDir, file);
+    let content = await fs9__default.promises.readFile(filePath, "utf-8");
     let modified = false;
     const toolsArrayRegex = /tools:\s*\[([^\]]*)\]/gs;
     const newContent = content.replace(toolsArrayRegex, (match) => {
@@ -17355,7 +17355,7 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
       return replaced;
     });
     if (modified) {
-      await fs8__default.promises.writeFile(filePath, newContent, "utf-8");
+      await fs9__default.promises.writeFile(filePath, newContent, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -17363,17 +17363,17 @@ async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPro
 }
 async function updatePromptReferencesInAgents(agentsDir, oldPromptName, newPromptName) {
   const updatedFiles = [];
-  if (!fs8__default.existsSync(agentsDir)) {
+  if (!fs9__default.existsSync(agentsDir)) {
     return updatedFiles;
   }
-  const files = fs8__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+  const files = fs9__default.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    const filePath = path8__default.join(agentsDir, file);
-    let content = await fs8__default.promises.readFile(filePath, "utf-8");
+    const filePath = path9__default.join(agentsDir, file);
+    let content = await fs9__default.promises.readFile(filePath, "utf-8");
     const promptRegex = new RegExp(`prompt:\\s*['"]${escapeRegExp(oldPromptName)}['"]`, "g");
     if (promptRegex.test(content)) {
       content = content.replace(promptRegex, `prompt: '${newPromptName}'`);
-      await fs8__default.promises.writeFile(filePath, content, "utf-8");
+      await fs9__default.promises.writeFile(filePath, content, "utf-8");
       updatedFiles.push(filePath);
     }
   }
@@ -17500,16 +17500,16 @@ function parseThreadEndpointRouteKey(input) {
   };
 }
 function scanThreadEndpointFiles(dir, options = {}) {
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return [];
   }
   const extensions = options.extensions ?? [".ts"];
   const routes = [];
   const scan = (currentDir, relativeDir = "") => {
-    const entries = fs8__default.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const filePath = path8__default.join(currentDir, entry.name);
-      const relativePath = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
+      const filePath = path9__default.join(currentDir, entry.name);
+      const relativePath = relativeDir ? path9__default.posix.join(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         scan(filePath, relativePath);
         continue;
@@ -17543,7 +17543,7 @@ function scanApiDirectory(dir) {
   try {
     return scanThreadEndpointFiles(dir, {
       extensions: [".ts"],
-      importPathForFile: (filePath) => "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/")
+      importPathForFile: (filePath) => "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/")
     }).map(({ method, route, importPath }) => ({
       method,
       route,
@@ -17555,26 +17555,26 @@ function scanApiDirectory(dir) {
   }
 }
 function discoverPackedPackageDirectories(packedDir) {
-  if (!fs8__default.existsSync(packedDir)) {
+  if (!fs9__default.existsSync(packedDir)) {
     return [];
   }
   const packageDirs = [];
-  const entries = fs8__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  const entries = fs9__default.readdirSync(packedDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
   for (const entry of entries) {
-    const fullPath = path8__default.join(packedDir, entry.name);
-    const packageJsonPath = path8__default.join(fullPath, "package.json");
-    if (fs8__default.existsSync(packageJsonPath)) {
+    const fullPath = path9__default.join(packedDir, entry.name);
+    const packageJsonPath = path9__default.join(fullPath, "package.json");
+    if (fs9__default.existsSync(packageJsonPath)) {
       packageDirs.push(fullPath);
       continue;
     }
     if (!entry.name.startsWith("@")) {
       continue;
     }
-    const scopedEntries = fs8__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
+    const scopedEntries = fs9__default.readdirSync(fullPath, { withFileTypes: true }).filter((scopedEntry) => scopedEntry.isDirectory());
     for (const scopedEntry of scopedEntries) {
-      const scopedPackagePath = path8__default.join(fullPath, scopedEntry.name);
-      const scopedPackageJson = path8__default.join(scopedPackagePath, "package.json");
-      if (fs8__default.existsSync(scopedPackageJson)) {
+      const scopedPackagePath = path9__default.join(fullPath, scopedEntry.name);
+      const scopedPackageJson = path9__default.join(scopedPackagePath, "package.json");
+      if (fs9__default.existsSync(scopedPackageJson)) {
         packageDirs.push(scopedPackagePath);
       }
     }
@@ -17582,26 +17582,26 @@ function discoverPackedPackageDirectories(packedDir) {
   return packageDirs;
 }
 function scanPackedDistDirectory(packagePath, outputDir, subDir) {
-  const fullPath = path8__default.join(packagePath, outputDir, subDir);
-  if (!fs8__default.existsSync(fullPath)) {
+  const fullPath = path9__default.join(packagePath, outputDir, subDir);
+  if (!fs9__default.existsSync(fullPath)) {
     return [];
   }
-  return fs8__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
+  return fs9__default.readdirSync(fullPath).filter((fileName) => fileName.endsWith(".js") || fileName.endsWith(".ts")).map((fileName) => ({
     name: fileName.replace(/\.(js|ts)$/, ""),
-    path: path8__default.join(fullPath, fileName).replace(/\\/g, "/")
+    path: path9__default.join(fullPath, fileName).replace(/\\/g, "/")
   }));
 }
 function scanPackedThreadEndpoints(packagePath, outputDir) {
-  const rootDir = path8__default.join(packagePath, outputDir, "thread-endpoints");
-  if (!fs8__default.existsSync(rootDir)) {
+  const rootDir = path9__default.join(packagePath, outputDir, "thread-endpoints");
+  if (!fs9__default.existsSync(rootDir)) {
     return [];
   }
   const endpoints = [];
   const scan = (dir, relativeDir = "") => {
-    const entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const nextRelative = relativeDir ? path8__default.posix.join(relativeDir, entry.name) : entry.name;
-      const absolutePath = path8__default.join(dir, entry.name);
+      const nextRelative = relativeDir ? path9__default.posix.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = path9__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         scan(absolutePath, nextRelative);
         continue;
@@ -17631,7 +17631,7 @@ function isSnakeCase(str) {
 }
 function validateToolFile(filePath, fileName) {
   try {
-    const content = fs8__default.readFileSync(filePath, "utf-8");
+    const content = fs9__default.readFileSync(filePath, "utf-8");
     const hasDefaultExport = /export\s+default\s+defineTool/.test(content);
     if (!hasDefaultExport) {
       return `Tool file '${fileName}.ts' must have a default export using defineTool()`;
@@ -17643,15 +17643,15 @@ function validateToolFile(filePath, fileName) {
 }
 async function scanToolsDirectory(dir) {
   const tools = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return tools;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       let toolError;
       const validationError = validateToolFile(filePath, fileName);
       if (validationError) {
@@ -17678,18 +17678,18 @@ async function scanToolsDirectory(dir) {
 }
 async function scanHooksDirectory(dir) {
   const hooks = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return hooks;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
       if (fileName === "index") continue;
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const idMatch = content.match(/id:\s*['"]([^'"]+)['"]/);
         const hookMatch = content.match(/hook:\s*['"]([^'"]+)['"]/);
         if (idMatch && hookMatch) {
@@ -17712,16 +17712,16 @@ async function scanHooksDirectory(dir) {
 }
 async function scanConfigDirectory(dir, definePattern) {
   const items = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return items;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       try {
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         const hasDefaultExport = definePattern.test(content);
         if (!hasDefaultExport) {
           items.push({
@@ -17766,20 +17766,20 @@ async function scanAgentsDirectory(dir) {
 }
 async function scanEffectsDirectory(dir) {
   const effects = [];
-  if (!fs8__default.existsSync(dir)) {
+  if (!fs9__default.existsSync(dir)) {
     return effects;
   }
-  const entries = await fs8__default.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs9__default.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".ts")) {
       const fileName = entry.name.replace(".ts", "");
-      const filePath = path8__default.join(dir, entry.name);
-      const importPath = "./" + path8__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const filePath = path9__default.join(dir, entry.name);
+      const importPath = "./" + path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
       if (fileName === "CLAUDE" || fileName.startsWith("_")) {
         continue;
       }
       try {
-        const content = fs8__default.readFileSync(filePath, "utf-8");
+        const content = fs9__default.readFileSync(filePath, "utf-8");
         if (!content.includes("defineEffect")) {
           continue;
         }
@@ -17792,14 +17792,14 @@ async function scanEffectsDirectory(dir) {
   return effects;
 }
 function parseRequestBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
     req.on("end", () => {
       try {
-        resolve2(body ? JSON.parse(body) : {});
+        resolve3(body ? JSON.parse(body) : {});
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -17809,17 +17809,17 @@ function parseRequestBody(req) {
 }
 function scanUsersDirectory(dir) {
   const results = [];
-  if (!fs8__default.existsSync(dir)) return results;
+  if (!fs9__default.existsSync(dir)) return results;
   const walk = (current, prefix) => {
     let entries;
     try {
-      entries = fs8__default.readdirSync(current, { withFileTypes: true });
+      entries = fs9__default.readdirSync(current, { withFileTypes: true });
     } catch (error) {
       console.error(`Error scanning users directory ${current}:`, error);
       return;
     }
     for (const entry of entries) {
-      const fullPath = path8__default.join(current, entry.name);
+      const fullPath = path9__default.join(current, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, prefix ? `${prefix}/${entry.name}` : entry.name);
         continue;
@@ -17829,7 +17829,7 @@ function scanUsersDirectory(dir) {
       const key = prefix ? `${prefix}/${base}` : base;
       results.push({
         key,
-        importPath: "./" + path8__default.relative(process.cwd(), fullPath).replace(/\\/g, "/")
+        importPath: "./" + path9__default.relative(process.cwd(), fullPath).replace(/\\/g, "/")
       });
     }
   };
@@ -18062,7 +18062,7 @@ async function handleModelApiRequest(context) {
         }
         await hmr.reloadRouterModule(server);
         await hmr.reloadBuilderModule(server);
-        await new Promise((resolve2) => setTimeout(resolve2, 100));
+        await new Promise((resolve3) => setTimeout(resolve3, 100));
         res.statusCode = 200;
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify({
@@ -18289,6 +18289,49 @@ async function handleConfigApiRequest(context) {
   if (await handleAgentApiRequest(context)) return true;
   return false;
 }
+
+// src/packing/package-identifier.ts
+function assertSafePackageIdentifier(identifier) {
+  const value = identifier.trim();
+  if (!value || value.includes("\\") || value.includes("\0") || value.startsWith("/")) {
+    throw new Error("Invalid package identifier");
+  }
+  const parts = value.split("/");
+  const scoped = parts.length === 2 && parts[0].startsWith("@");
+  if (parts.length > 1 && !scoped) throw new Error("Invalid package identifier");
+  if (parts.some((part) => !part || part === "." || part === ".." || !/^@?[a-zA-Z0-9._-]+$/.test(part))) {
+    throw new Error("Invalid package identifier");
+  }
+  return value;
+}
+
+// src/packing/path-safety.ts
+function isWithin(base, candidate) {
+  const relative4 = path9.relative(base, candidate);
+  return relative4 === "" || !relative4.startsWith(`..${path9.sep}`) && relative4 !== ".." && !path9.isAbsolute(relative4);
+}
+function resolvePathWithin(base, ...segments) {
+  const resolvedBase = path9.resolve(base);
+  const candidate = path9.resolve(resolvedBase, ...segments);
+  if (!isWithin(resolvedBase, candidate)) {
+    throw new Error("Path must remain inside the configured AgentBuilder directory");
+  }
+  if (fs9.existsSync(resolvedBase)) {
+    const realBase = fs9.realpathSync(resolvedBase);
+    if (typeof realBase !== "string") return candidate;
+    let existing = candidate;
+    while (!fs9.existsSync(existing) && existing !== resolvedBase) {
+      existing = path9.dirname(existing);
+    }
+    if (fs9.existsSync(existing)) {
+      const realExisting = fs9.realpathSync(existing);
+      if (typeof realExisting === "string" && !isWithin(realBase, realExisting)) {
+        throw new Error("Path traverses a symlink outside the configured AgentBuilder directory");
+      }
+    }
+  }
+  return candidate;
+}
 var MetadataService = class {
   metadataDir;
   /**
@@ -18297,7 +18340,7 @@ var MetadataService = class {
    * @param agentsDir - Path to the agents/ directory
    */
   constructor(agentsDir) {
-    this.metadataDir = path8.join(agentsDir, ".standardagent");
+    this.metadataDir = path9.join(agentsDir, ".standardagent");
   }
   /**
    * Read metadata for an agent.
@@ -18307,11 +18350,11 @@ var MetadataService = class {
    */
   async read(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = fs8.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -18324,11 +18367,11 @@ var MetadataService = class {
    * @param metadata - Metadata to write
    */
   async write(agentName, metadata) {
-    if (!fs8.existsSync(this.metadataDir)) {
-      fs8.mkdirSync(this.metadataDir, { recursive: true });
+    if (!fs9.existsSync(this.metadataDir)) {
+      fs9.mkdirSync(this.metadataDir, { recursive: true });
     }
     const filePath = this.getMetadataPath(agentName);
-    fs8.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+    fs9.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
   }
   /**
    * Delete metadata for an agent.
@@ -18337,8 +18380,8 @@ var MetadataService = class {
    */
   async delete(agentName) {
     const filePath = this.getMetadataPath(agentName);
-    if (fs8.existsSync(filePath)) {
-      fs8.unlinkSync(filePath);
+    if (fs9.existsSync(filePath)) {
+      fs9.unlinkSync(filePath);
     }
   }
   /**
@@ -18419,7 +18462,7 @@ var MetadataService = class {
    * Get the file path for an agent's metadata.
    */
   getMetadataPath(agentName) {
-    return path8.join(this.metadataDir, `${agentName}.json`);
+    return path9.join(this.metadataDir, `${agentName}.json`);
   }
 };
 var _ts;
@@ -18791,9 +18834,9 @@ var PackingService = class {
    * @returns Version specifier (e.g., '^1.2.3') or '*' if not found
    */
   resolvePackageVersion(pkgName, rootDir) {
-    const pkgJsonPath = path8.join(rootDir, "node_modules", pkgName, "package.json");
+    const pkgJsonPath = path9.join(rootDir, "node_modules", pkgName, "package.json");
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       return `^${pkgJson.version}`;
     } catch {
       return "*";
@@ -18810,7 +18853,7 @@ var PackingService = class {
    * @returns Analysis result with all discovered constituents
    */
   async analyzeAgent(agentName, rootDir) {
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const analysis = {
       agent: agentName,
       primaryPrompt: "",
@@ -18834,7 +18877,7 @@ var PackingService = class {
       warnings: [],
       errors: []
     };
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.errors.push(`Agent file not found: ${agentName}`);
       return analysis;
@@ -18845,7 +18888,7 @@ var PackingService = class {
       discoveredVia: "static",
       sharedWith: []
     });
-    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       analysis.primaryPrompt = agentPrompts.sideA;
@@ -18870,13 +18913,13 @@ var PackingService = class {
    * @returns Object with generatedReadme and agentDescription
    */
   async generateReadmeForAnalysis(analysis, rootDir) {
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const metadataService = new MetadataService(agentsDir);
     let agentDescription;
     const agentItem = analysis.constituents.agents.find((a) => a.name === analysis.agent);
     if (agentItem?.filePath) {
       try {
-        const agentSource = fs8.readFileSync(agentItem.filePath, "utf-8");
+        const agentSource = fs9.readFileSync(agentItem.filePath, "utf-8");
         agentDescription = await extractAgentDescription(agentSource) || void 0;
       } catch {
       }
@@ -18900,7 +18943,7 @@ var PackingService = class {
    * include all endpoint modules discovered under agents/api.
    */
   async analyzeThreadEndpoints(agentsDir, analysis) {
-    const apiDir = path8.join(agentsDir, "api");
+    const apiDir = path9.join(agentsDir, "api");
     const endpoints = this.scanThreadEndpointFiles(apiDir);
     for (const endpoint of endpoints) {
       if (analysis.constituents.threadEndpoints.some((item) => item.name === endpoint.name)) {
@@ -18922,15 +18965,15 @@ var PackingService = class {
    * - `admin/users/[userId]/sync.post`
    */
   scanThreadEndpointFiles(apiDir, relativeDir = "") {
-    if (!fs8.existsSync(apiDir)) {
+    if (!fs9.existsSync(apiDir)) {
       return [];
     }
     const endpoints = [];
-    const currentDir = relativeDir ? path8.join(apiDir, relativeDir) : apiDir;
-    if (!fs8.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path9.join(apiDir, relativeDir) : apiDir;
+    if (!fs9.existsSync(currentDir)) {
       return endpoints;
     }
-    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return endpoints;
     }
@@ -18938,8 +18981,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path8.join(apiDir, entryRelative);
+      const entryRelative = relativeDir ? path9.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path9.join(apiDir, entryRelative);
       if (isDirectory) {
         endpoints.push(...this.scanThreadEndpointFiles(apiDir, entryRelative));
         continue;
@@ -18966,7 +19009,7 @@ var PackingService = class {
    * include all effect modules discovered under agents/effects.
    */
   async analyzeEffects(agentsDir, analysis) {
-    const effectsDir = path8.join(agentsDir, "effects");
+    const effectsDir = path9.join(agentsDir, "effects");
     const effects = this.scanEffectFiles(effectsDir);
     for (const effect of effects) {
       if (analysis.constituents.effects.some((item) => item.name === effect.name)) {
@@ -18988,15 +19031,15 @@ var PackingService = class {
    * - `notifications/digest`
    */
   scanEffectFiles(effectsDir, relativeDir = "") {
-    if (!fs8.existsSync(effectsDir)) {
+    if (!fs9.existsSync(effectsDir)) {
       return [];
     }
     const effects = [];
-    const currentDir = relativeDir ? path8.join(effectsDir, relativeDir) : effectsDir;
-    if (!fs8.existsSync(currentDir)) {
+    const currentDir = relativeDir ? path9.join(effectsDir, relativeDir) : effectsDir;
+    if (!fs9.existsSync(currentDir)) {
       return effects;
     }
-    const entries = fs8.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(currentDir, { withFileTypes: true });
     if (entries.length > 0 && typeof entries[0] === "string") {
       return effects;
     }
@@ -19004,8 +19047,8 @@ var PackingService = class {
       const entryName = typeof entry === "string" ? entry : entry.name;
       const isDirectory = typeof entry === "string" ? false : entry.isDirectory();
       const isFile = typeof entry === "string" ? true : entry.isFile();
-      const entryRelative = relativeDir ? path8.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
-      const absolutePath = path8.join(effectsDir, entryRelative);
+      const entryRelative = relativeDir ? path9.posix.join(relativeDir.replace(/\\/g, "/"), entryName) : entryName;
+      const absolutePath = path9.join(effectsDir, entryRelative);
       if (isDirectory) {
         effects.push(...this.scanEffectFiles(effectsDir, entryRelative));
         continue;
@@ -19029,7 +19072,7 @@ var PackingService = class {
    * Recursively analyze a prompt and its dependencies.
    */
   async analyzePrompt(promptName, agentsDir, analysis, visited, parentKey) {
-    const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
+    const promptFilePath = await this.findFile(path9.join(agentsDir, "prompts"), promptName);
     if (!promptFilePath) {
       analysis.warnings.push(`Prompt file not found: ${promptName}`);
       return;
@@ -19048,7 +19091,7 @@ var PackingService = class {
       return;
     }
     visited.add(`prompt:${promptName}`);
-    const promptSource = fs8.readFileSync(promptFilePath, "utf-8");
+    const promptSource = fs9.readFileSync(promptFilePath, "utf-8");
     const modelName = await extractPromptModel(promptSource);
     if (modelName) {
       await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
@@ -19074,17 +19117,17 @@ var PackingService = class {
    */
   async analyzeTool(toolName, agentsDir, analysis, visited, discoveredVia, parentKey) {
     const thisKey = `tool:${toolName}`;
-    const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), toolName);
+    const promptFilePath = await this.findFile(path9.join(agentsDir, "prompts"), toolName);
     if (promptFilePath) {
       await this.analyzePrompt(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), toolName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), toolName);
     if (agentFilePath) {
       await this.analyzeNestedAgent(toolName, agentsDir, analysis, visited, parentKey);
       return;
     }
-    const toolFilePath = await this.findFile(path8.join(agentsDir, "tools"), toolName);
+    const toolFilePath = await this.findFile(path9.join(agentsDir, "tools"), toolName);
     if (!toolFilePath) {
       analysis.warnings.push(`Tool file not found: ${toolName}`);
       return;
@@ -19102,7 +19145,7 @@ var PackingService = class {
       return;
     }
     visited.add(`tool:${toolName}`);
-    const toolSource = fs8.readFileSync(toolFilePath, "utf-8");
+    const toolSource = fs9.readFileSync(toolFilePath, "utf-8");
     const { uses } = await extractToolUses(toolSource);
     for (const usedItem of uses) {
       await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
@@ -19112,7 +19155,7 @@ var PackingService = class {
    * Analyze a nested agent (used as a handoff target).
    */
   async analyzeNestedAgent(agentName, agentsDir, analysis, visited, parentKey) {
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) {
       analysis.warnings.push(`Agent file not found: ${agentName}`);
       return;
@@ -19131,7 +19174,7 @@ var PackingService = class {
       return;
     }
     visited.add(`agent:${agentName}`);
-    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     if (agentPrompts.sideA) {
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
@@ -19144,7 +19187,7 @@ var PackingService = class {
    * Analyze a model and its fallbacks.
    */
   async analyzeModel(modelName, agentsDir, analysis, visited, parentKey) {
-    const modelFilePath = await this.findFile(path8.join(agentsDir, "models"), modelName);
+    const modelFilePath = await this.findFile(path9.join(agentsDir, "models"), modelName);
     if (!modelFilePath) {
       analysis.warnings.push(`Model file not found: ${modelName}`);
       return;
@@ -19163,7 +19206,7 @@ var PackingService = class {
       return;
     }
     visited.add(`model:${modelName}`);
-    const modelSource = fs8.readFileSync(modelFilePath, "utf-8");
+    const modelSource = fs9.readFileSync(modelFilePath, "utf-8");
     const fallbacks = await extractModelFallbacks(modelSource);
     for (const fallbackName of fallbacks) {
       await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
@@ -19173,13 +19216,13 @@ var PackingService = class {
    * Check which items are shared with other agents.
    */
   async checkSharedItems(agentsDir, analysis) {
-    const agentsPath = path8.join(agentsDir, "agents");
-    if (!fs8.existsSync(agentsPath)) return;
-    const agentFiles = fs8.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
+    const agentsPath = path9.join(agentsDir, "agents");
+    if (!fs9.existsSync(agentsPath)) return;
+    const agentFiles = fs9.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
     for (const agentFile of agentFiles) {
       const otherAgentName = agentFile.replace(".ts", "");
       if (otherAgentName === analysis.agent) continue;
-      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path8.dirname(agentsDir));
+      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path9.dirname(agentsDir));
       for (const prompt of analysis.constituents.prompts) {
         if (otherAnalysis.prompts.includes(prompt.name)) {
           prompt.sharedWith.push(otherAgentName);
@@ -19211,19 +19254,19 @@ var PackingService = class {
    */
   async analyzeAgentLight(agentName, rootDir) {
     const result = { prompts: [], tools: [], models: [] };
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const visited = /* @__PURE__ */ new Set();
-    const agentFilePath = await this.findFile(path8.join(agentsDir, "agents"), agentName);
+    const agentFilePath = await this.findFile(path9.join(agentsDir, "agents"), agentName);
     if (!agentFilePath) return result;
-    const agentSource = fs8.readFileSync(agentFilePath, "utf-8");
+    const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
     const analyzePromptLight = async (promptName) => {
       if (visited.has(promptName)) return;
       visited.add(promptName);
       result.prompts.push(promptName);
-      const promptFilePath = await this.findFile(path8.join(agentsDir, "prompts"), promptName);
+      const promptFilePath = await this.findFile(path9.join(agentsDir, "prompts"), promptName);
       if (!promptFilePath) return;
-      const promptSource = fs8.readFileSync(promptFilePath, "utf-8");
+      const promptSource = fs9.readFileSync(promptFilePath, "utf-8");
       const modelName = await extractPromptModel(promptSource);
       if (modelName && !result.models.includes(modelName)) {
         result.models.push(modelName);
@@ -19296,14 +19339,15 @@ var PackingService = class {
         return result;
       }
       result.warnings = analysis.warnings;
-      const pkgOutputDir = path8.join(outputDir, packageId);
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "agents"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "tools"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "models"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "effects"), { recursive: true });
-      fs8.mkdirSync(path8.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
+      const safePackageId = assertSafePackageIdentifier(packageId);
+      const pkgOutputDir = resolvePathWithin(outputDir, safePackageId);
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "effects"), { recursive: true });
+      fs9.mkdirSync(path9.join(pkgOutputDir, "dist", "thread-endpoints"), { recursive: true });
       const seenItems = /* @__PURE__ */ new Set();
       const allItems = [];
       for (const a of analysis.constituents.agents) {
@@ -19357,13 +19401,13 @@ var PackingService = class {
       }
       const externalDeps = /* @__PURE__ */ new Map();
       for (const item of allItems) {
-        const outputPath = path8.join(
+        const outputPath = resolvePathWithin(
           pkgOutputDir,
           "dist",
           this.getTypeDir(item.type),
           `${item.name}.js`
         );
-        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
         const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
         for (const [depName, depVersion] of deps) {
           if (!externalDeps.has(depName)) {
@@ -19373,12 +19417,12 @@ var PackingService = class {
         result.filesCreated.push(outputPath);
       }
       const indexJs = this.generateReExportIndex(analysis, meta);
-      const indexJsPath = path8.join(pkgOutputDir, "dist", "index.js");
-      fs8.writeFileSync(indexJsPath, indexJs);
+      const indexJsPath = resolvePathWithin(pkgOutputDir, "dist", "index.js");
+      fs9.writeFileSync(indexJsPath, indexJs);
       result.filesCreated.push(indexJsPath);
       const indexDts = this.generateIndexDts(analysis);
-      const indexDtsPath = path8.join(pkgOutputDir, "dist", "index.d.ts");
-      fs8.writeFileSync(indexDtsPath, indexDts);
+      const indexDtsPath = resolvePathWithin(pkgOutputDir, "dist", "index.d.ts");
+      fs9.writeFileSync(indexDtsPath, indexDts);
       result.filesCreated.push(indexDtsPath);
       const pkgJson = this.generatePackageJson(
         finalPackageName,
@@ -19391,13 +19435,13 @@ var PackingService = class {
         license,
         licenseOwner
       );
-      const pkgJsonPath = path8.join(pkgOutputDir, "package.json");
-      fs8.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+      const pkgJsonPath = path9.join(pkgOutputDir, "package.json");
+      fs9.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
       result.filesCreated.push(pkgJsonPath);
       if (license) {
         const licenseContent = this.generateLicenseFile(license, licenseOwner);
-        const licensePath = path8.join(pkgOutputDir, "LICENSE");
-        fs8.writeFileSync(licensePath, licenseContent);
+        const licensePath = path9.join(pkgOutputDir, "LICENSE");
+        fs9.writeFileSync(licensePath, licenseContent);
         result.filesCreated.push(licensePath);
       }
       let readmeContent = readme;
@@ -19405,7 +19449,7 @@ var PackingService = class {
         const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
         let agentDescription;
         if (agentItem?.filePath) {
-          const agentSource = fs8.readFileSync(agentItem.filePath, "utf-8");
+          const agentSource = fs9.readFileSync(agentItem.filePath, "utf-8");
           agentDescription = await extractAgentDescription(agentSource) || void 0;
         }
         readmeContent = this.generateReadme(
@@ -19416,21 +19460,21 @@ var PackingService = class {
           agentDescription
         );
       }
-      const readmePath = path8.join(pkgOutputDir, "README.md");
-      fs8.writeFileSync(readmePath, readmeContent);
+      const readmePath = path9.join(pkgOutputDir, "README.md");
+      fs9.writeFileSync(readmePath, readmeContent);
       result.filesCreated.push(readmePath);
       if (removeOriginals || itemSelections) {
         result.filesRemoved = [];
         for (const item of allItems) {
           const selection = itemSelections?.find((s) => s.name === item.name && s.type === item.type);
           const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0 && item.type !== "thread-endpoint" && item.type !== "effect";
-          if (shouldRemove && fs8.existsSync(item.filePath)) {
-            fs8.unlinkSync(item.filePath);
+          if (shouldRemove && fs9.existsSync(item.filePath)) {
+            fs9.unlinkSync(item.filePath);
             result.filesRemoved.push(item.filePath);
           }
         }
       }
-      const agentsDir = path8.join(rootDir, "agents");
+      const agentsDir = path9.join(rootDir, "agents");
       const metadataService = new MetadataService(agentsDir);
       const metadata = {
         packageName: finalPackageName,
@@ -19464,7 +19508,7 @@ var PackingService = class {
     const commonjs = (await import('@rollup/plugin-commonjs')).default;
     const esbuild = (await import('rollup-plugin-esbuild')).default;
     const externalDeps = /* @__PURE__ */ new Map();
-    const agentsDir = path8.join(rootDir, "agents");
+    const agentsDir = path9.join(rootDir, "agents");
     const resolveVersion = this.resolvePackageVersion.bind(this);
     const trackExternalsPlugin = {
       name: "track-externals",
@@ -19473,14 +19517,14 @@ var PackingService = class {
           return null;
         }
         if (source.startsWith("./") || source.startsWith("../")) {
-          const resolved = path8.resolve(path8.dirname(importer), source);
+          const resolved = path9.resolve(path9.dirname(importer), source);
           let tsResolved = resolved;
           if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
-            if (fs8.existsSync(`${resolved}.ts`)) {
+            if (fs9.existsSync(`${resolved}.ts`)) {
               tsResolved = `${resolved}.ts`;
-            } else if (fs8.existsSync(`${resolved}.js`)) {
+            } else if (fs9.existsSync(`${resolved}.js`)) {
               tsResolved = `${resolved}.js`;
-            } else if (fs8.existsSync(`${resolved}/index.ts`)) {
+            } else if (fs9.existsSync(`${resolved}/index.ts`)) {
               tsResolved = `${resolved}/index.ts`;
             }
           }
@@ -19529,11 +19573,11 @@ var PackingService = class {
         exports: "named"
       });
       const bundledCode = output[0].code;
-      const header = `// Bundled from: ${path8.relative(rootDir, inputPath)}
+      const header = `// Bundled from: ${path9.relative(rootDir, inputPath)}
 // Local dependencies have been inlined
 
 `;
-      fs8.writeFileSync(outputPath, header + bundledCode);
+      fs9.writeFileSync(outputPath, header + bundledCode);
       await bundle.close();
     } catch (error) {
       await bundle.close();
@@ -19958,30 +20002,31 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Package info or null if not found
    */
   getPackedInfo(packageId, rootDir) {
-    const packedDir = path8.join(rootDir, "agents", "packed");
-    let packageDir = path8.join(packedDir, packageId);
-    if (!fs8.existsSync(packageDir)) {
-      if (!fs8.existsSync(packedDir)) {
+    const packedDir = path9.join(rootDir, "agents", "packed");
+    const safePackageId = assertSafePackageIdentifier(packageId);
+    let packageDir = resolvePathWithin(packedDir, safePackageId);
+    if (!fs9.existsSync(packageDir)) {
+      if (!fs9.existsSync(packedDir)) {
         return null;
       }
-      const dirs = fs8.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = fs9.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       const matchingDir = dirs.find(
         (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
       );
       if (!matchingDir) {
         return null;
       }
-      packageDir = path8.join(packedDir, matchingDir);
+      packageDir = path9.join(packedDir, matchingDir);
     }
-    const pkgJsonPath = path8.join(packageDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(packageDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return null;
     }
-    const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
     let readme;
-    const readmePath = path8.join(packageDir, "README.md");
-    if (fs8.existsSync(readmePath)) {
-      readme = fs8.readFileSync(readmePath, "utf-8");
+    const readmePath = path9.join(packageDir, "README.md");
+    if (fs9.existsSync(readmePath)) {
+      readme = fs9.readFileSync(readmePath, "utf-8");
     }
     return {
       packageName: pkgJson.name,
@@ -19999,11 +20044,11 @@ Copyright (c) ${year} ${copyrightHolder}
    * @returns Array of package directory names
    */
   listPackedPackages(rootDir) {
-    const packedDir = path8.join(rootDir, "agents", "packed");
-    if (!fs8.existsSync(packedDir)) {
+    const packedDir = path9.join(rootDir, "agents", "packed");
+    if (!fs9.existsSync(packedDir)) {
       return [];
     }
-    return fs8.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return fs9.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   /**
    * Generate README.md content for a packed agent.
@@ -20050,17 +20095,17 @@ ${license || "See LICENSE file"}
    * Find a file by name in a directory.
    */
   async findFile(dir, name) {
-    if (!fs8.existsSync(dir)) {
+    if (!fs9.existsSync(dir)) {
       return null;
     }
-    const exactPath = path8.join(dir, `${name}.ts`);
-    if (fs8.existsSync(exactPath)) {
+    const exactPath = resolvePathWithin(dir, `${name}.ts`);
+    if (fs9.existsSync(exactPath)) {
       return exactPath;
     }
-    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    const files = fs9.readdirSync(dir).filter((f) => f.endsWith(".ts"));
     for (const file of files) {
-      const filePath = path8.join(dir, file);
-      const source = fs8.readFileSync(filePath, "utf-8");
+      const filePath = path9.join(dir, file);
+      const source = fs9.readFileSync(filePath, "utf-8");
       const extractedName = await extractDefinitionName(source);
       if (extractedName === name) {
         return filePath;
@@ -20072,15 +20117,15 @@ ${license || "See LICENSE file"}
    * List all agents in the workspace.
    */
   async listAgents(rootDir) {
-    const agentsDir = path8.join(rootDir, "agents", "agents");
-    if (!fs8.existsSync(agentsDir)) {
+    const agentsDir = path9.join(rootDir, "agents", "agents");
+    if (!fs9.existsSync(agentsDir)) {
       return [];
     }
-    const files = fs8.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const files = fs9.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
     const agents = [];
     for (const file of files) {
-      const filePath = path8.join(agentsDir, file);
-      const source = fs8.readFileSync(filePath, "utf-8");
+      const filePath = path9.join(agentsDir, file);
+      const source = fs9.readFileSync(filePath, "utf-8");
       const name = await extractDefinitionName(source);
       if (name) {
         agents.push(name);
@@ -20096,7 +20141,7 @@ var PackageDiscoveryService = class {
   constructor(config) {
     this.config = {
       rootDir: config.rootDir,
-      packedDir: config.packedDir ?? path8.join(config.rootDir, "agents", "packed"),
+      packedDir: config.packedDir ?? path9.join(config.rootDir, "agents", "packed"),
       scanNpm: config.scanNpm ?? true,
       scanLocal: config.scanLocal ?? true
     };
@@ -20129,19 +20174,19 @@ var PackageDiscoveryService = class {
    */
   async discoverNpmPackages() {
     const packages = [];
-    const nodeModulesDir = path8.join(this.config.rootDir, "node_modules");
-    if (!fs8.existsSync(nodeModulesDir)) {
+    const nodeModulesDir = path9.join(this.config.rootDir, "node_modules");
+    if (!fs9.existsSync(nodeModulesDir)) {
       return packages;
     }
     const rootEntries = await this.scanDirectory(nodeModulesDir);
     for (const entry of rootEntries) {
       if (entry.startsWith(".")) continue;
       if (entry.startsWith("@")) {
-        const scopeDir = path8.join(nodeModulesDir, entry);
+        const scopeDir = path9.join(nodeModulesDir, entry);
         const scopeEntries = await this.scanDirectory(scopeDir);
         for (const scopedPkg of scopeEntries) {
           if (scopedPkg.startsWith(".")) continue;
-          const pkgDir = path8.join(scopeDir, scopedPkg);
+          const pkgDir = path9.join(scopeDir, scopedPkg);
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkNpmPackage(pkgDir, fullName);
           if (pkg) {
@@ -20149,7 +20194,7 @@ var PackageDiscoveryService = class {
           }
         }
       } else {
-        const pkgDir = path8.join(nodeModulesDir, entry);
+        const pkgDir = path9.join(nodeModulesDir, entry);
         const pkg = await this.checkNpmPackage(pkgDir, entry);
         if (pkg) {
           packages.push(pkg);
@@ -20165,12 +20210,12 @@ var PackageDiscoveryService = class {
    * which must contain `entryAgents` array.
    */
   async checkNpmPackage(pkgDir, pkgName) {
-    const pkgJsonPath = path8.join(pkgDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(pkgDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       const isStandardAgent = (
         // Has "standardagent" keyword
         pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
@@ -20207,21 +20252,21 @@ var PackageDiscoveryService = class {
    */
   async discoverLocalPackages() {
     const packages = [];
-    if (!fs8.existsSync(this.config.packedDir)) {
+    if (!fs9.existsSync(this.config.packedDir)) {
       return packages;
     }
     const entries = await this.scanDirectory(this.config.packedDir);
     for (const entry of entries) {
       if (entry.startsWith(".")) continue;
-      const pkgDir = path8.join(this.config.packedDir, entry);
-      const stat2 = fs8.statSync(pkgDir);
+      const pkgDir = path9.join(this.config.packedDir, entry);
+      const stat2 = fs9.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 = path8.join(pkgDir, scopedPkg);
-          const scopedStat = fs8.statSync(scopedPkgDir);
+          const scopedPkgDir = path9.join(pkgDir, scopedPkg);
+          const scopedStat = fs9.statSync(scopedPkgDir);
           if (!scopedStat.isDirectory()) continue;
           const fullName = `${entry}/${scopedPkg}`;
           const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
@@ -20244,12 +20289,12 @@ var PackageDiscoveryService = class {
    * Detection is based on the `standardagent` field in package.json.
    */
   async checkLocalPackage(pkgDir, dirName) {
-    const pkgJsonPath = path8.join(pkgDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(pkgDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return null;
     }
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       if (!pkgJson.standardagent?.entryAgents) {
         return null;
       }
@@ -20274,10 +20319,10 @@ var PackageDiscoveryService = class {
    * Scan a directory and return entry names.
    */
   async scanDirectory(dir) {
-    if (!fs8.existsSync(dir)) {
+    if (!fs9.existsSync(dir)) {
       return [];
     }
-    const entries = fs8.readdirSync(dir);
+    const entries = fs9.readdirSync(dir);
     return entries;
   }
   /**
@@ -20374,29 +20419,29 @@ var UnpackingService = class {
       }
       analysis.version = pkg.version;
       analysis.source = pkg.source;
-      const indexPath = path8.join(pkg.path, "dist", "index.js");
-      if (!fs8.existsSync(indexPath)) {
+      const indexPath = path9.join(pkg.path, "dist", "index.js");
+      if (!fs9.existsSync(indexPath)) {
         analysis.errors.push(`Package index not found: ${indexPath}`);
         return analysis;
       }
-      const indexContent = fs8.readFileSync(indexPath, "utf-8");
+      const indexContent = fs9.readFileSync(indexPath, "utf-8");
       const registryItems = await this.parseIndexExports(indexContent);
       const availableItems = /* @__PURE__ */ new Map();
       for (const item of registryItems) {
         availableItems.set(`${item.type}:${item.name}`, item);
       }
-      const agentsDir = path8.join(rootDir, "agents");
+      const agentsDir = path9.join(rootDir, "agents");
       const itemsWithRelations = [];
       for (const item of registryItems) {
-        const targetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
-        const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+        const targetPath = resolvePathWithin(agentsDir, TYPE_TO_TARGET_DIR[item.type], `${item.name}.ts`);
+        const sourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
         const existsGlobally = this.fileExists(targetPath);
-        const sourceExists = fs8.existsSync(sourcePath);
+        const sourceExists = fs9.existsSync(sourcePath);
         if (!sourceExists) {
           analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
           continue;
         }
-        const bundledCode = fs8.readFileSync(sourcePath, "utf-8");
+        const bundledCode = fs9.readFileSync(sourcePath, "utf-8");
         const children = await this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
         itemsWithRelations.push({
           name: item.name,
@@ -20406,10 +20451,10 @@ var UnpackingService = class {
           action: existsGlobally ? "skip" : "generate"
         });
         for (const child of children) {
-          const childTargetPath = path8.join(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
-          const childSourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
+          const childTargetPath = resolvePathWithin(agentsDir, TYPE_TO_TARGET_DIR[child.type], `${child.name}.ts`);
+          const childSourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
           const childExists = this.fileExists(childTargetPath);
-          const childSourceExists = fs8.existsSync(childSourcePath);
+          const childSourceExists = fs9.existsSync(childSourcePath);
           if (!childSourceExists) {
             continue;
           }
@@ -20512,8 +20557,8 @@ var UnpackingService = class {
         return result;
       }
       const itemsToProcess = this.applySelections(analysis.items, itemSelections);
-      const pkgJsonPath = path8.join(pkg.path, "package.json");
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJsonPath = path9.join(pkg.path, "package.json");
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       let author = "";
       if (typeof pkgJson.author === "string") {
         author = pkgJson.author;
@@ -20538,18 +20583,19 @@ var UnpackingService = class {
           continue;
         }
         try {
-          const sourcePath = path8.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
-          const bundledCode = fs8.readFileSync(sourcePath, "utf-8");
+          const sourcePath = resolvePathWithin(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+          const targetPath = resolvePathWithin(path9.join(rootDir, "agents"), path9.relative(path9.join(rootDir, "agents"), item.targetPath));
+          const bundledCode = fs9.readFileSync(sourcePath, "utf-8");
           let tsCode = await transformBundledJs(bundledCode);
           if (item.type === "agent") {
             tsCode = await injectAgentMetadata(tsCode, agentMetadata);
           }
-          const dir = path8.dirname(item.targetPath);
-          if (!fs8.existsSync(dir)) {
-            fs8.mkdirSync(dir, { recursive: true });
+          const dir = path9.dirname(targetPath);
+          if (!fs9.existsSync(dir)) {
+            fs9.mkdirSync(dir, { recursive: true });
           }
-          fs8.writeFileSync(item.targetPath, tsCode);
-          result.filesGenerated.push(item.targetPath);
+          fs9.writeFileSync(targetPath, tsCode);
+          result.filesGenerated.push(targetPath);
         } catch (error) {
           result.warnings.push(
             `Failed to generate ${item.type} "${item.name}": ${error instanceof Error ? error.message : String(error)}`
@@ -20558,7 +20604,12 @@ var UnpackingService = class {
       }
       if (deletePackage && pkg.source === "local") {
         try {
-          this.deleteDirectory(pkg.path);
+          const localPackedRoot = path9.join(rootDir, "agents", "packed");
+          const safePackagePath = resolvePathWithin(
+            localPackedRoot,
+            path9.relative(localPackedRoot, pkg.path)
+          );
+          this.deleteDirectory(safePackagePath);
           result.packageDeleted = true;
         } catch (error) {
           result.warnings.push(
@@ -20637,14 +20688,14 @@ var UnpackingService = class {
    */
   async resolvePackage(pkgIdentifier, rootDir) {
     if (pkgIdentifier.startsWith("/") || pkgIdentifier.startsWith("./")) {
-      const absolutePath = path8.isAbsolute(pkgIdentifier) ? pkgIdentifier : path8.join(rootDir, pkgIdentifier);
-      const pkgJsonPath2 = path8.join(absolutePath, "package.json");
-      if (fs8.existsSync(pkgJsonPath2)) {
+      const absolutePath = path9.isAbsolute(pkgIdentifier) ? pkgIdentifier : path9.join(rootDir, pkgIdentifier);
+      const pkgJsonPath2 = path9.join(absolutePath, "package.json");
+      if (fs9.existsSync(pkgJsonPath2)) {
         try {
-          const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath2, "utf-8"));
+          const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath2, "utf-8"));
           if (pkgJson.standardagent?.entryAgents) {
             return {
-              packageId: pkgJson.name || path8.basename(absolutePath),
+              packageId: pkgJson.name || path9.basename(absolutePath),
               version: pkgJson.version || "0.0.0",
               source: "local",
               path: absolutePath,
@@ -20656,11 +20707,12 @@ var UnpackingService = class {
       }
       return null;
     }
-    const packedDir = path8.join(rootDir, "agents", "packed", pkgIdentifier);
-    const pkgJsonPath = path8.join(packedDir, "package.json");
-    if (fs8.existsSync(pkgJsonPath)) {
+    const safeIdentifier = assertSafePackageIdentifier(pkgIdentifier);
+    const packedDir = resolvePathWithin(path9.join(rootDir, "agents", "packed"), safeIdentifier);
+    const pkgJsonPath = path9.join(packedDir, "package.json");
+    if (fs9.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.standardagent?.entryAgents) {
           return {
             packageId: pkgJson.name || pkgIdentifier,
@@ -20701,18 +20753,18 @@ var UnpackingService = class {
    * Check if a file exists.
    */
   fileExists(filePath) {
-    if (fs8.existsSync(filePath)) {
+    if (fs9.existsSync(filePath)) {
       return true;
     }
     const withoutExt = filePath.replace(/\.(ts|js)$/, "");
-    return fs8.existsSync(`${withoutExt}.ts`) || fs8.existsSync(`${withoutExt}.js`);
+    return fs9.existsSync(`${withoutExt}.ts`) || fs9.existsSync(`${withoutExt}.js`);
   }
   /**
    * Recursively delete a directory.
    */
   deleteDirectory(dirPath) {
-    if (fs8.existsSync(dirPath)) {
-      fs8.rmSync(dirPath, { recursive: true, force: true });
+    if (fs9.existsSync(dirPath)) {
+      fs9.rmSync(dirPath, { recursive: true, force: true });
     }
   }
   /**
@@ -20788,8 +20840,8 @@ var NpmPublishService = class {
         error: "Registry URL must use HTTPS"
       };
     }
-    const pkgJsonPath = path8.join(packageDir, "package.json");
-    if (!fs8.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path9.join(packageDir, "package.json");
+    if (!fs9.existsSync(pkgJsonPath)) {
       return {
         success: false,
         output: "",
@@ -20799,7 +20851,7 @@ var NpmPublishService = class {
     let packageName;
     let version;
     try {
-      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
       packageName = pkgJson.name;
       version = pkgJson.version;
     } catch (e) {
@@ -20809,13 +20861,13 @@ var NpmPublishService = class {
         error: `Failed to read package.json: ${e instanceof Error ? e.message : String(e)}`
       };
     }
-    const npmrcPath = path8.join(packageDir, ".npmrc");
+    const npmrcPath = path9.join(packageDir, ".npmrc");
     const registryHost = new URL(registry).host;
     const npmrcContent = `//${registryHost}/:_authToken=${token}
 registry=${registry}
 `;
     try {
-      fs8.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
+      fs9.writeFileSync(npmrcPath, npmrcContent, { mode: 384 });
       const args = ["publish"];
       if (dryRun) {
         args.push("--dry-run");
@@ -20847,8 +20899,8 @@ registry=${registry}
       };
     } finally {
       try {
-        if (fs8.existsSync(npmrcPath)) {
-          fs8.unlinkSync(npmrcPath);
+        if (fs9.existsSync(npmrcPath)) {
+          fs9.unlinkSync(npmrcPath);
         }
       } catch {
       }
@@ -20941,7 +20993,7 @@ async function handlePackingApiRequest(context) {
       const body = await parseRequestBody(req);
       const packingService = new PackingService();
       const rootDir = process.cwd();
-      const outputDir = path8__default.join(rootDir, "agents", "packed");
+      const outputDir = path9__default.join(rootDir, "agents", "packed");
       const result = await packingService.pack({
         agentName,
         rootDir,
@@ -20994,8 +21046,8 @@ async function handlePackingApiRequest(context) {
         res.end(JSON.stringify({ error: "Cannot delete npm packages. Use npm uninstall instead." }));
         return true;
       }
-      const fs18 = await import('fs');
-      fs18.rmSync(pkg.path, { recursive: true, force: true });
+      const fs19 = await import('fs');
+      fs19.rmSync(pkg.path, { recursive: true, force: true });
       await reloadAllAgentModules(context);
       res.statusCode = 200;
       res.setHeader("Content-Type", "application/json");
@@ -21023,8 +21075,8 @@ async function handlePackingApiRequest(context) {
         return true;
       }
       const { spawn } = await import('child_process');
-      const parentDir = path8__default.dirname(pkg.path);
-      const dirName = path8__default.basename(pkg.path);
+      const parentDir = path9__default.dirname(pkg.path);
+      const dirName = path9__default.basename(pkg.path);
       res.setHeader("Content-Type", "application/gzip");
       res.setHeader("Content-Disposition", `attachment; filename="${packageId}.tar.gz"`);
       const tar = spawn("tar", ["-czf", "-", "-C", parentDir, dirName]);
@@ -21078,18 +21130,19 @@ async function handlePackingApiRequest(context) {
   if (packPublishMatch && method === "POST") {
     try {
       const packageId = decodeURIComponent(packPublishMatch[1]);
+      assertSafePackageIdentifier(packageId);
       const body = await parseRequestBody(req);
       const rootDir = process.cwd();
-      const packedDir = path8__default.join(rootDir, "agents", "packed");
-      let packageDir = path8__default.join(packedDir, packageId);
-      if (!fs8__default.existsSync(packageDir)) {
-        if (!fs8__default.existsSync(packedDir)) {
+      const packedDir = path9__default.join(rootDir, "agents", "packed");
+      let packageDir = resolvePathWithin(packedDir, packageId);
+      if (!fs9__default.existsSync(packageDir)) {
+        if (!fs9__default.existsSync(packedDir)) {
           res.statusCode = 400;
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify({ error: "No packed packages found. Pack the agent first." }));
           return true;
         }
-        const dirs = fs8__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        const dirs = fs9__default.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
         const matchingDir = dirs.find(
           (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
         );
@@ -21101,14 +21154,14 @@ async function handlePackingApiRequest(context) {
           }));
           return true;
         }
-        packageDir = path8__default.join(packedDir, matchingDir);
+        packageDir = resolvePathWithin(packedDir, matchingDir);
       }
       let token = body.token || process.env.NPM_TOKEN;
       let tokenSource = body.token ? "provided" : "environment";
       if (!token) {
-        const devVarsPath = path8__default.join(rootDir, ".dev.vars");
-        if (fs8__default.existsSync(devVarsPath)) {
-          const devVars = fs8__default.readFileSync(devVarsPath, "utf-8");
+        const devVarsPath = path9__default.join(rootDir, ".dev.vars");
+        if (fs9__default.existsSync(devVarsPath)) {
+          const devVars = fs9__default.readFileSync(devVarsPath, "utf-8");
           const match = devVars.match(/^NPM_TOKEN=(.+)$/m);
           if (match) {
             token = match[1].trim();
@@ -21219,27 +21272,94 @@ async function handlePackingApiRequest(context) {
   return false;
 }
 
+// src/routing/access-policy.ts
+var PUBLIC_ROUTES = /* @__PURE__ */ new Set([
+  "/api/auth/bootstrap",
+  "/api/auth/login",
+  "/api/auth/config",
+  "/api/auth/brolly-control",
+  "/api/auth/platform-cleanup",
+  "/api/auth/platform-replica",
+  "/api/auth/sa/start",
+  "/api/auth/sa/callback",
+  "/api/config",
+  "/api/auth/oauth/github",
+  "/api/auth/oauth/google",
+  "/api/auth/oauth/github/callback",
+  "/api/auth/oauth/google/callback",
+  "/api/hooks"
+]);
+function isProviderIconRoute(routePath) {
+  return /^\/api\/providers\/[^/]+\/icon$/.test(routePath);
+}
+function isHostedInstance(env) {
+  const value = env?.STANDARD_AGENTS_HOSTED;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "0" && normalized !== "false";
+  }
+  return Boolean(value);
+}
+function isTrustedLocalDevelopmentRequest(request, env) {
+  if (isHostedInstance(env)) return false;
+  let hostname;
+  try {
+    hostname = new URL(request.url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local");
+}
+function isPublicApiRoute(routePath, request, env) {
+  if (PUBLIC_ROUTES.has(routePath)) return true;
+  if (routePath === "/api/auth/device/start" || routePath.startsWith("/api/auth/device/")) {
+    return true;
+  }
+  if (isProviderIconRoute(routePath)) {
+    return true;
+  }
+  if (!isTrustedLocalDevelopmentRequest(request, env)) return false;
+  return routePath === "/api/threads" || routePath.startsWith("/api/threads/") || routePath === "/api/platform" || routePath.startsWith("/api/platform/") || routePath === "/api/platform-session" || routePath.startsWith("/api/platform-session/") || routePath === "/api/platform-auth" || routePath.startsWith("/api/platform-auth/");
+}
+function isAdminOnlyApiRoute(routePath, method = "GET") {
+  if (routePath === "/api/skills" || routePath.startsWith("/api/skills/")) return true;
+  if (routePath === "/api/pack" || routePath.startsWith("/api/pack/")) return true;
+  if (routePath === "/api/unpack" || routePath.startsWith("/api/unpack/")) return true;
+  if (routePath === "/api/prompts" || routePath.startsWith("/api/prompts/")) return true;
+  if (routePath === "/api/tools" || routePath.startsWith("/api/tools/")) return true;
+  if (routePath === "/api/models" || routePath.startsWith("/api/models/")) return true;
+  if (routePath === "/api/providers") return true;
+  if (routePath.startsWith("/api/providers/")) {
+    return !isProviderIconRoute(routePath);
+  }
+  if (routePath.startsWith("/api/agents/")) {
+    return !/^\/api\/agents\/[^/]+\/tenvs$/.test(routePath);
+  }
+  if (routePath === "/api/agents" && method.toUpperCase() !== "GET") return true;
+  return false;
+}
+
 // src/plugin/dev-middleware.ts
 function readRawRequestBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
     req.on("end", () => {
-      resolve2(chunks.length > 0 ? Buffer.concat(chunks) : void 0);
+      resolve3(chunks.length > 0 ? Buffer.concat(chunks) : void 0);
     });
     req.on("error", reject);
   });
 }
 function resolveContainedFile(baseDir, requestPath) {
-  const resolvedBase = path8__default.resolve(baseDir);
-  const resolved = path8__default.resolve(resolvedBase, `.${path8__default.sep}${requestPath.replace(/^\/+/, "")}`);
-  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path8__default.sep)) {
+  const resolvedBase = path9__default.resolve(baseDir);
+  const resolved = path9__default.resolve(resolvedBase, `.${path9__default.sep}${requestPath.replace(/^\/+/, "")}`);
+  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path9__default.sep)) {
     return null;
   }
   try {
-    return fs8__default.existsSync(resolved) && fs8__default.statSync(resolved).isFile() ? resolved : null;
+    return fs9__default.existsSync(resolved) && fs9__default.statSync(resolved).isFile() ? resolved : null;
   } catch {
     return null;
   }
@@ -21289,6 +21409,21 @@ function createDevMiddleware(server, context) {
         return;
       }
     }
+    const routePath = new URL(pathWithoutMount, "http://localhost").pathname;
+    let trustedLocalHost = false;
+    try {
+      trustedLocalHost = isTrustedLocalDevelopmentRequest(
+        new Request(`http://${req.headers.host || "invalid.remote"}${routePath}`),
+        {}
+      );
+    } catch {
+    }
+    if (isAdminOnlyApiRoute(routePath, method) && !trustedLocalHost) {
+      res.statusCode = 403;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ error: "Authoring APIs are available only from local development hosts" }));
+      return;
+    }
     if (await handleConfigApiRequest({
       req,
       res,
@@ -21378,19 +21513,19 @@ function createDevMiddleware(server, context) {
     const clientPath = pathWithoutMount.startsWith("/agents/") ? pathWithoutMount.slice("/agents".length) || "/" : pathWithoutMount;
     const isStaticAsset = clientPath.startsWith("/assets/") || clientPath.startsWith("/vendor.js") || clientPath.startsWith("/vue.js") || clientPath.startsWith("/monaco.js") || clientPath.startsWith("/index.js") || clientPath.startsWith("/index.css") || clientPath.match(/\.(js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|ico)$/);
     {
-      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
+      const currentDir = path9__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const clientDir = path8__default.resolve(
+      const clientDir = path9__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
       let filePath;
       if (isStaticAsset) {
         const cleanUrl = clientPath.split("?")[0];
-        filePath = path8__default.join(clientDir, cleanUrl);
-        if (!fs8__default.existsSync(filePath)) {
+        filePath = path9__default.join(clientDir, cleanUrl);
+        if (!fs9__default.existsSync(filePath)) {
           const projectPublicFile = resolveContainedFile(
-            path8__default.resolve(server.config.root, "public"),
+            path9__default.resolve(server.config.root, "public"),
             cleanUrl
           );
           if (projectPublicFile) {
@@ -21398,12 +21533,12 @@ function createDevMiddleware(server, context) {
           }
         }
       } else {
-        filePath = path8__default.join(clientDir, "index.html");
+        filePath = path9__default.join(clientDir, "index.html");
       }
       try {
-        if (fs8__default.existsSync(filePath)) {
-          let content = fs8__default.readFileSync(filePath);
-          const ext = path8__default.extname(filePath).toLowerCase();
+        if (fs9__default.existsSync(filePath)) {
+          let content = fs9__default.readFileSync(filePath);
+          const ext = path9__default.extname(filePath).toLowerCase();
           if (ext === ".html") {
             content = Buffer.from(
               injectUiConfigIntoHtml(content.toString())
@@ -21443,7 +21578,7 @@ async function loadBuilderVirtualModule(context) {
   const effects = await scanEffectsDirectory(effectsDir);
   const toAbsolutePath = (relativePath) => {
     if (relativePath.startsWith("./")) {
-      return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+      return path9__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
     }
     return relativePath;
   };
@@ -21715,7 +21850,7 @@ async function loadRegistryVirtualModule(context) {
   const effects = await scanEffectsDirectory(effectsDir);
   const toAbsolutePath = (relativePath) => {
     if (relativePath.startsWith("./")) {
-      return path8__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+      return path9__default.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
     }
     return relativePath;
   };
@@ -21743,23 +21878,23 @@ async function loadRegistryVirtualModule(context) {
     const absPath = toAbsolutePath(importPath);
     return `    "${name}": async () => (await import("${absPath}")).default,`;
   }).join("\n");
-  const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
+  const packedDir = path9__default.resolve(process.cwd(), "agents/packed");
   const packedPackages = [];
-  if (fs8__default.existsSync(packedDir)) {
+  if (fs9__default.existsSync(packedDir)) {
     console.log(`[vite-plugin-agent] Scanning packed directory: ${packedDir}`);
     const packageDirs = discoverPackedPackageDirectories(packedDir);
     console.log(`[vite-plugin-agent] Found package dirs: ${packageDirs.join(", ")}`);
     for (const pkgPath of packageDirs) {
-      const pkgJsonPath = path8__default.join(pkgPath, "package.json");
-      if (fs8__default.existsSync(pkgJsonPath)) {
+      const pkgJsonPath = path9__default.join(pkgPath, "package.json");
+      if (fs9__default.existsSync(pkgJsonPath)) {
         try {
-          const pkgJson = JSON.parse(fs8__default.readFileSync(pkgJsonPath, "utf-8"));
+          const pkgJson = JSON.parse(fs9__default.readFileSync(pkgJsonPath, "utf-8"));
           console.log(`[vite-plugin-agent] Loaded ${pkgPath} package.json, standardagent:`, pkgJson.standardagent);
           if (!pkgJson.standardagent) {
             continue;
           }
           const mainEntry = pkgJson.main || "./dist/index.js";
-          const outputDir = path8__default.dirname(mainEntry).replace(/^\.\//, "");
+          const outputDir = path9__default.dirname(mainEntry).replace(/^\.\//, "");
           const pkg = {
             packageId: pkgJson.name,
             version: pkgJson.version,
@@ -21877,7 +22012,7 @@ export function getVisibleToolNames() {
 async function loadRoutesVirtualModule(context) {
   const { threadApiDir, rou3Code, hmr } = context;
   const threadRoutes = scanApiDirectory(threadApiDir);
-  const toAbsolutePath = (inputPath) => path8__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
+  const toAbsolutePath = (inputPath) => path9__default.resolve(process.cwd(), inputPath).replace(/\\/g, "/");
   const threadRouteCode = threadRoutes.map(({ method, route, importPath }) => {
     const apiRoute = `/api/threads/:threadId${route}`;
     return `  addRoute(
@@ -21888,20 +22023,20 @@ async function loadRoutesVirtualModule(context) {
   );`;
   }).join("\n");
   const packedThreadRoutes = [];
-  const packedDir = path8__default.resolve(process.cwd(), "agents/packed");
+  const packedDir = path9__default.resolve(process.cwd(), "agents/packed");
   const packedPackageDirs = discoverPackedPackageDirectories(packedDir);
   for (const packagePath of packedPackageDirs) {
-    const packageJsonPath = path8__default.join(packagePath, "package.json");
-    if (!fs8__default.existsSync(packageJsonPath)) {
+    const packageJsonPath = path9__default.join(packagePath, "package.json");
+    if (!fs9__default.existsSync(packageJsonPath)) {
       continue;
     }
     try {
-      const packageJson = JSON.parse(fs8__default.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs9__default.readFileSync(packageJsonPath, "utf-8"));
       if (!packageJson.standardagent) {
         continue;
       }
       const mainEntry = packageJson.main || "./dist/index.js";
-      const outputDir = path8__default.dirname(mainEntry).replace(/^\.\//, "");
+      const outputDir = path9__default.dirname(mainEntry).replace(/^\.\//, "");
       const threadEndpoints = scanPackedThreadEndpoints(packagePath, outputDir);
       for (const endpoint of threadEndpoints) {
         const apiRoute = `/api/threads/:threadId${endpoint.route}`;
@@ -21935,98 +22070,16 @@ import { providers, providerNames, providerFactories } from "virtual:@standardag
 import { prompts, promptNames } from "virtual:@standardagents-prompts";
 import { agents, agentNames } from "virtual:@standardagents-agents";
 import { registry } from "virtual:@standardagents-registry";
-import { requireAuth, createThreadEndpointHandler } from "@standardagents/builder/runtime";
+import {
+  requireAuth,
+  createThreadEndpointHandler,
+  canAccessThread,
+  isHostedInstance,
+  isPublicApiRoute,
+  isAdminOnlyApiRoute,
+} from "@standardagents/builder/runtime";
 import { isThreadEndpoint } from "@standardagents/spec";
 
-// Routes that don't require authentication
-const PUBLIC_ROUTES = [
-  '/api/auth/bootstrap',
-  '/api/auth/login',
-  '/api/auth/config',
-  '/api/auth/brolly-control',
-  '/api/auth/platform-cleanup',
-  '/api/auth/platform-replica',
-  '/api/auth/sa/start',     // Login with Standard Agents (OAuth) \u2014 unauthenticated entry
-  '/api/auth/sa/callback',  // OAuth callback (sets the session cookie)
-  '/api/config',
-  '/api/auth/oauth/github',
-  '/api/auth/oauth/google',
-  '/api/auth/oauth/github/callback',
-  '/api/auth/oauth/google/callback',
-  '/api/platform-auth/bootstrap',
-  '/api/platform-auth/login',
-  '/api/platform-auth/logout',
-  '/api/platform-auth/me',
-  '/api/hooks'  // Hook metadata is safe to expose publicly
-];
-
-// True when the platform deployed this instance (injects STANDARD_AGENTS_HOSTED).
-// Hosted instances are internet-reachable and multi-tenant, so the thread data
-// API and event/stream WebSockets must NOT be anonymously public the way they
-// are in single-user local dev \u2014 they require a session (admin) or API key (SDK).
-function isHostedInstance(env) {
-  const value = env && env.STANDARD_AGENTS_HOSTED;
-  if (typeof value === 'string') {
-    const trimmed = value.trim().toLowerCase();
-    return trimmed !== '' && trimmed !== '0' && trimmed !== 'false';
-  }
-  return Boolean(value);
-}
-
-// Check if a route is public (no auth required)
-function isPublicRoute(routePath, hosted) {
-  // Exact match for auth routes
-  if (PUBLIC_ROUTES.includes(routePath)) {
-    return true;
-  }
-
-  // Thread routes (REST + message/log stream WebSockets) are public in local
-  // single-user dev, but on a hosted deployment they require auth \u2014 requireAuth
-  // accepts the admin's session (cookie or token) or the SDK's API key, so this
-  // only blocks anonymous access to another tenant's threads/messages/files.
-  if (!hosted && (routePath.startsWith('/api/threads/') || routePath === '/api/threads')) {
-    return true;
-  }
-
-  // Device-code CLI login: start/poll are public by design (possession of the
-  // one-time code is the secret) and the approve page must reach its controller
-  // even when anonymous so it can redirect the browser through the platform
-  // login (the controller enforces session auth itself).
-  if (routePath === '/api/auth/device/start' || routePath.startsWith('/api/auth/device/')) {
-    return true;
-  }
-
-  // Provider icon routes are public (used by <img src>)
-  if (routePath.startsWith('/api/providers/') && routePath.includes('/icon')) {
-    return true;
-  }
-
-  // Platform proxy routes handle their own auth in local dev only.
-  if (hosted && (routePath.startsWith('/api/platform/') || routePath === '/api/platform')) {
-    return false;
-  }
-  if (routePath.startsWith('/api/platform/') || routePath === '/api/platform') {
-    return true;
-  }
-
-  // Platform session proxy and auth bridge are local-dev helpers only.
-  if (hosted && (routePath.startsWith('/api/platform-session/') || routePath === '/api/platform-session')) {
-    return false;
-  }
-  if (routePath.startsWith('/api/platform-session/') || routePath === '/api/platform-session') {
-    return true;
-  }
-
-  if (hosted && (routePath.startsWith('/api/platform-auth/') || routePath === '/api/platform-auth')) {
-    return false;
-  }
-  if (routePath.startsWith('/api/platform-auth/') || routePath === '/api/platform-auth') {
-    return true;
-  }
-
-  return false;
-}
-
 function platformEndpoint(env) {
   const configured =
     env && (env.PLATFORM_ENDPOINT || env.STANDARD_AGENTS_PLATFORM_URL || env.PLATFORM_URL || env.STANDARD_AGENTS_PUBLIC_URL);
@@ -22169,7 +22222,7 @@ ${packedThreadRouteCode}
 
   if (routeMatch) {
     // Check if authentication is required for this route
-    const publicRoute = isPublicRoute(routePath, isHostedInstance(env));
+    const publicRoute = isPublicApiRoute(routePath, request, env);
     const isApiRoute = routePath.startsWith('/api/');
 
     let authContext = null;
@@ -22185,6 +22238,10 @@ ${packedThreadRouteCode}
 
       authContext = authResult;
 
+      if (isAdminOnlyApiRoute(routePath, request.method) && authContext.user.role !== 'admin') {
+        return addCorsHeaders(Response.json({ error: 'Forbidden: Admin access required' }, { status: 403 }));
+      }
+
       if (routePath.startsWith('/api/threads/')) {
         // Packed and user thread endpoints reserve threadId for the owning
         // thread while nested endpoint parameters may also be named id.
@@ -22198,7 +22255,7 @@ ${packedThreadRouteCode}
           if (!thread) {
             return addCorsHeaders(Response.json({ error: \`Thread not found: \${threadId}\` }, { status: 404 }));
           }
-          if (authContext.user.role !== 'admin' && (thread.user_id === null || thread.user_id !== authContext.user.id)) {
+          if (!canAccessThread(authContext, thread)) {
             return addCorsHeaders(Response.json({ error: "Forbidden: You don't have access to this thread" }, { status: 403 }));
           }
         }
@@ -22374,13 +22431,13 @@ ${hooksCode}
 };`;
   }
   if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
-    const relativeToolsDir = path8__default.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
-    const relativeHooksDir = path8__default.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
-    const relativeApiDir = path8__default.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
-    const relativeModelsDir = path8__default.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
-    const relativeProvidersDir = path8__default.relative(process.cwd(), providersDir).replace(/\\/g, "/");
-    const relativePromptsDir = path8__default.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
-    const relativeAgentsDir = path8__default.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
+    const relativeToolsDir = path9__default.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
+    const relativeHooksDir = path9__default.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
+    const relativeApiDir = path9__default.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
+    const relativeModelsDir = path9__default.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
+    const relativeProvidersDir = path9__default.relative(process.cwd(), providersDir).replace(/\\/g, "/");
+    const relativePromptsDir = path9__default.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
+    const relativeAgentsDir = path9__default.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
     return `// Virtual agent config module
 export const config = {
   toolsDir: "${relativeToolsDir}",
@@ -22597,14 +22654,14 @@ var packingDeps = [
   "typescript"
 ];
 function createPluginViteConfig(pluginModuleUrl) {
-  const currentDir = path8__default.dirname(fileURLToPath(pluginModuleUrl));
+  const currentDir = path9__default.dirname(fileURLToPath(pluginModuleUrl));
   const isInDist = currentDir.endsWith("dist");
-  const builderClientDir = path8__default.resolve(
+  const builderClientDir = path9__default.resolve(
     currentDir,
     isInDist ? "./client" : "../dist/client"
   );
   return {
-    publicDir: fs8__default.existsSync(builderClientDir) ? builderClientDir : void 0,
+    publicDir: fs9__default.existsSync(builderClientDir) ? builderClientDir : void 0,
     build: {
       rollupOptions: {
         external: [...packingDeps]
@@ -22751,24 +22808,24 @@ function applyPluginEnvironmentConfig(config) {
 
 // src/plugin.ts
 function agentbuilder(options = {}) {
-  const toolsDir = options.toolsDir ? path8__default.resolve(process.cwd(), options.toolsDir) : path8__default.resolve(process.cwd(), "agents/tools");
-  const hooksDir = options.hooksDir ? path8__default.resolve(process.cwd(), options.hooksDir) : path8__default.resolve(process.cwd(), "agents/hooks");
-  const threadApiDir = options.apiDir ? path8__default.resolve(process.cwd(), options.apiDir) : path8__default.resolve(process.cwd(), "agents/api");
-  const modelsDir = options.modelsDir ? path8__default.resolve(process.cwd(), options.modelsDir) : path8__default.resolve(process.cwd(), "agents/models");
-  const providersDir = options.providersDir ? path8__default.resolve(process.cwd(), options.providersDir) : path8__default.resolve(process.cwd(), "agents/providers");
-  const promptsDir = options.promptsDir ? path8__default.resolve(process.cwd(), options.promptsDir) : path8__default.resolve(process.cwd(), "agents/prompts");
-  const agentsDir = options.agentsDir ? path8__default.resolve(process.cwd(), options.agentsDir) : path8__default.resolve(process.cwd(), "agents/agents");
-  const effectsDir = options.effectsDir ? path8__default.resolve(process.cwd(), options.effectsDir) : path8__default.resolve(process.cwd(), "agents/effects");
-  const usersDir = options.usersDir ? path8__default.resolve(process.cwd(), options.usersDir) : path8__default.resolve(process.cwd(), "agents/users");
-  const outputDir = path8__default.resolve(process.cwd(), ".agents");
-  const generatedWorkerEntry = path8__default.join(outputDir, "worker.ts");
+  const toolsDir = options.toolsDir ? path9__default.resolve(process.cwd(), options.toolsDir) : path9__default.resolve(process.cwd(), "agents/tools");
+  const hooksDir = options.hooksDir ? path9__default.resolve(process.cwd(), options.hooksDir) : path9__default.resolve(process.cwd(), "agents/hooks");
+  const threadApiDir = options.apiDir ? path9__default.resolve(process.cwd(), options.apiDir) : path9__default.resolve(process.cwd(), "agents/api");
+  const modelsDir = options.modelsDir ? path9__default.resolve(process.cwd(), options.modelsDir) : path9__default.resolve(process.cwd(), "agents/models");
+  const providersDir = options.providersDir ? path9__default.resolve(process.cwd(), options.providersDir) : path9__default.resolve(process.cwd(), "agents/providers");
+  const promptsDir = options.promptsDir ? path9__default.resolve(process.cwd(), options.promptsDir) : path9__default.resolve(process.cwd(), "agents/prompts");
+  const agentsDir = options.agentsDir ? path9__default.resolve(process.cwd(), options.agentsDir) : path9__default.resolve(process.cwd(), "agents/agents");
+  const effectsDir = options.effectsDir ? path9__default.resolve(process.cwd(), options.effectsDir) : path9__default.resolve(process.cwd(), "agents/effects");
+  const usersDir = options.usersDir ? path9__default.resolve(process.cwd(), options.usersDir) : path9__default.resolve(process.cwd(), "agents/users");
+  const outputDir = path9__default.resolve(process.cwd(), ".agents");
+  const generatedWorkerEntry = path9__default.join(outputDir, "worker.ts");
   const isProviderPackageInstalled = (packageName) => {
     let dir = process.cwd();
     for (; ; ) {
-      if (fs8__default.existsSync(path8__default.join(dir, "node_modules", packageName, "package.json"))) {
+      if (fs9__default.existsSync(path9__default.join(dir, "node_modules", packageName, "package.json"))) {
         return true;
       }
-      const parent = path8__default.dirname(dir);
+      const parent = path9__default.dirname(dir);
       if (parent === dir) return false;
       dir = parent;
     }
@@ -22803,17 +22860,17 @@ export default {
 
 export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog, DurableUserHub };
 `;
-    fs8__default.mkdirSync(outputDir, { recursive: true });
-    if (!fs8__default.existsSync(generatedWorkerEntry) || fs8__default.readFileSync(generatedWorkerEntry, "utf-8") !== content) {
-      fs8__default.writeFileSync(generatedWorkerEntry, content);
+    fs9__default.mkdirSync(outputDir, { recursive: true });
+    if (!fs9__default.existsSync(generatedWorkerEntry) || fs9__default.readFileSync(generatedWorkerEntry, "utf-8") !== content) {
+      fs9__default.writeFileSync(generatedWorkerEntry, content);
     }
   }
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path8__default.dirname(__filename);
-  const rou3Path = path8__default.join(__dirname, "../dist/rou3.js");
+  const __dirname = path9__default.dirname(__filename);
+  const rou3Path = path9__default.join(__dirname, "../dist/rou3.js");
   let rou3Code = "";
   try {
-    rou3Code = fs8__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
+    rou3Code = fs9__default.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
   } catch (err) {
     console.warn("[vite-plugin-agent] Could not read rou3.js for inlining:", err);
   }
@@ -22856,7 +22913,7 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     sourceDirs,
     regenerateTypes
   };
-  const workerEntry = path8__default.relative(process.cwd(), generatedWorkerEntry).split(path8__default.sep).join("/");
+  const workerEntry = path9__default.relative(process.cwd(), generatedWorkerEntry).split(path9__default.sep).join("/");
   const corePlugin = {
     name: "vite-plugin-agent",
     enforce: "pre",
@@ -22931,28 +22988,28 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     },
     writeBundle(options2, bundle) {
       const outDir = options2.dir || "dist";
-      const mountDir = path8__default.join(outDir, "../client");
-      const currentDir = path8__default.dirname(fileURLToPath(import.meta.url));
+      const mountDir = path9__default.join(outDir, "../client");
+      const currentDir = path9__default.dirname(fileURLToPath(import.meta.url));
       const isInDist = currentDir.endsWith("dist");
-      const clientDir = path8__default.resolve(
+      const clientDir = path9__default.resolve(
         currentDir,
         isInDist ? "./client" : "../dist/client"
       );
-      if (!fs8__default.existsSync(clientDir)) {
+      if (!fs9__default.existsSync(clientDir)) {
         console.warn(`[agentbuilder] Client directory not found at ${clientDir}`);
         return;
       }
-      fs8__default.mkdirSync(mountDir, { recursive: true });
+      fs9__default.mkdirSync(mountDir, { recursive: true });
       function copyRecursive(src, dest) {
-        const entries = fs8__default.readdirSync(src, { withFileTypes: true });
+        const entries = fs9__default.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const srcPath = path8__default.join(src, entry.name);
-          const destPath = path8__default.join(dest, entry.name);
+          const srcPath = path9__default.join(src, entry.name);
+          const destPath = path9__default.join(dest, entry.name);
           if (entry.isDirectory()) {
-            fs8__default.mkdirSync(destPath, { recursive: true });
+            fs9__default.mkdirSync(destPath, { recursive: true });
             copyRecursive(srcPath, destPath);
           } else {
-            let content = fs8__default.readFileSync(srcPath);
+            let content = fs9__default.readFileSync(srcPath);
             if (entry.name === "index.html") {
               const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = {};</script>`;
               let htmlContent = content.toString();
@@ -22960,27 +23017,27 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
               htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
               content = Buffer.from(htmlContent);
             }
-            fs8__default.writeFileSync(destPath, content);
+            fs9__default.writeFileSync(destPath, content);
           }
         }
       }
       copyRecursive(clientDir, mountDir);
-      const projectPublicDir = path8__default.resolve(process.cwd(), "public");
-      if (fs8__default.existsSync(projectPublicDir)) {
+      const projectPublicDir = path9__default.resolve(process.cwd(), "public");
+      if (fs9__default.existsSync(projectPublicDir)) {
         let copyPublicRecursive2 = function(src, dest) {
-          const entries = fs8__default.readdirSync(src, { withFileTypes: true });
+          const entries = fs9__default.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const srcPath = path8__default.join(src, entry.name);
-            const destPath = path8__default.join(dest, entry.name);
+            const srcPath = path9__default.join(src, entry.name);
+            const destPath = path9__default.join(dest, entry.name);
             if (entry.isDirectory()) {
-              fs8__default.mkdirSync(destPath, { recursive: true });
+              fs9__default.mkdirSync(destPath, { recursive: true });
               copyPublicRecursive2(srcPath, destPath);
-            } else if (fs8__default.existsSync(destPath)) {
+            } else if (fs9__default.existsSync(destPath)) {
               console.warn(
                 `[agentbuilder] Skipping public/ file that collides with a built UI asset: ${destPath}`
               );
             } else {
-              fs8__default.copyFileSync(srcPath, destPath);
+              fs9__default.copyFileSync(srcPath, destPath);
             }
           }
         };
@@ -23273,6 +23330,17 @@ async function requireAdmin(request, env) {
   return result;
 }
 
+// src/utils/permissions.ts
+function canAccessThread(auth, thread) {
+  if (auth.user.role === "admin") {
+    return true;
+  }
+  if (thread.user_id === null) {
+    return false;
+  }
+  return thread.user_id === auth.user.id;
+}
+
 // src/index.ts
 init_client_forwarding();
 
@@ -24953,6 +25021,18 @@ function messageTimestampSeconds(message) {
   return Math.floor(micros / (1e3 * TIMESTAMP_MULTIPLIER));
 }
 
+// src/events/access.ts
+var EVENT_STREAM_USER_ID_HEADER = "X-Standard-Agents-Event-User-Id";
+var EVENT_STREAM_SCOPE_HEADER = "X-Standard-Agents-Event-Scope";
+function isEventSocketAttachment(value) {
+  if (!value || typeof value !== "object") return false;
+  const attachment = value;
+  return attachment.channel === "events" && (attachment.scope === "user" || attachment.scope === "all") && typeof attachment.userId === "string" && attachment.userId.length > 0;
+}
+function eventSocketCanReceive(attachment, ownerUserId) {
+  return attachment.scope === "all" || ownerUserId !== null && attachment.userId === ownerUserId;
+}
+
 // src/durable-objects/agentbuilder-migrations/0001_initial.ts
 var migration36 = {
   version: 1,
@@ -25981,8 +26061,13 @@ var DurableAgentBuilder = class extends DurableObject {
     const sockets = ctx.getWebSockets();
     for (const ws of sockets) {
       const attachment = ws.deserializeAttachment();
-      if (attachment?.channel === "events") {
+      if (isEventSocketAttachment(attachment)) {
         this.eventSockets.add(ws);
+      } else if (attachment?.channel === "events") {
+        try {
+          ws.close(1012, "Reconnect to establish an authenticated event scope");
+        } catch {
+        }
       }
     }
   }
@@ -26252,10 +26337,10 @@ var DurableAgentBuilder = class extends DurableObject {
     for (const entry of value) {
       if (!entry || typeof entry !== "object") continue;
       const attachment = entry;
-      const path20 = typeof attachment.path === "string" ? attachment.path.trim() : "";
-      if (!path20) continue;
+      const path21 = typeof attachment.path === "string" ? attachment.path.trim() : "";
+      if (!path21) continue;
       output.push({
-        path: path20,
+        path: path21,
         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,
@@ -26272,8 +26357,8 @@ var DurableAgentBuilder = class extends DurableObject {
     const trimmed = sanitized.replace(/^[-.]+|[-.]+$/g, "");
     return trimmed || "attachment";
   }
-  inferMimeTypeFromPath(path20) {
-    const normalized = path20.toLowerCase();
+  inferMimeTypeFromPath(path21) {
+    const normalized = path21.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";
@@ -26311,7 +26396,7 @@ var DurableAgentBuilder = class extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path20) => typeof path20 === "string" && path20.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path21) => typeof path21 === "string" && path21.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -26611,7 +26696,10 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
       executing: false
     };
     const eventThread = await this.toThreadEventPayload(thread);
-    this.broadcastEvent({ type: "thread_created", thread: eventThread });
+    this.broadcastEvent(
+      { type: "thread_created", thread: eventThread },
+      thread.user_id
+    );
     await this.runAfterThreadCreatedHook(thread);
     return thread;
   }
@@ -26914,14 +27002,20 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
         stampedMessageAt = stampAt;
       }
     }
-    this.broadcastEvent({
-      type: "thread_activity",
-      threadId,
-      ...activityAt !== void 0 ? { last_activity_at: activityAt } : {},
-      ...executing !== void 0 ? { executing } : {},
-      ...preview != null ? { last_message_preview: preview } : {},
-      ...stampedMessageAt !== void 0 ? { last_message_at: stampedMessageAt } : {}
-    });
+    const ownerUserId = await this.getThreadOwnerId(threadId);
+    if (ownerUserId !== void 0) {
+      this.broadcastEvent(
+        {
+          type: "thread_activity",
+          threadId,
+          ...activityAt !== void 0 ? { last_activity_at: activityAt } : {},
+          ...executing !== void 0 ? { executing } : {},
+          ...preview != null ? { last_message_preview: preview } : {},
+          ...stampedMessageAt !== void 0 ? { last_message_at: stampedMessageAt } : {}
+        },
+        ownerUserId
+      );
+    }
   }
   /**
    * Fill in previews for threads that predate preview tracking. Callers read
@@ -26948,8 +27042,14 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
    */
   async deleteThread(id) {
     await this.ensureMigrated();
+    const ownerUserId = await this.getThreadOwnerId(id);
     await this.ctx.storage.sql.exec(`DELETE FROM threads WHERE id = ?`, id);
-    this.broadcastEvent({ type: "thread_deleted", threadId: id });
+    if (ownerUserId !== void 0) {
+      this.broadcastEvent(
+        { type: "thread_deleted", threadId: id },
+        ownerUserId
+      );
+    }
     return true;
   }
   /**
@@ -27011,7 +27111,10 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
       const updated = await this.getThread(id);
       if (updated) {
         const eventThread = await this.toThreadEventPayload(updated);
-        this.broadcastEvent({ type: "thread_updated", thread: eventThread });
+        this.broadcastEvent(
+          { type: "thread_updated", thread: eventThread },
+          updated.user_id
+        );
       }
     } catch {
     }
@@ -27091,7 +27194,10 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     const updated = await this.getThread(id);
     if (updated) {
       const eventThread = await this.toThreadEventPayload(updated);
-      this.broadcastEvent({ type: "thread_updated", thread: eventThread });
+      this.broadcastEvent(
+        { type: "thread_updated", thread: eventThread },
+        updated.user_id
+      );
     }
     return updated;
   }
@@ -27796,7 +27902,18 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
   }
   async toThreadEventPayload(thread) {
     const eventThread = {
-      ...thread
+      id: thread.id,
+      agent_name: thread.agent_name,
+      origin_agent_name: thread.origin_agent_name,
+      user_id: thread.user_id,
+      tags: thread.tags,
+      parent: thread.parent,
+      terminated: thread.terminated,
+      created_at: thread.created_at,
+      last_activity_at: thread.last_activity_at,
+      executing: thread.executing,
+      last_message_preview: thread.last_message_preview,
+      last_message_at: thread.last_message_at
     };
     try {
       const agentDef = await this.loadAgent(thread.agent_name);
@@ -28663,10 +28780,21 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
    * Uses Hibernation API to reduce costs during inactivity
    */
   async handleEventsWebSocketUpgrade(request) {
+    const attachment = {
+      channel: "events",
+      scope: request.headers.get(EVENT_STREAM_SCOPE_HEADER) === "all" ? "all" : "user",
+      userId: request.headers.get(EVENT_STREAM_USER_ID_HEADER) ?? ""
+    };
+    if (!isEventSocketAttachment(attachment)) {
+      return Response.json(
+        { error: "Missing authenticated event subscription" },
+        { status: 401 }
+      );
+    }
     const pair = new WebSocketPair();
     const [client, server] = Object.values(pair);
     this.ctx.acceptWebSocket(server);
-    server.serializeAttachment({ channel: "events" });
+    server.serializeAttachment(attachment);
     this.eventSockets.add(server);
     return new Response(null, {
       status: 101,
@@ -28687,17 +28815,23 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     const thread = await this.getThread(threadId);
     if (!thread) return;
     const eventThread = await this.toThreadEventPayload(thread);
-    this.broadcastEvent({ type: "thread_updated", thread: eventThread });
+    this.broadcastEvent(
+      { type: "thread_updated", thread: eventThread },
+      thread.user_id
+    );
   }
   /**
-   * Broadcast an event to all connected WebSocket clients
+   * Broadcast an event only to its owner or an explicitly all-scoped admin.
    */
-  broadcastEvent(event) {
+  broadcastEvent(event, ownerUserId) {
     const payload = JSON.stringify(event);
     for (const ws of Array.from(this.eventSockets)) {
       try {
         if (ws.readyState === WebSocket.OPEN) {
-          ws.send(payload);
+          const attachment = ws.deserializeAttachment();
+          if (isEventSocketAttachment(attachment) && eventSocketCanReceive(attachment, ownerUserId)) {
+            ws.send(payload);
+          }
         } else {
           this.eventSockets.delete(ws);
         }
@@ -28706,6 +28840,15 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
       }
     }
   }
+  /** Resolve a thread owner without decrypting its env or loading the row. */
+  async getThreadOwnerId(threadId) {
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT user_id FROM threads WHERE id = ? LIMIT 1`,
+      threadId
+    );
+    const rows = cursor.toArray();
+    return rows[0]?.user_id;
+  }
   /**
    * WebSocket Hibernation API handler for incoming messages
    * Called when a message is received on a hibernated WebSocket
@@ -28774,12 +28917,12 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     return all.find((s) => s.name === name) ?? null;
   }
   /** One bundled file's text (null when the skill or file is missing). */
-  async getSkillFile(name, path20) {
+  async getSkillFile(name, path21) {
     await this.ensureMigrated();
     const cursor = await this.ctx.storage.sql.exec(
       `SELECT content FROM skill_files WHERE skill_name = ? AND path = ?`,
       name,
-      path20.replace(/^\.\//, "")
+      path21.replace(/^\.\//, "")
     );
     const rows = cursor.toArray();
     return rows.length ? rows[0].content : null;
@@ -29002,12 +29145,12 @@ init_code_execution();
 var DEFAULT_CLIENT_TOOL_TIMEOUT_MS = 5 * 60 * 1e3;
 var BRIDGE_LIVENESS_TIMEOUT_MS = 20 * 1e3;
 var RUNTIME_STORAGE_PREFIX = "__agentbuilder_runtime_storage__:";
-function normalizeEndpointThreadPath(path20) {
-  if (!path20 || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path20)) {
+function normalizeEndpointThreadPath(path21) {
+  if (!path21 || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path21)) {
     throw new Error("Use a relative thread filesystem path");
   }
   const parts = [];
-  for (const part of path20.replace(/\\/g, "/").split("/")) {
+  for (const part of path21.replace(/\\/g, "/").split("/")) {
     if (!part || part === ".") continue;
     if (part === "..") {
       if (parts.length === 0) throw new Error("Path cannot escape the thread filesystem root");
@@ -29057,12 +29200,12 @@ function createEndpointFetchBridge() {
 function createEndpointFsBridge(state) {
   const decoder = new TextDecoder();
   return {
-    readFile: async (path20) => {
-      const data = await state.readFile(normalizeEndpointThreadPath(path20));
+    readFile: async (path21) => {
+      const data = await state.readFile(normalizeEndpointThreadPath(path21));
       return data ? decoder.decode(data) : null;
     },
-    writeFile: async (path20, content, mimeType = "text/plain") => {
-      return state.writeFile(normalizeEndpointThreadPath(path20), content, mimeType);
+    writeFile: async (path21, content, mimeType = "text/plain") => {
+      return state.writeFile(normalizeEndpointThreadPath(path21), content, mimeType);
     }
   };
 }
@@ -29131,24 +29274,24 @@ function createEndpointThreadStateBridge(state) {
     emit: (event, data) => state.emit(event, data),
     getValue: (key) => state.getValue(key),
     setValue: (key, value) => state.setValue(key, value),
-    readFile: (path20) => state.readFile(normalizeEndpointThreadPath(path20)),
-    writeFile: (path20, data, mimeType = "application/octet-stream", options) => {
-      return state.writeFile(normalizeEndpointThreadPath(path20), data, mimeType, options);
+    readFile: (path21) => state.readFile(normalizeEndpointThreadPath(path21)),
+    writeFile: (path21, data, mimeType = "application/octet-stream", options) => {
+      return state.writeFile(normalizeEndpointThreadPath(path21), data, mimeType, options);
     },
-    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)),
+    statFile: (path21) => state.statFile(normalizeEndpointThreadPath(path21)),
+    readdirFile: (path21) => state.readdirFile(normalizeEndpointThreadPath(path21)),
+    unlinkFile: (path21) => state.unlinkFile(normalizeEndpointThreadPath(path21)),
+    mkdirFile: (path21) => state.mkdirFile(normalizeEndpointThreadPath(path21)),
+    rmdirFile: (path21) => state.rmdirFile(normalizeEndpointThreadPath(path21)),
     moveFile: (sourcePath, destinationPath) => state.moveFile(
       normalizeEndpointThreadPath(sourcePath),
       normalizeEndpointThreadPath(destinationPath)
     ),
-    renameFile: (path20, newName) => state.renameFile(normalizeEndpointThreadPath(path20), newName),
+    renameFile: (path21, newName) => state.renameFile(normalizeEndpointThreadPath(path21), newName),
     getFileStats: () => state.getFileStats(),
     grepFiles: (pattern) => state.grepFiles(pattern),
     findFiles: (pattern) => state.findFiles(pattern),
-    getFileThumbnail: (path20) => state.getFileThumbnail(normalizeEndpointThreadPath(path20))
+    getFileThumbnail: (path21) => state.getFileThumbnail(normalizeEndpointThreadPath(path21))
   };
 }
 var DurableThread = class _DurableThread extends DurableObject {
@@ -29849,7 +29992,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     this.assertJsonSerializableThreadValue(value, "$", /* @__PURE__ */ new WeakSet());
     return JSON.stringify(value);
   }
-  assertJsonSerializableThreadValue(value, path20, seen) {
+  assertJsonSerializableThreadValue(value, path21, seen) {
     if (value === null) {
       return;
     }
@@ -29859,36 +30002,36 @@ var DurableThread = class _DurableThread extends DurableObject {
         return;
       case "number":
         if (!Number.isFinite(value)) {
-          throw new Error(`Thread value at ${path20} must be a finite number`);
+          throw new Error(`Thread value at ${path21} must be a finite number`);
         }
         return;
       case "object": {
         if (seen.has(value)) {
-          throw new Error(`Thread value at ${path20} cannot contain circular references`);
+          throw new Error(`Thread value at ${path21} cannot contain circular references`);
         }
         seen.add(value);
         if (Array.isArray(value)) {
           for (let i = 0; i < value.length; i += 1) {
-            this.assertJsonSerializableThreadValue(value[i], `${path20}[${i}]`, seen);
+            this.assertJsonSerializableThreadValue(value[i], `${path21}[${i}]`, seen);
           }
           seen.delete(value);
           return;
         }
         const prototype = Object.getPrototypeOf(value);
         if (prototype !== Object.prototype && prototype !== null) {
-          throw new Error(`Thread value at ${path20} must be a JSON object, array, or primitive`);
+          throw new Error(`Thread value at ${path21} must be a JSON object, array, or primitive`);
         }
         if (Object.getOwnPropertySymbols(value).length > 0) {
-          throw new Error(`Thread value at ${path20} cannot contain symbol keys`);
+          throw new Error(`Thread value at ${path21} cannot contain symbol keys`);
         }
         for (const [entryKey, entryValue] of Object.entries(value)) {
-          this.assertJsonSerializableThreadValue(entryValue, `${path20}.${entryKey}`, seen);
+          this.assertJsonSerializableThreadValue(entryValue, `${path21}.${entryKey}`, seen);
         }
         seen.delete(value);
         return;
       }
       default:
-        throw new Error(`Thread value at ${path20} must be JSON-serializable`);
+        throw new Error(`Thread value at ${path21} must be JSON-serializable`);
     }
   }
   // ============================================================
@@ -31053,8 +31196,8 @@ var DurableThread = class _DurableThread extends DurableObject {
     );
     return terminalCursor.toArray()[0] ?? null;
   }
-  inferMimeTypeFromPath(path20) {
-    const normalized = path20.toLowerCase();
+  inferMimeTypeFromPath(path21) {
+    const normalized = path21.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";
@@ -31093,7 +31236,7 @@ var DurableThread = class _DurableThread extends DurableObject {
       ext: value.slice(lastDot + 1).toLowerCase()
     };
   }
-  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path20) {
+  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path21) {
     const source = sourceMimeType?.trim();
     if (source && source !== "application/octet-stream") {
       return source;
@@ -31102,7 +31245,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (fallback && fallback !== "application/octet-stream") {
       return fallback;
     }
-    return this.inferMimeTypeFromPath(path20) ?? source ?? fallback ?? "application/octet-stream";
+    return this.inferMimeTypeFromPath(path21) ?? source ?? fallback ?? "application/octet-stream";
   }
   buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
     const safeName = this.sanitizeFilename(preferredName);
@@ -31197,8 +31340,8 @@ var DurableThread = class _DurableThread extends DurableObject {
     }
     return copied;
   }
-  async readAttachmentDataFromSource(path20, sourceFile) {
-    const sourceData = await this.readFile(path20);
+  async readAttachmentDataFromSource(path21, sourceFile) {
+    const sourceData = await this.readFile(path21);
     if (sourceData.success && sourceData.data) {
       return sourceData.data;
     }
@@ -31232,7 +31375,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path20) => typeof path20 === "string" && path20.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path21) => typeof path21 === "string" && path21.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -32967,7 +33110,7 @@ ${resultContent}${attachmentSummary}`;
     const id = durability?.toolCallId ?? crypto.randomUUID();
     const timeoutMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : DEFAULT_CLIENT_TOOL_TIMEOUT_MS;
     this.bridgeLastSeen.set(socket, Date.now());
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const timer = setTimeout(() => {
         this.markBridgeDead(socket);
         this.settleClientCall(id, {
@@ -32987,7 +33130,7 @@ ${resultContent}${attachmentSummary}`;
           });
         }
       }, 5e3);
-      this.pendingClientCalls.set(id, { resolve: resolve2, timer, liveness, socket });
+      this.pendingClientCalls.set(id, { resolve: resolve3, timer, liveness, socket });
       const frame = JSON.stringify({
         type: "tool_request",
         id,
@@ -33365,7 +33508,7 @@ ${resultContent}${attachmentSummary}`;
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
       await new Promise(
-        (resolve2) => setTimeout(resolve2, _DurableThread.OWNER_REATTACH_POLL_MS)
+        (resolve3) => setTimeout(resolve3, _DurableThread.OWNER_REATTACH_POLL_MS)
       );
       const owner = await this.getExecutionOwner();
       const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
@@ -33398,8 +33541,8 @@ ${resultContent}${attachmentSummary}`;
       }
     });
     let settleDone;
-    const done = new Promise((resolve2) => {
-      settleDone = resolve2;
+    const done = new Promise((resolve3) => {
+      settleDone = resolve3;
     });
     const state = {
       socket,
@@ -33411,11 +33554,11 @@ ${resultContent}${attachmentSummary}`;
     };
     this.clientStreams.set(id, state);
     this.bridgeLastSeen.set(socket, Date.now());
-    const openResult = await new Promise((resolve2) => {
-      state.opened = resolve2;
+    const openResult = await new Promise((resolve3) => {
+      state.opened = resolve3;
       const timeoutMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : _DurableThread.CLIENT_STREAM_OPEN_TIMEOUT_MS;
       state.openTimer = setTimeout(() => {
-        resolve2({
+        resolve3({
           ok: false,
           error: `The client did not accept the ${request.tool} stream within ${Math.round(timeoutMs / 1e3)}s.`,
           code: "timeout"
@@ -33431,7 +33574,7 @@ ${resultContent}${attachmentSummary}`;
           })
         );
       } catch (error) {
-        resolve2({
+        resolve3({
           ok: false,
           error: `Failed to reach the client: ${error instanceof Error ? error.message : String(error)}`,
           code: "unavailable"
@@ -33610,13 +33753,13 @@ ${resultContent}${attachmentSummary}`;
     switch (parsed.type) {
       case "stream_opened": {
         if (state.opened) {
-          const resolve2 = state.opened;
+          const resolve3 = state.opened;
           state.opened = null;
           if (state.openTimer) {
             clearTimeout(state.openTimer);
             state.openTimer = null;
           }
-          resolve2({ ok: true });
+          resolve3({ ok: true });
         }
         return;
       }
@@ -34542,7 +34685,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       const busyWaitBudgetMs = 3e4;
       const waitStartedAt = Date.now();
       while (this.isExecuting && Date.now() - waitStartedAt < busyWaitBudgetMs) {
-        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        await new Promise((resolve3) => setTimeout(resolve3, 500));
       }
       if (this.isExecuting) {
         throw new Error(
@@ -35205,11 +35348,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Write a file to storage (RPC method)
    */
-  async writeFile(path20, data, mimeType, options) {
+  async writeFile(path21, data, mimeType, options) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const existingFile = await fs18.stat(path20);
+      const fs19 = this.getFileStorage();
+      const existingFile = await fs19.stat(path21);
       const isUpdate = existingFile !== null;
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
@@ -35217,7 +35360,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       for (let i = 0; i < binaryString.length; i++) {
         dataBuffer[i] = binaryString.charCodeAt(i);
         if (i > 0 && i % YIELD_INTERVAL === 0) {
-          await new Promise((resolve2) => setTimeout(resolve2, 0));
+          await new Promise((resolve3) => setTimeout(resolve3, 0));
         }
       }
       let thumbnailBuffer;
@@ -35227,16 +35370,16 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
         for (let i = 0; i < thumbBinary.length; i++) {
           thumbnailBuffer[i] = thumbBinary.charCodeAt(i);
           if (i > 0 && i % YIELD_INTERVAL === 0) {
-            await new Promise((resolve2) => setTimeout(resolve2, 0));
+            await new Promise((resolve3) => setTimeout(resolve3, 0));
           }
         }
       }
-      const record = await fs18.writeFile(path20, dataBuffer, mimeType, {
+      const record = await fs19.writeFile(path21, dataBuffer, mimeType, {
         metadata: options?.metadata,
         thumbnail: thumbnailBuffer
       });
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path: path20,
+        path: path21,
         file: record
       });
       return { success: true, file: record };
@@ -35248,15 +35391,15 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Write a text file to storage (RPC method)
    */
-  async writeTextFile(path20, content, mimeType = "text/plain", options) {
+  async writeTextFile(path21, content, mimeType = "text/plain", options) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const existingFile = await fs18.stat(path20);
+      const fs19 = this.getFileStorage();
+      const existingFile = await fs19.stat(path21);
       const isUpdate = existingFile !== null;
-      const record = await fs18.writeFile(path20, content, mimeType, options);
+      const record = await fs19.writeFile(path21, content, mimeType, options);
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path: path20,
+        path: path21,
         file: record
       });
       return { success: true, file: record };
@@ -35293,11 +35436,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Link to an external file (RPC method)
    */
-  async linkFile(path20, location, options) {
+  async linkFile(path21, location, options) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const record = await fs18.linkFile(path20, location, options);
+      const fs19 = this.getFileStorage();
+      const record = await fs19.linkFile(path21, location, options);
       return { success: true, file: record };
     } catch (error) {
       console.error("Error in linkFile:", error);
@@ -35308,11 +35451,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Read a file from storage (RPC method)
    * Returns base64-encoded data
    */
-  async readFile(path20) {
+  async readFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const data = await fs18.readFile(path20);
+      const fs19 = this.getFileStorage();
+      const data = await fs19.readFile(path21);
       if (data === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -35331,11 +35474,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Read a text file from storage (RPC method)
    */
-  async readTextFile(path20) {
+  async readTextFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const content = await fs18.readTextFile(path20);
+      const fs19 = this.getFileStorage();
+      const content = await fs19.readTextFile(path21);
       if (content === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -35348,11 +35491,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Get file metadata (RPC method)
    */
-  async statFile(path20) {
+  async statFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const record = await fs18.stat(path20);
+      const fs19 = this.getFileStorage();
+      const record = await fs19.stat(path21);
       if (record === null) {
         return { success: false, error: "File not found" };
       }
@@ -35365,11 +35508,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Check if file exists (RPC method)
    */
-  async fileExists(path20) {
+  async fileExists(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const exists2 = await fs18.exists(path20);
+      const fs19 = this.getFileStorage();
+      const exists2 = await fs19.exists(path21);
       return { success: true, exists: exists2 };
     } catch (error) {
       console.error("Error in fileExists:", error);
@@ -35379,12 +35522,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Delete a file (RPC method)
    */
-  async unlinkFile(path20) {
+  async unlinkFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      await fs18.unlink(path20);
-      this.broadcastEvent("file_deleted", { path: path20 });
+      const fs19 = this.getFileStorage();
+      await fs19.unlink(path21);
+      this.broadcastEvent("file_deleted", { path: path21 });
       return { success: true };
     } catch (error) {
       console.error("Error in unlinkFile:", error);
@@ -35394,12 +35537,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Create a directory (RPC method)
    */
-  async mkdirFile(path20) {
+  async mkdirFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const record = await fs18.mkdir(path20);
-      this.broadcastEvent("file_created", { path: path20, file: record });
+      const fs19 = this.getFileStorage();
+      const record = await fs19.mkdir(path21);
+      this.broadcastEvent("file_created", { path: path21, file: record });
       return { success: true, directory: record };
     } catch (error) {
       console.error("Error in mkdirFile:", error);
@@ -35409,11 +35552,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * List directory contents (RPC method)
    */
-  async readdirFile(path20) {
+  async readdirFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const files = await fs18.readdir(path20);
+      const fs19 = this.getFileStorage();
+      const files = await fs19.readdir(path21);
       return { success: true, files };
     } catch (error) {
       console.error("Error in readdirFile:", error);
@@ -35423,12 +35566,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Remove empty directory (RPC method)
    */
-  async rmdirFile(path20) {
+  async rmdirFile(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      await fs18.rmdir(path20);
-      this.broadcastEvent("file_deleted", { path: path20 });
+      const fs19 = this.getFileStorage();
+      await fs19.rmdir(path21);
+      this.broadcastEvent("file_deleted", { path: path21 });
       return { success: true };
     } catch (error) {
       console.error("Error in rmdirFile:", error);
@@ -35443,9 +35586,9 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs18 = this.getFileStorage();
+      const fs19 = this.getFileStorage();
       const from = normalizePath2(sourcePath);
-      const record = await fs18.move(sourcePath, destinationPath);
+      const record = await fs19.move(sourcePath, destinationPath);
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
       return { success: true, file: record };
@@ -35457,13 +35600,13 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Rename a file or directory in place (RPC method).
    */
-  async renameFile(path20, newName) {
+  async renameFile(path21, newName) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs18 = this.getFileStorage();
-      const from = normalizePath2(path20);
-      const record = await fs18.rename(path20, newName);
+      const fs19 = this.getFileStorage();
+      const from = normalizePath2(path21);
+      const record = await fs19.rename(path21, newName);
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
       return { success: true, file: record };
@@ -35478,8 +35621,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async getFileStats() {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const stats = await fs18.getFileStats();
+      const fs19 = this.getFileStorage();
+      const stats = await fs19.getFileStats();
       return { success: true, stats };
     } catch (error) {
       console.error("Error in getFileStats:", error);
@@ -35490,11 +35633,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Get thumbnail for an image (RPC method)
    * Returns base64-encoded data
    */
-  async getFileThumbnail(path20) {
+  async getFileThumbnail(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const data = await fs18.getThumbnail(path20);
+      const fs19 = this.getFileStorage();
+      const data = await fs19.getThumbnail(path21);
       if (data === null) {
         return { success: false, error: "Thumbnail not found" };
       }
@@ -35516,8 +35659,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async grepFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const results = await fs18.grep(pattern, options);
+      const fs19 = this.getFileStorage();
+      const results = await fs19.grep(pattern, options);
       return { success: true, results };
     } catch (error) {
       console.error("Error in grepFiles:", error);
@@ -35530,8 +35673,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async findFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const files = await fs18.find(pattern, options);
+      const fs19 = this.getFileStorage();
+      const files = await fs19.find(pattern, options);
       return { success: true, files };
     } catch (error) {
       console.error("Error in findFiles:", error);
@@ -35546,11 +35689,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Creates file record with is_chunked=1 and chunk_count=null.
    * Caller should then use writeFileChunk() to write chunks.
    */
-  async startChunkedUpload(path20, totalSize, mimeType, options) {
+  async startChunkedUpload(path21, 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(path20);
+      const normalizedPath = normalizePath2(path21);
       const name = basename3(normalizedPath);
       const now = Date.now();
       const expectedChunks = Math.ceil(totalSize / CHUNK_SIZE2);
@@ -35587,11 +35730,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * @param chunkIndex - 0-based chunk index
    * @param data - Base64 encoded chunk data
    */
-  async writeFileChunk(path20, chunkIndex, data) {
+  async writeFileChunk(path21, chunkIndex, data) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path20);
+      const normalizedPath = normalizePath2(path21);
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
       for (let i = 0; i < binaryString.length; i++) {
@@ -35613,12 +35756,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Complete a chunked file upload.
    * Validates all chunks are present and sets chunk_count.
    */
-  async completeChunkedUpload(path20, expectedChunks, options) {
+  async completeChunkedUpload(path21, expectedChunks, options) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs18 = this.getFileStorage();
-      const normalizedPath = normalizePath2(path20);
+      const fs19 = this.getFileStorage();
+      const normalizedPath = normalizePath2(path21);
       const countResult = await this.ctx.storage.sql.exec(
         `SELECT COUNT(*) as count FROM file_chunks WHERE file_path = ?`,
         normalizedPath
@@ -35644,7 +35787,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
         thumbnailBuffer || null,
         normalizedPath
       );
-      const file = await fs18.stat(normalizedPath);
+      const file = await fs19.stat(normalizedPath);
       if (file) {
         this.broadcastEvent("file_created", { path: normalizedPath, file });
       }
@@ -35658,11 +35801,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Read a single chunk of a file.
    * Use for streaming large files to client.
    */
-  async readFileChunk(path20, chunkIndex) {
+  async readFileChunk(path21, chunkIndex) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path20);
+      const normalizedPath = normalizePath2(path21);
       const cursor = await this.ctx.storage.sql.exec(
         `SELECT data FROM file_chunks WHERE file_path = ? AND chunk_index = ?`,
         normalizedPath,
@@ -35687,11 +35830,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Get file info including chunking metadata.
    */
-  async getFileInfo(path20) {
+  async getFileInfo(path21) {
     await this.ensureMigrated();
     try {
-      const fs18 = this.getFileStorage();
-      const file = await fs18.stat(path20);
+      const fs19 = this.getFileStorage();
+      const file = await fs19.stat(path21);
       if (!file) {
         return { success: false, error: "File not found" };
       }
@@ -35909,16 +36052,16 @@ function parseUserRouteKey(key) {
   }
   return { key, method, segments, dynamism };
 }
-function matchSegments(route, path20) {
+function matchSegments(route, path21) {
   const params = {};
   for (let i = 0; i < route.length; i++) {
     const seg = route[i];
     if (seg === "[*]") {
       if (i !== route.length - 1) return null;
-      params["*"] = path20.slice(i).join("/");
+      params["*"] = path21.slice(i).join("/");
       return params;
     }
-    const value = path20[i];
+    const value = path21[i];
     if (value === void 0) return null;
     if (seg.startsWith("[") && seg.endsWith("]")) {
       params[seg.slice(1, -1)] = value;
@@ -35926,16 +36069,16 @@ function matchSegments(route, path20) {
       return null;
     }
   }
-  return path20.length === route.length ? params : null;
+  return path21.length === route.length ? params : null;
 }
 function matchUserRoute(keys, method, endpointPath) {
-  const path20 = endpointPath.split("/").filter((s) => s.length > 0);
+  const path21 = endpointPath.split("/").filter((s) => s.length > 0);
   const wanted = method.toUpperCase();
   let best = null;
   for (const key of keys) {
     const route = parseUserRouteKey(key);
     if (route.method !== wanted) continue;
-    const params = matchSegments(route.segments, path20);
+    const params = matchSegments(route.segments, path21);
     if (!params) continue;
     if (!best || route.dynamism < best.route.dynamism) {
       best = { route, params };
@@ -36960,6 +37103,6 @@ init_context();
 init_ProviderRegistry();
 init_types2();
 
-export { CLIENT_STREAM_CHUNK_BYTES, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, NamespaceResolutionError, PackageDiscoveryService, ProviderRegistry, ThreadWatchdog, agentbuilder, assistantMessageText, authenticate, buildImageDescription, builder, callClient, callClientStream, cat, createNamespaceContext, createThreadEndpointHandler, decodeStreamChunk, defineController2 as defineController, discoverPackages, emitThreadEvent, encodeStreamChunk, enhanceFlowState, exists, find, forceTurn, generateAgentFile, generateImageDescription, generateModelFile, generatePromptFile, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, hasJsonArrayEntries, head, injectMessage, isQualifiedName, isVisibleTerminalAssistantMessage, linkFile, messageTimestampSeconds, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, supportsClientForwarding, tail, unlink, updateThread, writeFile, writeImage };
+export { CLIENT_STREAM_CHUNK_BYTES, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, NamespaceResolutionError, PackageDiscoveryService, ProviderRegistry, ThreadWatchdog, agentbuilder, assistantMessageText, authenticate, buildImageDescription, builder, callClient, callClientStream, canAccessThread, cat, createNamespaceContext, createThreadEndpointHandler, decodeStreamChunk, defineController2 as defineController, discoverPackages, emitThreadEvent, encodeStreamChunk, enhanceFlowState, exists, find, forceTurn, generateAgentFile, generateImageDescription, generateModelFile, generatePromptFile, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, hasJsonArrayEntries, head, injectMessage, isAdminOnlyApiRoute, isHostedInstance, isPublicApiRoute, isQualifiedName, isTrustedLocalDevelopmentRequest, isVisibleTerminalAssistantMessage, linkFile, messageTimestampSeconds, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, supportsClientForwarding, tail, unlink, updateThread, writeFile, writeImage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map