agentuity-vscode 0.1.22 → 0.1.24

package/dist/extension.js

@@ -6104,7 +6104,7 @@ __export(extension_exports, {
   deactivate: () => deactivate
 });
 module.exports = __toCommonJS(extension_exports);
-var vscode27 = __toESM(require("vscode"));
+var vscode28 = __toESM(require("vscode"));
 
 // src/core/cliClient.ts
 var vscode = __toESM(require("vscode"));
@@ -7181,6 +7181,48 @@ var CliClient = class {
   async whoami() {
     return this.exec(["auth", "whoami"], { format: "json" });
   }
+  // ==================== Org/Region Methods ====================
+  async orgList() {
+    const result = await this.exec(["auth", "whoami"], {
+      format: "json"
+    });
+    if (result.success && result.data) {
+      const whoamiData = result.data;
+      return {
+        success: true,
+        data: whoamiData.organizations || [],
+        exitCode: result.exitCode
+      };
+    }
+    return { success: result.success, error: result.error, data: [], exitCode: result.exitCode };
+  }
+  async orgCurrent() {
+    return this.exec(["auth", "org", "current"], { format: "json" });
+  }
+  async orgSelect(orgId) {
+    return this.exec(["auth", "org", "select", orgId], { format: "json" });
+  }
+  async orgUnselect() {
+    return this.exec(["auth", "org", "unselect"], { format: "json" });
+  }
+  async regionList() {
+    const regions = [
+      { region: "usc", description: "US Central" },
+      { region: "use", description: "US East" }
+    ];
+    return { success: true, data: regions, exitCode: 0 };
+  }
+  async regionCurrent() {
+    return this.exec(["cloud", "region", "current"], { format: "json" });
+  }
+  async regionSelect(region) {
+    return this.exec(["cloud", "region", "select", region], {
+      format: "json"
+    });
+  }
+  async regionUnselect() {
+    return this.exec(["cloud", "region", "unselect"], { format: "json" });
+  }
   async listAgents() {
     return this.exec(["cloud", "agent", "list"], { format: "json" });
   }
@@ -7273,11 +7315,150 @@ var CliClient = class {
   async deleteStream(id) {
     return this.exec(["cloud", "stream", "delete", id], { format: "json" });
   }
+  // Queue methods
+  async listQueues(opts) {
+    const args = ["cloud", "queue", "list"];
+    if (opts?.limit) {
+      args.push("--limit", String(opts.limit));
+    }
+    if (opts?.offset) {
+      args.push("--offset", String(opts.offset));
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async getQueue(name2) {
+    return this.exec(["cloud", "queue", "get", name2], { format: "json" });
+  }
+  async getQueueStats() {
+    return this.exec(["cloud", "queue", "stats"], { format: "json" });
+  }
+  async listQueueMessages(queueName, opts) {
+    const args = ["cloud", "queue", "messages", queueName];
+    if (opts?.limit) {
+      args.push("--limit", String(opts.limit));
+    }
+    if (opts?.offset) {
+      args.push("--offset", String(opts.offset));
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async getQueueMessage(queueName, messageId) {
+    return this.exec(["cloud", "queue", "messages", queueName, messageId], {
+      format: "json"
+    });
+  }
+  async publishQueueMessage(queueName, payload, opts) {
+    const quotedPayload = `'${payload.replace(/'/g, "'\\''")}'`;
+    const args = ["cloud", "queue", "publish", queueName, quotedPayload];
+    if (opts?.metadata) {
+      const quotedMetadata = `'${opts.metadata.replace(/'/g, "'\\''")}'`;
+      args.push("--metadata", quotedMetadata);
+    }
+    if (opts?.ttl) {
+      args.push("--ttl", String(opts.ttl));
+    }
+    if (opts?.partitionKey) {
+      args.push("--partitionKey", opts.partitionKey);
+    }
+    if (opts?.idempotencyKey) {
+      args.push("--idempotencyKey", opts.idempotencyKey);
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async pauseQueue(name2) {
+    return this.exec(["cloud", "queue", "pause", name2], { format: "json" });
+  }
+  async resumeQueue(name2) {
+    return this.exec(["cloud", "queue", "resume", name2], { format: "json" });
+  }
+  async deleteQueue(name2) {
+    return this.exec(["cloud", "queue", "delete", name2, "--confirm"], {
+      format: "json"
+    });
+  }
+  async createQueue(queueType, name2, opts) {
+    const args = ["cloud", "queue", "create", queueType, "--name", name2];
+    if (opts?.ttl) {
+      args.push("--ttl", String(opts.ttl));
+    }
+    if (opts?.description) {
+      args.push("--description", opts.description);
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async listDlqMessages(queueName, opts) {
+    const args = ["cloud", "queue", "dlq", "list", queueName];
+    if (opts?.limit) {
+      args.push("--limit", String(opts.limit));
+    }
+    if (opts?.offset) {
+      args.push("--offset", String(opts.offset));
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async replayDlqMessage(queueName, messageId) {
+    return this.exec(
+      ["cloud", "queue", "dlq", "replay", queueName, messageId],
+      { format: "json" }
+    );
+  }
+  async purgeDlq(queueName) {
+    return this.exec(
+      ["cloud", "queue", "dlq", "purge", queueName, "--confirm"],
+      { format: "json" }
+    );
+  }
+  async listQueueDestinations(queueName) {
+    return this.exec(
+      ["cloud", "queue", "destinations", "list", queueName],
+      { format: "json" }
+    );
+  }
+  async createQueueDestination(queueName, url, opts) {
+    const args = ["cloud", "queue", "destinations", "create", queueName, "--url", url];
+    if (opts?.method) {
+      args.push("--method", opts.method);
+    }
+    if (opts?.timeout) {
+      args.push("--timeout", String(opts.timeout));
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async updateQueueDestination(queueName, destinationId, opts) {
+    const args = ["cloud", "queue", "destinations", "update", queueName, destinationId];
+    if (opts.url) {
+      args.push("--url", opts.url);
+    }
+    if (opts.method) {
+      args.push("--method", opts.method);
+    }
+    if (opts.timeout) {
+      args.push("--timeout", String(opts.timeout));
+    }
+    if (opts.enabled) {
+      args.push("--enabled");
+    }
+    if (opts.disabled) {
+      args.push("--disabled");
+    }
+    return this.exec(args, { format: "json" });
+  }
+  async deleteQueueDestination(queueName, destinationId) {
+    return this.exec(
+      ["cloud", "queue", "destinations", "delete", queueName, destinationId],
+      { format: "json" }
+    );
+  }
   // Profile methods
   async getCurrentProfile() {
     return this.exec(["profile", "current"], { format: "json" });
   }
   // Vector methods
+  async listVectorNamespaces() {
+    return this.exec(["cloud", "vector", "list-namespaces"], {
+      format: "json"
+    });
+  }
   async vectorSearch(namespace, query, opts) {
     const args = ["cloud", "vector", "search", namespace, query];
     if (opts?.limit) {
@@ -7374,6 +7555,9 @@ var CliClient = class {
     if (options.description) {
       args.push("--description", options.description);
     }
+    if (options.projectId) {
+      args.push("--project-id", options.projectId);
+    }
     if (options.memory) {
       args.push("--memory", options.memory);
     }
@@ -7413,6 +7597,11 @@ var CliClient = class {
         args.push("--metadata", `${key}=${value}`);
       }
     }
+    if (options.files && options.files.length > 0) {
+      for (const file of options.files) {
+        args.push("--file", `${file.path}:${file.content}`);
+      }
+    }
     return this.exec(args, { format: "json", timeout: 12e4 });
   }
   /**
@@ -7944,8 +8133,8 @@ var DevServerManager = class {
     this.hasReceivedOutput = false;
     const cli = getCliClient();
     const env9 = cli.getCliEnv();
-    const cliPath = "bunx";
-    const args = ["agentuity", "dev"];
+    const cliPath = cli.getCliPath();
+    const args = ["dev"];
     const spawnOpts = {
       cwd: project.rootPath,
       shell: true,
@@ -8644,7 +8833,7 @@ function getExtension(language) {
 }
 
 // src/features/agentExplorer/index.ts
-var vscode11 = __toESM(require("vscode"));
+var vscode12 = __toESM(require("vscode"));
 var path5 = __toESM(require("path"));
 
 // src/features/agentExplorer/agentTreeData.ts
@@ -8768,8 +8957,27 @@ var AgentTreeDataProvider = class extends BaseTreeDataProvider {
   }
 };
 
+// src/core/urls.ts
+var vscode11 = __toESM(require("vscode"));
+var DEFAULT_APP_URL = "https://app.agentuity.com";
+function getAppUrl() {
+  const config = vscode11.workspace.getConfiguration("agentuity");
+  return config.get("appUrl") || DEFAULT_APP_URL;
+}
+function getSessionsUrl(projectId, agentIdentifier) {
+  const base = getAppUrl();
+  let url = `${base}/projects/${projectId}/sessions`;
+  if (agentIdentifier) {
+    url += `?agent=${encodeURIComponent(agentIdentifier)}`;
+  }
+  return url;
+}
+function getWorkbenchUrl(projectId) {
+  const base = getAppUrl();
+  return `${base}/projects/${projectId}`;
+}
+
 // src/features/agentExplorer/index.ts
-var SESSIONS_BASE_URL = "https://app-v1.agentuity.com";
 var agentProvider;
 function getAgentProvider() {
   return agentProvider;
@@ -8777,7 +8985,7 @@ function getAgentProvider() {
 function registerAgentExplorer(context) {
   const provider = new AgentTreeDataProvider();
   agentProvider = provider;
-  const treeView = vscode11.window.createTreeView("agentuity.agents", {
+  const treeView = vscode12.window.createTreeView("agentuity.agents", {
     treeDataProvider: provider,
     showCollapseAll: true
   });
@@ -8788,61 +8996,61 @@ function registerAgentExplorer(context) {
     void provider.forceRefresh();
   });
   context.subscriptions.push(
-    vscode11.commands.registerCommand("agentuity.agent.goToFile", async (item) => {
+    vscode12.commands.registerCommand("agentuity.agent.goToFile", async (item) => {
       const filename = item?.agentData?.metadata?.filename;
       if (typeof filename !== "string") {
-        vscode11.window.showWarningMessage("No source file associated with this agent");
+        vscode12.window.showWarningMessage("No source file associated with this agent");
         return;
       }
       const project = getCurrentProject();
       if (!project) {
-        vscode11.window.showWarningMessage("No project detected");
+        vscode12.window.showWarningMessage("No project detected");
         return;
       }
       const filePath = path5.join(project.rootPath, filename);
-      const uri = vscode11.Uri.file(filePath);
+      const uri = vscode12.Uri.file(filePath);
       try {
-        await vscode11.window.showTextDocument(uri);
+        await vscode12.window.showTextDocument(uri);
       } catch {
-        vscode11.window.showErrorMessage(`Could not open file: ${filePath}`);
+        vscode12.window.showErrorMessage(`Could not open file: ${filePath}`);
       }
     })
   );
   context.subscriptions.push(
-    vscode11.commands.registerCommand(
+    vscode12.commands.registerCommand(
       "agentuity.agent.viewSessions",
       async (item) => {
         const project = getCurrentProject();
         if (!project) {
-          vscode11.window.showErrorMessage("No Agentuity project found");
+          vscode12.window.showErrorMessage("No Agentuity project found");
           return;
         }
         const agent = item?.agentData;
         if (!agent) {
-          vscode11.window.showWarningMessage("No agent selected");
+          vscode12.window.showWarningMessage("No agent selected");
           return;
         }
-        const url = `${SESSIONS_BASE_URL}/projects/${project.projectId}/sessions?agent=${agent.id}`;
-        await vscode11.env.openExternal(vscode11.Uri.parse(url));
+        const url = getSessionsUrl(project.projectId, agent.id);
+        await vscode12.env.openExternal(vscode12.Uri.parse(url));
       }
     )
   );
   context.subscriptions.push(
-    vscode11.commands.registerCommand(
+    vscode12.commands.registerCommand(
       "agentuity.agent.viewSessionLogs",
       async (item) => {
         const project = getCurrentProject();
         if (!project) {
-          vscode11.window.showErrorMessage("No Agentuity project found");
+          vscode12.window.showErrorMessage("No Agentuity project found");
           return;
         }
         const agent = item?.agentData;
         if (!agent) {
-          vscode11.window.showWarningMessage("No agent selected");
+          vscode12.window.showWarningMessage("No agent selected");
           return;
         }
-        const url = `${SESSIONS_BASE_URL}/projects/${project.projectId}/sessions?agent=${agent.id}`;
-        await vscode11.env.openExternal(vscode11.Uri.parse(url));
+        const url = getSessionsUrl(project.projectId, agent.id);
+        await vscode12.env.openExternal(vscode12.Uri.parse(url));
       }
     )
   );
@@ -8851,12 +9059,12 @@ function registerAgentExplorer(context) {
 }
 
 // src/features/dataExplorer/index.ts
-var vscode13 = __toESM(require("vscode"));
+var vscode14 = __toESM(require("vscode"));
 
 // src/features/dataExplorer/dataTreeData.ts
-var vscode12 = __toESM(require("vscode"));
-var DataTreeItem = class extends vscode12.TreeItem {
-  constructor(label, collapsibleState, itemType, category, parentName, vectorResult, streamInfo) {
+var vscode13 = __toESM(require("vscode"));
+var DataTreeItem = class extends vscode13.TreeItem {
+  constructor(label, collapsibleState, itemType, category, parentName, vectorResult, streamInfo, queueInfo) {
     super(label, collapsibleState);
     this.label = label;
     this.collapsibleState = collapsibleState;
@@ -8865,6 +9073,7 @@ var DataTreeItem = class extends vscode12.TreeItem {
     this.parentName = parentName;
     this.vectorResult = vectorResult;
     this.streamInfo = streamInfo;
+    this.queueInfo = queueInfo;
     this.setIcon();
     if (itemType === "category" && category === "vector") {
       this.contextValue = "category-vector";
@@ -8872,58 +9081,101 @@ var DataTreeItem = class extends vscode12.TreeItem {
       this.contextValue = itemType;
     }
   }
+  messageId;
+  destinationId;
   setIcon() {
     switch (this.itemType) {
       case "category":
         if (this.label === "Key-Value") {
-          this.iconPath = new vscode12.ThemeIcon("database");
+          this.iconPath = new vscode13.ThemeIcon("database");
         } else if (this.label === "Databases") {
-          this.iconPath = new vscode12.ThemeIcon("server");
+          this.iconPath = new vscode13.ThemeIcon("server");
         } else if (this.label === "Vectors") {
-          this.iconPath = new vscode12.ThemeIcon("symbol-numeric");
+          this.iconPath = new vscode13.ThemeIcon("symbol-numeric");
         } else if (this.label === "Storage") {
-          this.iconPath = new vscode12.ThemeIcon("cloud");
+          this.iconPath = new vscode13.ThemeIcon("cloud");
         } else if (this.label === "Streams") {
-          this.iconPath = new vscode12.ThemeIcon("pulse");
+          this.iconPath = new vscode13.ThemeIcon("pulse");
+        } else if (this.label === "Queues") {
+          this.iconPath = new vscode13.ThemeIcon("mail");
         }
         break;
       case "namespace":
-        this.iconPath = new vscode12.ThemeIcon("folder");
+        this.iconPath = new vscode13.ThemeIcon("folder");
         break;
       case "key":
-        this.iconPath = new vscode12.ThemeIcon("symbol-key");
+        this.iconPath = new vscode13.ThemeIcon("symbol-key");
         break;
       case "database":
-        this.iconPath = new vscode12.ThemeIcon("database");
+        this.iconPath = new vscode13.ThemeIcon("database");
         break;
       case "vectorSearchGroup":
-        this.iconPath = new vscode12.ThemeIcon("search");
+        this.iconPath = new vscode13.ThemeIcon("search");
         break;
       case "vectorResult":
-        this.iconPath = new vscode12.ThemeIcon("file-text");
+        this.iconPath = new vscode13.ThemeIcon("file-text");
         break;
       case "storageBucket":
-        this.iconPath = new vscode12.ThemeIcon("package");
+        this.iconPath = new vscode13.ThemeIcon("package");
         break;
       case "storageFile":
-        this.iconPath = new vscode12.ThemeIcon("file");
+        this.iconPath = new vscode13.ThemeIcon("file");
         break;
       case "streamItem":
-        this.iconPath = new vscode12.ThemeIcon("broadcast");
+        this.iconPath = new vscode13.ThemeIcon("broadcast");
+        break;
+      case "queueItem":
+        this.iconPath = new vscode13.ThemeIcon("mail");
+        break;
+      case "queueSection":
+        if (this.label === "Messages") {
+          this.iconPath = new vscode13.ThemeIcon("inbox");
+        } else if (this.label === "Dead Letter Queue") {
+          this.iconPath = new vscode13.ThemeIcon("warning");
+        } else if (this.label === "Destinations") {
+          this.iconPath = new vscode13.ThemeIcon("link-external");
+        }
+        break;
+      case "queueMessage":
+        this.iconPath = new vscode13.ThemeIcon("mail");
+        break;
+      case "dlqMessage":
+        this.iconPath = new vscode13.ThemeIcon("warning");
+        break;
+      case "queueDestination":
+        this.iconPath = new vscode13.ThemeIcon("link-external");
         break;
       case "message":
-        this.iconPath = new vscode12.ThemeIcon("info");
+        this.iconPath = new vscode13.ThemeIcon("info");
         break;
     }
   }
 };
 var DataTreeDataProvider = class {
-  _onDidChangeTreeData = new vscode12.EventEmitter();
+  _onDidChangeTreeData = new vscode13.EventEmitter();
   onDidChangeTreeData = this._onDidChangeTreeData.event;
   vectorSearchGroups = [];
+  messageLimits = /* @__PURE__ */ new Map();
+  dlqLimits = /* @__PURE__ */ new Map();
+  MESSAGE_PAGE_SIZE = 25;
   refresh() {
     this._onDidChangeTreeData.fire();
   }
+  refreshQueueMessages(queueName) {
+    this.messageLimits.delete(queueName);
+    this.dlqLimits.delete(queueName);
+    this._onDidChangeTreeData.fire();
+  }
+  loadMoreMessages(queueName) {
+    const currentLimit = this.messageLimits.get(queueName) || this.MESSAGE_PAGE_SIZE;
+    this.messageLimits.set(queueName, currentLimit + this.MESSAGE_PAGE_SIZE);
+    this._onDidChangeTreeData.fire();
+  }
+  loadMoreDlqMessages(queueName) {
+    const currentLimit = this.dlqLimits.get(queueName) || this.MESSAGE_PAGE_SIZE;
+    this.dlqLimits.set(queueName, currentLimit + this.MESSAGE_PAGE_SIZE);
+    this._onDidChangeTreeData.fire();
+  }
   addVectorSearchGroup(group) {
     this.vectorSearchGroups.unshift(group);
     this.refresh();
@@ -8939,24 +9191,24 @@ var DataTreeDataProvider = class {
     const authStatus = getAuthStatus();
     if (authStatus.state === "unknown") {
       return [
-        new DataTreeItem("Checking auth...", vscode12.TreeItemCollapsibleState.None, "message")
+        new DataTreeItem("Checking auth...", vscode13.TreeItemCollapsibleState.None, "message")
       ];
     }
     if (authStatus.state === "cli-missing") {
       return [
-        new DataTreeItem("CLI not installed", vscode12.TreeItemCollapsibleState.None, "message")
+        new DataTreeItem("CLI not installed", vscode13.TreeItemCollapsibleState.None, "message")
       ];
     }
     if (authStatus.state === "unauthenticated") {
       return [
-        new DataTreeItem("Not logged in", vscode12.TreeItemCollapsibleState.None, "message")
+        new DataTreeItem("Not logged in", vscode13.TreeItemCollapsibleState.None, "message")
       ];
     }
     if (!hasProject()) {
       return [
         new DataTreeItem(
           "No project detected",
-          vscode12.TreeItemCollapsibleState.None,
+          vscode13.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -8965,33 +9217,39 @@ var DataTreeDataProvider = class {
       return [
         new DataTreeItem(
           "Key-Value",
-          vscode12.TreeItemCollapsibleState.Collapsed,
+          vscode13.TreeItemCollapsibleState.Collapsed,
           "category",
           "kv"
         ),
         new DataTreeItem(
           "Databases",
-          vscode12.TreeItemCollapsibleState.Collapsed,
+          vscode13.TreeItemCollapsibleState.Collapsed,
           "category",
           "db"
         ),
         new DataTreeItem(
           "Vectors",
-          vscode12.TreeItemCollapsibleState.Collapsed,
+          vscode13.TreeItemCollapsibleState.Collapsed,
           "category",
           "vector"
         ),
         new DataTreeItem(
           "Storage",
-          vscode12.TreeItemCollapsibleState.Collapsed,
+          vscode13.TreeItemCollapsibleState.Collapsed,
           "category",
           "storage"
         ),
         new DataTreeItem(
           "Streams",
-          vscode12.TreeItemCollapsibleState.Collapsed,
+          vscode13.TreeItemCollapsibleState.Collapsed,
           "category",
           "stream"
+        ),
+        new DataTreeItem(
+          "Queues",
+          vscode13.TreeItemCollapsibleState.Collapsed,
+          "category",
+          "queue"
         )
       ];
     }
@@ -9007,6 +9265,19 @@ var DataTreeDataProvider = class {
     if (element.itemType === "storageBucket" && element.category === "storage") {
       return this.loadStorageFiles(element.label);
     }
+    if (element.itemType === "queueItem" && element.queueInfo) {
+      return this.loadQueueSections(element.queueInfo.name);
+    }
+    if (element.itemType === "queueSection" && element.parentName) {
+      const sectionLabel = element.label;
+      if (sectionLabel === "Messages") {
+        return this.loadQueueMessages(element.parentName);
+      } else if (sectionLabel === "Dead Letter Queue") {
+        return this.loadDlqMessages(element.parentName);
+      } else if (sectionLabel === "Destinations") {
+        return this.loadQueueDestinations(element.parentName);
+      }
+    }
     return [];
   }
   getErrorMessage(error, category) {
@@ -9026,7 +9297,7 @@ var DataTreeDataProvider = class {
             return [
               new DataTreeItem(
                 "No namespaces",
-                vscode12.TreeItemCollapsibleState.None,
+                vscode13.TreeItemCollapsibleState.None,
                 "message"
               )
             ];
@@ -9034,7 +9305,7 @@ var DataTreeDataProvider = class {
           return result.data.map((ns) => {
             return new DataTreeItem(
               ns,
-              vscode12.TreeItemCollapsibleState.Collapsed,
+              vscode13.TreeItemCollapsibleState.Collapsed,
               "namespace",
               "kv"
             );
@@ -9043,7 +9314,7 @@ var DataTreeDataProvider = class {
         return [
           new DataTreeItem(
             this.getErrorMessage(result.error, "namespaces"),
-            vscode12.TreeItemCollapsibleState.None,
+            vscode13.TreeItemCollapsibleState.None,
             "message"
           )
         ];
@@ -9054,7 +9325,7 @@ var DataTreeDataProvider = class {
             return [
               new DataTreeItem(
                 "No databases",
-                vscode12.TreeItemCollapsibleState.None,
+                vscode13.TreeItemCollapsibleState.None,
                 "message"
               )
             ];
@@ -9062,7 +9333,7 @@ var DataTreeDataProvider = class {
           return result.data.databases.map((db) => {
             const item = new DataTreeItem(
               db.name,
-              vscode12.TreeItemCollapsibleState.None,
+              vscode13.TreeItemCollapsibleState.None,
               "database",
               "db"
             );
@@ -9073,31 +9344,57 @@ var DataTreeDataProvider = class {
         return [
           new DataTreeItem(
             this.getErrorMessage(result.error, "databases"),
-            vscode12.TreeItemCollapsibleState.None,
+            vscode13.TreeItemCollapsibleState.None,
             "message"
           )
         ];
       } else if (element.category === "vector") {
-        if (this.vectorSearchGroups.length === 0) {
+        const items = [];
+        if (this.vectorSearchGroups.length > 0) {
+          for (const group of this.vectorSearchGroups) {
+            const item = new DataTreeItem(
+              group.label,
+              vscode13.TreeItemCollapsibleState.Collapsed,
+              "vectorSearchGroup",
+              "vector",
+              group.id
+            );
+            item.description = `${group.results.length} results`;
+            items.push(item);
+          }
+        }
+        const result = await cli.listVectorNamespaces();
+        if (result.success && Array.isArray(result.data) && result.data.length > 0) {
+          if (items.length > 0) {
+            const separator = new DataTreeItem(
+              "\u2500\u2500\u2500 Namespaces \u2500\u2500\u2500",
+              vscode13.TreeItemCollapsibleState.None,
+              "message"
+            );
+            items.push(separator);
+          }
+          for (const ns of result.data) {
+            const item = new DataTreeItem(
+              ns,
+              vscode13.TreeItemCollapsibleState.None,
+              "namespace",
+              "vector"
+            );
+            item.tooltip = `Vector namespace: ${ns}
+Right-click to search`;
+            items.push(item);
+          }
+        }
+        if (items.length === 0) {
           const item = new DataTreeItem(
-            'Use "Search Vectors..." to search',
-            vscode12.TreeItemCollapsibleState.None,
+            "No namespaces found",
+            vscode13.TreeItemCollapsibleState.None,
             "message"
           );
-          item.tooltip = "Right-click on Vectors or use the command palette";
+          item.tooltip = "Deploy your project to create vector namespaces";
           return [item];
         }
-        return this.vectorSearchGroups.map((group) => {
-          const item = new DataTreeItem(
-            group.label,
-            vscode12.TreeItemCollapsibleState.Collapsed,
-            "vectorSearchGroup",
-            "vector",
-            group.id
-          );
-          item.description = `${group.results.length} results`;
-          return item;
-        });
+        return items;
       } else if (element.category === "storage") {
         const result = await cli.listStorageBuckets();
         if (result.success && result.data?.buckets) {
@@ -9105,7 +9402,7 @@ var DataTreeDataProvider = class {
             return [
               new DataTreeItem(
                 "No buckets",
-                vscode12.TreeItemCollapsibleState.None,
+                vscode13.TreeItemCollapsibleState.None,
                 "message"
               )
             ];
@@ -9113,7 +9410,7 @@ var DataTreeDataProvider = class {
           return result.data.buckets.map((bucket) => {
             const item = new DataTreeItem(
               bucket.bucket_name,
-              vscode12.TreeItemCollapsibleState.Collapsed,
+              vscode13.TreeItemCollapsibleState.Collapsed,
               "storageBucket",
               "storage"
             );
@@ -9126,7 +9423,7 @@ var DataTreeDataProvider = class {
         return [
           new DataTreeItem(
             this.getErrorMessage(result.error, "storage"),
-            vscode12.TreeItemCollapsibleState.None,
+            vscode13.TreeItemCollapsibleState.None,
             "message"
           )
         ];
@@ -9137,7 +9434,7 @@ var DataTreeDataProvider = class {
             return [
               new DataTreeItem(
                 "No streams",
-                vscode12.TreeItemCollapsibleState.None,
+                vscode13.TreeItemCollapsibleState.None,
                 "message"
               )
             ];
@@ -9145,7 +9442,7 @@ var DataTreeDataProvider = class {
           return result.data.streams.map((stream) => {
             const item = new DataTreeItem(
               stream.name || stream.id,
-              vscode12.TreeItemCollapsibleState.None,
+              vscode13.TreeItemCollapsibleState.None,
               "streamItem",
               "stream",
               void 0,
@@ -9161,16 +9458,53 @@ URL: ${stream.url}`;
         return [
           new DataTreeItem(
             this.getErrorMessage(result.error, "streams"),
-            vscode12.TreeItemCollapsibleState.None,
+            vscode13.TreeItemCollapsibleState.None,
+            "message"
+          )
+        ];
+      } else if (element.category === "queue") {
+        const result = await cli.listQueues();
+        if (result.success && result.data?.queues) {
+          if (result.data.queues.length === 0) {
+            return [
+              new DataTreeItem("No queues", vscode13.TreeItemCollapsibleState.None, "message")
+            ];
+          }
+          return result.data.queues.map((queue) => {
+            const item = new DataTreeItem(
+              queue.name,
+              vscode13.TreeItemCollapsibleState.Collapsed,
+              "queueItem",
+              "queue",
+              void 0,
+              void 0,
+              void 0,
+              queue
+            );
+            item.description = `${queue.queue_type} \u2022 ${queue.message_count} msgs`;
+            item.tooltip = [
+              `Name: ${queue.name}`,
+              `Type: ${queue.queue_type}`,
+              `Messages: ${queue.message_count}`,
+              `DLQ: ${queue.dlq_count}`,
+              `Created: ${new Date(queue.created_at).toLocaleString()}`
+            ].join("\n");
+            return item;
+          });
+        }
+        return [
+          new DataTreeItem(
+            this.getErrorMessage(result.error, "queues"),
+            vscode13.TreeItemCollapsibleState.None,
             "message"
           )
         ];
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to load";
-      return [new DataTreeItem(message, vscode12.TreeItemCollapsibleState.None, "message")];
+      return [new DataTreeItem(message, vscode13.TreeItemCollapsibleState.None, "message")];
     }
-    return [new DataTreeItem("Failed to load", vscode12.TreeItemCollapsibleState.None, "message")];
+    return [new DataTreeItem("Failed to load", vscode13.TreeItemCollapsibleState.None, "message")];
   }
   loadVectorSearchResults(groupId) {
     const group = this.vectorSearchGroups.find((g) => g.id === groupId);
@@ -9178,12 +9512,12 @@ URL: ${stream.url}`;
       return [];
     }
     if (group.results.length === 0) {
-      return [new DataTreeItem("No results", vscode12.TreeItemCollapsibleState.None, "message")];
+      return [new DataTreeItem("No results", vscode13.TreeItemCollapsibleState.None, "message")];
     }
     return group.results.map((result) => {
       const item = new DataTreeItem(
         result.key ?? "(unknown)",
-        vscode12.TreeItemCollapsibleState.None,
+        vscode13.TreeItemCollapsibleState.None,
         "vectorResult",
         "vector",
         group.namespace,
@@ -9202,13 +9536,13 @@ ID: ${result.id ?? "(unknown)"}`;
       if (result.success && result.data?.keys) {
         if (result.data.keys.length === 0) {
           return [
-            new DataTreeItem("No keys", vscode12.TreeItemCollapsibleState.None, "message")
+            new DataTreeItem("No keys", vscode13.TreeItemCollapsibleState.None, "message")
           ];
         }
         return result.data.keys.map(
           (key) => new DataTreeItem(
             key,
-            vscode12.TreeItemCollapsibleState.None,
+            vscode13.TreeItemCollapsibleState.None,
             "key",
             "kv",
             namespace
@@ -9217,10 +9551,10 @@ ID: ${result.id ?? "(unknown)"}`;
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to load keys";
-      return [new DataTreeItem(message, vscode12.TreeItemCollapsibleState.None, "message")];
+      return [new DataTreeItem(message, vscode13.TreeItemCollapsibleState.None, "message")];
     }
     return [
-      new DataTreeItem("Failed to load keys", vscode12.TreeItemCollapsibleState.None, "message")
+      new DataTreeItem("Failed to load keys", vscode13.TreeItemCollapsibleState.None, "message")
     ];
   }
   async loadStorageFiles(bucket) {
@@ -9230,13 +9564,13 @@ ID: ${result.id ?? "(unknown)"}`;
       if (result.success && result.data?.files) {
         if (result.data.files.length === 0) {
           return [
-            new DataTreeItem("No files", vscode12.TreeItemCollapsibleState.None, "message")
+            new DataTreeItem("No files", vscode13.TreeItemCollapsibleState.None, "message")
           ];
         }
         return result.data.files.map((file) => {
           const item = new DataTreeItem(
             file.key,
-            vscode12.TreeItemCollapsibleState.None,
+            vscode13.TreeItemCollapsibleState.None,
             "storageFile",
             "storage",
             bucket
@@ -9247,10 +9581,10 @@ ID: ${result.id ?? "(unknown)"}`;
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to load files";
-      return [new DataTreeItem(message, vscode12.TreeItemCollapsibleState.None, "message")];
+      return [new DataTreeItem(message, vscode13.TreeItemCollapsibleState.None, "message")];
     }
     return [
-      new DataTreeItem("Failed to load files", vscode12.TreeItemCollapsibleState.None, "message")
+      new DataTreeItem("Failed to load files", vscode13.TreeItemCollapsibleState.None, "message")
     ];
   }
   formatFileSize(bytes) {
@@ -9259,6 +9593,203 @@ ID: ${result.id ?? "(unknown)"}`;
     if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
     return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
   }
+  loadQueueSections(queueName) {
+    const messagesItem = new DataTreeItem(
+      "Messages",
+      vscode13.TreeItemCollapsibleState.Collapsed,
+      "queueSection",
+      "queue",
+      queueName
+    );
+    messagesItem.contextValue = "queueSection-messages";
+    messagesItem.description = `${this.MESSAGE_PAGE_SIZE} latest`;
+    const dlqItem = new DataTreeItem(
+      "Dead Letter Queue",
+      vscode13.TreeItemCollapsibleState.Collapsed,
+      "queueSection",
+      "queue",
+      queueName
+    );
+    dlqItem.contextValue = "queueSection-dlq";
+    dlqItem.description = `${this.MESSAGE_PAGE_SIZE} latest`;
+    const destItem = new DataTreeItem(
+      "Destinations",
+      vscode13.TreeItemCollapsibleState.Collapsed,
+      "queueSection",
+      "queue",
+      queueName
+    );
+    destItem.contextValue = "queueSection-destinations";
+    return [messagesItem, dlqItem, destItem];
+  }
+  async loadQueueMessages(queueName) {
+    const cli = getCliClient();
+    const currentLimit = this.messageLimits.get(queueName) || this.MESSAGE_PAGE_SIZE;
+    try {
+      const result = await cli.listQueueMessages(queueName, { limit: currentLimit });
+      if (result.success && result.data?.data?.messages) {
+        const messages = result.data.data.messages;
+        const total = result.data.data.total || messages.length;
+        if (messages.length === 0) {
+          return [
+            new DataTreeItem("No messages", vscode13.TreeItemCollapsibleState.None, "message")
+          ];
+        }
+        const items = messages.map((msg) => {
+          const item = new DataTreeItem(
+            msg.id.substring(0, 16) + "...",
+            vscode13.TreeItemCollapsibleState.None,
+            "queueMessage",
+            "queue",
+            queueName
+          );
+          item.contextValue = "queueMessage";
+          item.description = msg.state || "";
+          item.tooltip = [
+            `ID: ${msg.id}`,
+            `Offset: ${msg.offset}`,
+            `State: ${msg.state || "unknown"}`,
+            msg.created_at ? `Created: ${new Date(msg.created_at).toLocaleString()}` : ""
+          ].filter(Boolean).join("\n");
+          item.messageId = msg.id;
+          return item;
+        });
+        if (messages.length < total) {
+          const remaining = total - messages.length;
+          const loadMoreItem = new DataTreeItem(
+            `Load ${Math.min(remaining, this.MESSAGE_PAGE_SIZE)} More... (${remaining} remaining)`,
+            vscode13.TreeItemCollapsibleState.None,
+            "message",
+            "queue",
+            queueName
+          );
+          loadMoreItem.contextValue = "loadMoreMessages";
+          items.push(loadMoreItem);
+        }
+        return items;
+      }
+      return [
+        new DataTreeItem(
+          this.getErrorMessage(result.error, "messages"),
+          vscode13.TreeItemCollapsibleState.None,
+          "message"
+        )
+      ];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load messages";
+      return [new DataTreeItem(message, vscode13.TreeItemCollapsibleState.None, "message")];
+    }
+  }
+  async loadDlqMessages(queueName) {
+    const cli = getCliClient();
+    const currentLimit = this.dlqLimits.get(queueName) || this.MESSAGE_PAGE_SIZE;
+    try {
+      const result = await cli.listDlqMessages(queueName, { limit: currentLimit });
+      if (result.success && result.data?.messages) {
+        const messages = result.data.messages;
+        const total = result.data.total || messages.length;
+        if (messages.length === 0) {
+          return [
+            new DataTreeItem(
+              "No DLQ messages",
+              vscode13.TreeItemCollapsibleState.None,
+              "message"
+            )
+          ];
+        }
+        const items = messages.map((msg) => {
+          const item = new DataTreeItem(
+            msg.id.substring(0, 16) + "...",
+            vscode13.TreeItemCollapsibleState.None,
+            "dlqMessage",
+            "queue",
+            queueName
+          );
+          item.contextValue = "dlqMessage";
+          item.description = `${msg.delivery_attempts} attempts`;
+          item.tooltip = [
+            `ID: ${msg.id}`,
+            `Offset: ${msg.offset}`,
+            `Attempts: ${msg.delivery_attempts}`,
+            `Reason: ${msg.failure_reason || "Unknown"}`,
+            `Moved: ${new Date(msg.moved_at).toLocaleString()}`
+          ].join("\n");
+          item.messageId = msg.id;
+          return item;
+        });
+        if (messages.length < total) {
+          const remaining = total - messages.length;
+          const loadMoreItem = new DataTreeItem(
+            `Load ${Math.min(remaining, this.MESSAGE_PAGE_SIZE)} More... (${remaining} remaining)`,
+            vscode13.TreeItemCollapsibleState.None,
+            "message",
+            "queue",
+            queueName
+          );
+          loadMoreItem.contextValue = "loadMoreDlqMessages";
+          items.push(loadMoreItem);
+        }
+        return items;
+      }
+      return [
+        new DataTreeItem(
+          this.getErrorMessage(result.error, "DLQ"),
+          vscode13.TreeItemCollapsibleState.None,
+          "message"
+        )
+      ];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load DLQ";
+      return [new DataTreeItem(message, vscode13.TreeItemCollapsibleState.None, "message")];
+    }
+  }
+  async loadQueueDestinations(queueName) {
+    const cli = getCliClient();
+    try {
+      const result = await cli.listQueueDestinations(queueName);
+      if (result.success && result.data?.destinations) {
+        if (result.data.destinations.length === 0) {
+          return [
+            new DataTreeItem(
+              "No destinations",
+              vscode13.TreeItemCollapsibleState.None,
+              "message"
+            )
+          ];
+        }
+        return result.data.destinations.map((dest) => {
+          const item = new DataTreeItem(
+            dest.url,
+            vscode13.TreeItemCollapsibleState.None,
+            "queueDestination",
+            "queue",
+            queueName
+          );
+          item.contextValue = "queueDestination";
+          item.description = dest.enabled ? "enabled" : "disabled";
+          item.tooltip = [
+            `ID: ${dest.id}`,
+            `Type: ${dest.destination_type}`,
+            `URL: ${dest.url}`,
+            `Enabled: ${dest.enabled ? "Yes" : "No"}`,
+            `Created: ${new Date(dest.created_at).toLocaleString()}`
+          ].join("\n");
+          item.destinationId = dest.id;
+          return item;
+        });
+      }
+      return [
+        new DataTreeItem(
+          this.getErrorMessage(result.error, "destinations"),
+          vscode13.TreeItemCollapsibleState.None,
+          "message"
+        )
+      ];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load destinations";
+      return [new DataTreeItem(message, vscode13.TreeItemCollapsibleState.None, "message")];
+    }
+  }
   dispose() {
     this._onDidChangeTreeData.dispose();
   }
@@ -9267,7 +9798,7 @@ ID: ${result.id ?? "(unknown)"}`;
 // src/features/dataExplorer/index.ts
 function registerDataExplorer(context) {
   const provider = new DataTreeDataProvider();
-  const treeView = vscode13.window.createTreeView("agentuity.data", {
+  const treeView = vscode14.window.createTreeView("agentuity.data", {
     treeDataProvider: provider,
     showCollapseAll: true
   });
@@ -9284,6 +9815,14 @@ function registerDataExplorer(context) {
       await openStorageFile(item);
     } else if (item.itemType === "streamItem" && item.streamInfo) {
       await openStreamDetails(item);
+    } else if (item.itemType === "queueMessage" && item.parentName) {
+      await vscode14.commands.executeCommand("agentuity.queue.viewMessage", item);
+    } else if (item.itemType === "queueItem" && item.queueInfo) {
+      await openQueueDetails(item);
+    } else if (item.itemType === "message" && item.contextValue === "loadMoreMessages" && item.parentName) {
+      provider.loadMoreMessages(item.parentName);
+    } else if (item.itemType === "message" && item.contextValue === "loadMoreDlqMessages" && item.parentName) {
+      provider.loadMoreDlqMessages(item.parentName);
     }
   });
   const authSub = onAuthStatusChanged(() => {
@@ -9293,7 +9832,7 @@ function registerDataExplorer(context) {
     provider.refresh();
   });
   context.subscriptions.push(
-    vscode13.commands.registerCommand(
+    vscode14.commands.registerCommand(
       "agentuity.db.copyConnectionString",
       async (item) => {
         if (item?.itemType === "database") {
@@ -9303,7 +9842,7 @@ function registerDataExplorer(context) {
     )
   );
   context.subscriptions.push(
-    vscode13.commands.registerCommand(
+    vscode14.commands.registerCommand(
       "agentuity.db.openConnectionUri",
       async (item) => {
         if (item?.itemType !== "database") return;
@@ -9311,40 +9850,40 @@ function registerDataExplorer(context) {
         const name2 = String(item.label);
         const result = await cli.getDatabase(name2);
         if (!result.success || !result.data) {
-          vscode13.window.showErrorMessage(
+          vscode14.window.showErrorMessage(
             `Failed to get database "${name2}": ${result.error ?? "Unknown error"}`
           );
           return;
         }
         try {
-          await vscode13.env.openExternal(vscode13.Uri.parse(result.data.url));
+          await vscode14.env.openExternal(vscode14.Uri.parse(result.data.url));
         } catch {
-          vscode13.window.showErrorMessage(`Could not open URI: ${result.data.url}`);
+          vscode14.window.showErrorMessage(`Could not open URI: ${result.data.url}`);
         }
       }
     )
   );
   context.subscriptions.push(
-    vscode13.commands.registerCommand("agentuity.db.viewLogs", async (item) => {
+    vscode14.commands.registerCommand("agentuity.db.viewLogs", async (item) => {
       if (item?.itemType !== "database") return;
       const cli = getCliClient();
       const name2 = String(item.label);
-      await vscode13.window.withProgress(
+      await vscode14.window.withProgress(
         {
-          location: vscode13.ProgressLocation.Notification,
+          location: vscode14.ProgressLocation.Notification,
           title: `Fetching database logs for "${name2}"...`,
           cancellable: false
         },
         async () => {
           const result = await cli.getDbLogs(name2, { limit: 100 });
           if (!result.success || !result.data) {
-            vscode13.window.showErrorMessage(
+            vscode14.window.showErrorMessage(
               `Failed to fetch database logs: ${result.error ?? "Unknown error"}`
             );
             return;
           }
           if (result.data.length === 0) {
-            vscode13.window.showInformationMessage("No logs found for this database");
+            vscode14.window.showInformationMessage("No logs found for this database");
             return;
           }
           const logContent = result.data.map((log2) => {
@@ -9358,48 +9897,412 @@ function registerDataExplorer(context) {
           }).join("\n\n");
           await openReadonlyDocument(logContent, "log", `db-logs-${name2}`);
         }
-      );
-    })
+      );
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.vector.search", async () => {
+      const cli = getCliClient();
+      const namespace = await vscode14.window.showInputBox({
+        prompt: "Vector namespace",
+        placeHolder: "e.g., default, products, knowledge-base",
+        ignoreFocusOut: true
+      });
+      if (!namespace) return;
+      const query = await vscode14.window.showInputBox({
+        prompt: "Search query (text to find similar vectors)",
+        placeHolder: "Enter search text...",
+        ignoreFocusOut: true
+      });
+      if (!query) return;
+      const result = await cli.vectorSearch(namespace, query);
+      if (!result.success || !result.data) {
+        vscode14.window.showErrorMessage(
+          `Vector search failed: ${result.error ?? "Unknown error"}`
+        );
+        return;
+      }
+      provider.addVectorSearchGroup({
+        id: `${namespace}:${Date.now()}`,
+        label: `"${query}" in ${namespace}`,
+        namespace,
+        query,
+        results: result.data.results ?? []
+      });
+      vscode14.window.showInformationMessage(
+        `Found ${result.data.count} result${result.data.count !== 1 ? "s" : ""}`
+      );
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.vector.clearSearches", () => {
+      provider.clearVectorSearchGroups();
+      vscode14.window.showInformationMessage("Cleared vector search results");
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.create", async () => {
+      const cli = getCliClient();
+      const queueType = await vscode14.window.showQuickPick(
+        [
+          {
+            label: "Worker",
+            description: "Point-to-point queue with acknowledgment",
+            value: "worker"
+          },
+          {
+            label: "Pub/Sub",
+            description: "Publish-subscribe with multiple consumers",
+            value: "pubsub"
+          }
+        ],
+        { placeHolder: "Select queue type" }
+      );
+      if (!queueType) return;
+      const name2 = await vscode14.window.showInputBox({
+        prompt: "Queue name",
+        placeHolder: "my-queue",
+        validateInput: (value) => {
+          if (!value || value.trim() === "") return "Queue name is required";
+          if (!/^[a-zA-Z0-9_-]+$/.test(value))
+            return "Only letters, numbers, dashes, and underscores allowed";
+          return null;
+        }
+      });
+      if (!name2) return;
+      const ttlStr = await vscode14.window.showInputBox({
+        prompt: "Message TTL in seconds (optional)",
+        placeHolder: "86400 (24 hours)"
+      });
+      const ttl = ttlStr ? parseInt(ttlStr, 10) : void 0;
+      const result = await cli.createQueue(queueType.value, name2, {
+        ttl
+      });
+      if (result.success) {
+        vscode14.window.showInformationMessage(`Created ${queueType.value} queue: ${name2}`);
+        provider.refresh();
+      } else {
+        vscode14.window.showErrorMessage(`Failed to create queue: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.delete", async (item) => {
+      if (item?.itemType !== "queueItem" || !item.queueInfo) return;
+      const queueName = item.queueInfo.name;
+      const confirm = await vscode14.window.showInputBox({
+        prompt: `Type "${queueName}" to confirm deletion`,
+        placeHolder: queueName
+      });
+      if (confirm !== queueName) {
+        vscode14.window.showWarningMessage("Queue deletion cancelled");
+        return;
+      }
+      const cli = getCliClient();
+      const result = await cli.deleteQueue(queueName);
+      if (result.success) {
+        vscode14.window.showInformationMessage(`Deleted queue: ${queueName}`);
+        provider.refresh();
+      } else {
+        vscode14.window.showErrorMessage(`Failed to delete queue: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.pause", async (item) => {
+      if (item?.itemType !== "queueItem" || !item.queueInfo) return;
+      const cli = getCliClient();
+      const result = await cli.pauseQueue(item.queueInfo.name);
+      if (result.success) {
+        vscode14.window.showInformationMessage(`Paused queue: ${item.queueInfo.name}`);
+        provider.refresh();
+      } else {
+        vscode14.window.showErrorMessage(`Failed to pause queue: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.resume", async (item) => {
+      if (item?.itemType !== "queueItem" || !item.queueInfo) return;
+      const cli = getCliClient();
+      const result = await cli.resumeQueue(item.queueInfo.name);
+      if (result.success) {
+        vscode14.window.showInformationMessage(`Resumed queue: ${item.queueInfo.name}`);
+        provider.refresh();
+      } else {
+        vscode14.window.showErrorMessage(`Failed to resume queue: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.publish", async (item) => {
+      let queueName;
+      if (item?.itemType === "queueItem" && item.queueInfo) {
+        queueName = item.queueInfo.name;
+      } else {
+        const cli2 = getCliClient();
+        const queuesResult = await cli2.listQueues();
+        if (!queuesResult.success || !queuesResult.data?.queues?.length) {
+          vscode14.window.showErrorMessage("No queues available");
+          return;
+        }
+        const queuePick = await vscode14.window.showQuickPick(
+          queuesResult.data.queues.map((q) => ({ label: q.name, description: q.queue_type })),
+          { placeHolder: "Select queue" }
+        );
+        if (!queuePick) return;
+        queueName = queuePick.label;
+      }
+      const payloadStr = await vscode14.window.showInputBox({
+        prompt: "Message payload (JSON)",
+        placeHolder: '{"key": "value"}',
+        validateInput: (value) => {
+          if (!value) return "Payload is required";
+          try {
+            JSON.parse(value);
+            return null;
+          } catch {
+            return "Invalid JSON";
+          }
+        }
+      });
+      if (!payloadStr) return;
+      const metadataStr = await vscode14.window.showInputBox({
+        prompt: "Message metadata (JSON, optional)",
+        placeHolder: '{"priority": "high"}',
+        validateInput: (value) => {
+          if (!value) return null;
+          try {
+            JSON.parse(value);
+            return null;
+          } catch {
+            return "Invalid JSON";
+          }
+        }
+      });
+      const cli = getCliClient();
+      const result = await cli.publishQueueMessage(queueName, payloadStr, {
+        metadata: metadataStr || void 0
+      });
+      if (result.success && result.data) {
+        vscode14.window.showInformationMessage(`Published message: ${result.data.id}`);
+        provider.refresh();
+      } else {
+        vscode14.window.showErrorMessage(`Failed to publish message: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.viewMessage", async (item) => {
+      if (item?.itemType !== "queueMessage" || !item.parentName) return;
+      const messageId = item.messageId;
+      if (!messageId) return;
+      const cli = getCliClient();
+      const result = await cli.getQueueMessage(item.parentName, messageId);
+      if (result.success && result.data?.message) {
+        const msg = result.data.message;
+        const content = JSON.stringify(
+          {
+            id: msg.id,
+            queue_id: msg.queue_id,
+            offset: msg.offset,
+            state: msg.state,
+            delivery_attempts: msg.delivery_attempts,
+            partition_key: msg.partition_key,
+            idempotency_key: msg.idempotency_key,
+            published_at: msg.published_at,
+            created_at: msg.created_at,
+            delivered_at: msg.delivered_at,
+            acknowledged_at: msg.acknowledged_at,
+            expires_at: msg.expires_at,
+            payload: msg.payload,
+            metadata: msg.metadata
+          },
+          null,
+          2
+        );
+        await openReadonlyDocument(
+          content,
+          "json",
+          `queue-message-${messageId.substring(0, 8)}`
+        );
+      } else {
+        vscode14.window.showErrorMessage(`Failed to get message: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand(
+      "agentuity.queue.copyMessageId",
+      async (item) => {
+        if (item?.itemType !== "queueMessage" && item?.itemType !== "dlqMessage") return;
+        const messageId = item.messageId;
+        if (!messageId) return;
+        await vscode14.env.clipboard.writeText(messageId);
+        vscode14.window.showInformationMessage("Message ID copied to clipboard");
+      }
+    )
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand(
+      "agentuity.queue.refreshMessages",
+      async (item) => {
+        let queueName;
+        if (item?.itemType === "queueItem" && item.queueInfo) {
+          queueName = item.queueInfo.name;
+        } else if (item?.itemType === "queueSection" && item.parentName) {
+          queueName = item.parentName;
+        }
+        if (queueName) {
+          provider.refreshQueueMessages(queueName);
+          vscode14.window.showInformationMessage(`Refreshed messages for queue: ${queueName}`);
+        }
+      }
+    )
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.dlq.replay", async (item) => {
+      if (item?.itemType !== "dlqMessage" || !item.parentName) return;
+      const messageId = item.messageId;
+      if (!messageId) return;
+      const cli = getCliClient();
+      const result = await cli.replayDlqMessage(item.parentName, messageId);
+      if (result.success) {
+        vscode14.window.showInformationMessage(`Replayed message: ${messageId}`);
+        provider.refreshQueueMessages(item.parentName);
+      } else {
+        vscode14.window.showErrorMessage(`Failed to replay message: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand("agentuity.queue.dlq.purge", async (item) => {
+      let queueName;
+      if (item?.itemType === "queueSection" && item.parentName && item.label === "Dead Letter Queue") {
+        queueName = item.parentName;
+      } else if (item?.itemType === "queueItem" && item.queueInfo) {
+        queueName = item.queueInfo.name;
+      } else {
+        return;
+      }
+      const confirm = await vscode14.window.showInputBox({
+        prompt: `Type "purge ${queueName}" to confirm DLQ purge`,
+        placeHolder: `purge ${queueName}`
+      });
+      if (confirm !== `purge ${queueName}`) {
+        vscode14.window.showWarningMessage("DLQ purge cancelled");
+        return;
+      }
+      const cli = getCliClient();
+      const result = await cli.purgeDlq(queueName);
+      if (result.success) {
+        vscode14.window.showInformationMessage(`Purged DLQ for: ${queueName}`);
+        provider.refreshQueueMessages(queueName);
+      } else {
+        vscode14.window.showErrorMessage(`Failed to purge DLQ: ${result.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand(
+      "agentuity.queue.destination.create",
+      async (item) => {
+        let queueName;
+        if (item?.itemType === "queueSection" && item.parentName && item.label === "Destinations") {
+          queueName = item.parentName;
+        } else if (item?.itemType === "queueItem" && item.queueInfo) {
+          queueName = item.queueInfo.name;
+        } else {
+          return;
+        }
+        const url = await vscode14.window.showInputBox({
+          prompt: "Webhook URL",
+          placeHolder: "https://example.com/webhook",
+          validateInput: (value) => {
+            if (!value) return "URL is required";
+            try {
+              new URL(value);
+              return null;
+            } catch {
+              return "Invalid URL";
+            }
+          }
+        });
+        if (!url) return;
+        const method = await vscode14.window.showQuickPick(["POST", "PUT", "PATCH"], {
+          placeHolder: "HTTP method (default: POST)"
+        });
+        const cli = getCliClient();
+        const result = await cli.createQueueDestination(queueName, url, {
+          method: method || "POST"
+        });
+        if (result.success) {
+          vscode14.window.showInformationMessage(
+            `Created destination: ${url} - refresh to see updated state`
+          );
+        } else {
+          vscode14.window.showErrorMessage(`Failed to create destination: ${result.error}`);
+        }
+      }
+    )
+  );
+  context.subscriptions.push(
+    vscode14.commands.registerCommand(
+      "agentuity.queue.destination.delete",
+      async (item) => {
+        if (item?.itemType !== "queueDestination" || !item.parentName) return;
+        const destinationId = item.destinationId;
+        if (!destinationId) return;
+        const confirm = await vscode14.window.showWarningMessage(
+          `Delete destination: ${item.label}?`,
+          { modal: true },
+          "Delete"
+        );
+        if (confirm !== "Delete") return;
+        const cli = getCliClient();
+        const result = await cli.deleteQueueDestination(item.parentName, destinationId);
+        if (result.success) {
+          vscode14.window.showInformationMessage(
+            "Destination deleted - refresh to see updated state"
+          );
+        } else {
+          vscode14.window.showErrorMessage(`Failed to delete destination: ${result.error}`);
+        }
+      }
+    )
   );
   context.subscriptions.push(
-    vscode13.commands.registerCommand("agentuity.vector.search", async () => {
-      const cli = getCliClient();
-      const namespace = await vscode13.window.showInputBox({
-        prompt: "Vector namespace",
-        placeHolder: "e.g., default, products, knowledge-base",
-        ignoreFocusOut: true
-      });
-      if (!namespace) return;
-      const query = await vscode13.window.showInputBox({
-        prompt: "Search query (text to find similar vectors)",
-        placeHolder: "Enter search text...",
-        ignoreFocusOut: true
-      });
-      if (!query) return;
-      const result = await cli.vectorSearch(namespace, query);
-      if (!result.success || !result.data) {
-        vscode13.window.showErrorMessage(
-          `Vector search failed: ${result.error ?? "Unknown error"}`
-        );
-        return;
+    vscode14.commands.registerCommand(
+      "agentuity.queue.destination.toggle",
+      async (item) => {
+        if (item?.itemType !== "queueDestination" || !item.parentName) return;
+        const destinationId = item.destinationId;
+        if (!destinationId) return;
+        const isEnabled = item.description === "enabled";
+        const cli = getCliClient();
+        const result = await cli.updateQueueDestination(item.parentName, destinationId, {
+          enabled: !isEnabled,
+          disabled: isEnabled
+        });
+        if (result.success) {
+          vscode14.window.showInformationMessage(
+            `Destination ${isEnabled ? "disabled" : "enabled"} - refresh to see updated state`
+          );
+        } else {
+          vscode14.window.showErrorMessage(`Failed to update destination: ${result.error}`);
+        }
       }
-      provider.addVectorSearchGroup({
-        id: `${namespace}:${Date.now()}`,
-        label: `"${query}" in ${namespace}`,
-        namespace,
-        query,
-        results: result.data.results ?? []
-      });
-      vscode13.window.showInformationMessage(
-        `Found ${result.data.count} result${result.data.count !== 1 ? "s" : ""}`
-      );
-    })
+    )
   );
   context.subscriptions.push(
-    vscode13.commands.registerCommand("agentuity.vector.clearSearches", () => {
-      provider.clearVectorSearchGroups();
-      vscode13.window.showInformationMessage("Cleared vector search results");
-    })
+    vscode14.commands.registerCommand(
+      "agentuity.queue.destination.copyUrl",
+      async (item) => {
+        if (item?.itemType !== "queueDestination") return;
+        await vscode14.env.clipboard.writeText(item.label);
+        vscode14.window.showInformationMessage("URL copied to clipboard");
+      }
+    )
   );
   context.subscriptions.push(treeView, authSub, projectSub, { dispose: () => provider.dispose() });
   return provider;
@@ -9409,13 +10312,13 @@ async function copyDatabaseConnectionString(item) {
   const name2 = String(item.label);
   const result = await cli.getDatabase(name2);
   if (!result.success || !result.data) {
-    vscode13.window.showErrorMessage(
+    vscode14.window.showErrorMessage(
       `Failed to get database "${name2}": ${result.error ?? "Unknown error"}`
     );
     return;
   }
-  await vscode13.env.clipboard.writeText(result.data.url);
-  vscode13.window.showInformationMessage(`Copied connection string for "${name2}" to clipboard`);
+  await vscode14.env.clipboard.writeText(result.data.url);
+  vscode14.window.showInformationMessage(`Copied connection string for "${name2}" to clipboard`);
 }
 async function openVectorDocument(item) {
   const cli = getCliClient();
@@ -9423,11 +10326,11 @@ async function openVectorDocument(item) {
   const namespace = item.parentName;
   const result = await cli.getVector(namespace, key);
   if (!result.success || !result.data) {
-    vscode13.window.showErrorMessage(`Failed to get vector: ${result.error}`);
+    vscode14.window.showErrorMessage(`Failed to get vector: ${result.error}`);
     return;
   }
   if (!result.data.exists) {
-    vscode13.window.showWarningMessage(`Vector "${key}" does not exist`);
+    vscode14.window.showWarningMessage(`Vector "${key}" does not exist`);
     return;
   }
   const lines = [];
@@ -9450,12 +10353,12 @@ async function openDataValue(item) {
   const result = await cli.getKvValue(namespace, key);
   if (result.success && result.data) {
     if (!result.data.exists) {
-      vscode13.window.showWarningMessage(`Key "${key}" does not exist`);
+      vscode14.window.showWarningMessage(`Key "${key}" does not exist`);
       return;
     }
     await openContent(result.data.data, result.data.contentType);
   } else {
-    vscode13.window.showErrorMessage(`Failed to get value: ${result.error}`);
+    vscode14.window.showErrorMessage(`Failed to get value: ${result.error}`);
   }
 }
 async function openStorageFile(item) {
@@ -9464,7 +10367,7 @@ async function openStorageFile(item) {
   const bucket = item.parentName;
   const result = await cli.getStorageFileMetadata(bucket, filename);
   if (!result.success || !result.data) {
-    vscode13.window.showErrorMessage(`Failed to get file metadata: ${result.error}`);
+    vscode14.window.showErrorMessage(`Failed to get file metadata: ${result.error}`);
     return;
   }
   const lines = [];
@@ -9497,6 +10400,33 @@ async function openStreamDetails(item) {
   );
   await openReadonlyDocument(content, "json", `stream-${stream.name}`);
 }
+async function openQueueDetails(item) {
+  const cli = getCliClient();
+  const queueName = item.queueInfo.name;
+  const result = await cli.getQueue(queueName);
+  if (result.success && result.data?.queue) {
+    const queue = result.data.queue;
+    const content = JSON.stringify(
+      {
+        name: queue.name,
+        id: queue.id,
+        queue_type: queue.queue_type,
+        description: queue.description,
+        message_count: queue.message_count,
+        dlq_count: queue.dlq_count,
+        next_offset: queue.next_offset,
+        paused_at: queue.paused_at,
+        created_at: queue.created_at,
+        updated_at: queue.updated_at
+      },
+      null,
+      2
+    );
+    await openReadonlyDocument(content, "json", `queue-${queueName}`);
+  } else {
+    vscode14.window.showErrorMessage(`Failed to get queue details: ${result.error}`);
+  }
+}
 function formatFileSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -9556,11 +10486,11 @@ function bytesToString(data) {
 }
 
 // src/features/deploymentExplorer/index.ts
-var vscode15 = __toESM(require("vscode"));
+var vscode16 = __toESM(require("vscode"));
 
 // src/features/deploymentExplorer/deploymentTreeData.ts
-var vscode14 = __toESM(require("vscode"));
-var DeploymentTreeItem = class extends vscode14.TreeItem {
+var vscode15 = __toESM(require("vscode"));
+var DeploymentTreeItem = class extends vscode15.TreeItem {
   constructor(label, collapsibleState, itemType, deploymentData) {
     super(label, collapsibleState);
     this.label = label;
@@ -9574,23 +10504,23 @@ var DeploymentTreeItem = class extends vscode14.TreeItem {
     switch (this.itemType) {
       case "deployment":
         if (this.deploymentData?.active) {
-          this.iconPath = new vscode14.ThemeIcon(
+          this.iconPath = new vscode15.ThemeIcon(
             "rocket",
-            new vscode14.ThemeColor("charts.green")
+            new vscode15.ThemeColor("charts.green")
           );
         } else {
-          this.iconPath = new vscode14.ThemeIcon("history");
+          this.iconPath = new vscode15.ThemeIcon("history");
         }
         break;
       case "info":
       case "message":
-        this.iconPath = new vscode14.ThemeIcon("info");
+        this.iconPath = new vscode15.ThemeIcon("info");
         break;
     }
   }
 };
 var DeploymentTreeDataProvider = class {
-  _onDidChangeTreeData = new vscode14.EventEmitter();
+  _onDidChangeTreeData = new vscode15.EventEmitter();
   onDidChangeTreeData = this._onDidChangeTreeData.event;
   deployments = [];
   loading = false;
@@ -9613,7 +10543,7 @@ var DeploymentTreeDataProvider = class {
       return [
         new DeploymentTreeItem(
           "Checking auth...",
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -9622,7 +10552,7 @@ var DeploymentTreeDataProvider = class {
       return [
         new DeploymentTreeItem(
           "CLI not installed",
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -9631,7 +10561,7 @@ var DeploymentTreeDataProvider = class {
       return [
         new DeploymentTreeItem(
           "Not logged in",
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -9640,21 +10570,21 @@ var DeploymentTreeDataProvider = class {
       return [
         new DeploymentTreeItem(
           "No project detected",
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "message"
         )
       ];
     }
     if (this.loading) {
       return [
-        new DeploymentTreeItem("Loading...", vscode14.TreeItemCollapsibleState.None, "message")
+        new DeploymentTreeItem("Loading...", vscode15.TreeItemCollapsibleState.None, "message")
       ];
     }
     if (this.error) {
       return [
         new DeploymentTreeItem(
           `Error: ${this.error}`,
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -9666,7 +10596,7 @@ var DeploymentTreeDataProvider = class {
       return [
         new DeploymentTreeItem(
           "No deployments found",
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -9675,7 +10605,7 @@ var DeploymentTreeDataProvider = class {
       const label = dep.active ? `${dep.id} (active)` : dep.id;
       const item = new DeploymentTreeItem(
         label,
-        vscode14.TreeItemCollapsibleState.Collapsed,
+        vscode15.TreeItemCollapsibleState.Collapsed,
         "deployment",
         dep
       );
@@ -9689,14 +10619,14 @@ var DeploymentTreeDataProvider = class {
     items.push(
       new DeploymentTreeItem(
         `State: ${dep.state || "unknown"}`,
-        vscode14.TreeItemCollapsibleState.None,
+        vscode15.TreeItemCollapsibleState.None,
         "info"
       )
     );
     items.push(
       new DeploymentTreeItem(
         `Created: ${new Date(dep.createdAt).toLocaleString()}`,
-        vscode14.TreeItemCollapsibleState.None,
+        vscode15.TreeItemCollapsibleState.None,
         "info"
       )
     );
@@ -9704,7 +10634,7 @@ var DeploymentTreeDataProvider = class {
       items.push(
         new DeploymentTreeItem(
           `Message: ${dep.message}`,
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "info"
         )
       );
@@ -9713,7 +10643,7 @@ var DeploymentTreeDataProvider = class {
       items.push(
         new DeploymentTreeItem(
           `Tags: ${dep.tags.join(", ")}`,
-          vscode14.TreeItemCollapsibleState.None,
+          vscode15.TreeItemCollapsibleState.None,
           "info"
         )
       );
@@ -9768,7 +10698,7 @@ var DeploymentTreeDataProvider = class {
 // src/features/deploymentExplorer/index.ts
 function registerDeploymentExplorer(context) {
   const provider = new DeploymentTreeDataProvider();
-  const treeView = vscode15.window.createTreeView("agentuity.deployments", {
+  const treeView = vscode16.window.createTreeView("agentuity.deployments", {
     treeDataProvider: provider,
     showCollapseAll: true
   });
@@ -9786,7 +10716,7 @@ function registerDeploymentExplorer(context) {
     void provider.forceRefresh();
   });
   context.subscriptions.push(
-    vscode15.commands.registerCommand(
+    vscode16.commands.registerCommand(
       "agentuity.deployment.viewLogs",
       async (item) => {
         if (item?.deploymentData) {
@@ -9796,7 +10726,7 @@ function registerDeploymentExplorer(context) {
     )
   );
   context.subscriptions.push(
-    vscode15.commands.registerCommand(
+    vscode16.commands.registerCommand(
       "agentuity.deployment.showDetails",
       async (item) => {
         if (item?.deploymentData) {
@@ -9815,14 +10745,14 @@ async function showDeploymentDetails(deploymentId) {
     const content = JSON.stringify(result.data, null, 2);
     await openReadonlyDocument(content, "json", `deployment-${deploymentId.substring(0, 8)}`);
   } else {
-    vscode15.window.showErrorMessage(`Failed to get deployment details: ${result.error}`);
+    vscode16.window.showErrorMessage(`Failed to get deployment details: ${result.error}`);
   }
 }
 async function viewDeploymentLogs(deploymentId) {
   const cli = getCliClient();
-  await vscode15.window.withProgress(
+  await vscode16.window.withProgress(
     {
-      location: vscode15.ProgressLocation.Notification,
+      location: vscode16.ProgressLocation.Notification,
       title: "Fetching deployment logs...",
       cancellable: false
     },
@@ -9830,7 +10760,7 @@ async function viewDeploymentLogs(deploymentId) {
       const result = await cli.getDeploymentLogs(deploymentId, 100);
       if (result.success && result.data) {
         if (result.data.length === 0) {
-          vscode15.window.showInformationMessage("No logs found for this deployment");
+          vscode16.window.showInformationMessage("No logs found for this deployment");
           return;
         }
         const logContent = result.data.map((log2) => {
@@ -9843,21 +10773,21 @@ async function viewDeploymentLogs(deploymentId) {
           `deployment-logs-${deploymentId.substring(0, 8)}`
         );
       } else {
-        vscode15.window.showErrorMessage(`Failed to fetch logs: ${result.error}`);
+        vscode16.window.showErrorMessage(`Failed to fetch logs: ${result.error}`);
       }
     }
   );
 }
 
 // src/features/sandboxExplorer/index.ts
-var vscode18 = __toESM(require("vscode"));
+var vscode19 = __toESM(require("vscode"));
 var path13 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var fs14 = __toESM(require("fs"));
 
 // src/features/sandboxExplorer/sandboxTreeData.ts
-var vscode16 = __toESM(require("vscode"));
-var SandboxTreeItem = class extends vscode16.TreeItem {
+var vscode17 = __toESM(require("vscode"));
+var SandboxTreeItem = class extends vscode17.TreeItem {
   constructor(label, collapsibleState, itemType, sandboxData, fileData, snapshotData, executionData, parentSandboxId, categoryType, linkedData, filePath, region) {
     super(label, collapsibleState);
     this.label = label;
@@ -9899,7 +10829,7 @@ var SandboxTreeItem = class extends vscode16.TreeItem {
         this.setupCreateItem();
         break;
       case "message":
-        this.iconPath = new vscode16.ThemeIcon("info");
+        this.iconPath = new vscode17.ThemeIcon("info");
         this.contextValue = "message";
         break;
     }
@@ -9908,7 +10838,7 @@ var SandboxTreeItem = class extends vscode16.TreeItem {
     if (!this.sandboxData) return;
     const status = this.sandboxData.status;
     const isLinked = this.linkedData !== void 0;
-    this.iconPath = new vscode16.ThemeIcon(this.getStatusIcon(status), this.getStatusColor(status));
+    this.iconPath = new vscode17.ThemeIcon(this.getStatusIcon(status), this.getStatusColor(status));
     let contextValue = `sandbox.${status}`;
     if (isLinked) {
       contextValue += ".linked";
@@ -9945,13 +10875,13 @@ var SandboxTreeItem = class extends vscode16.TreeItem {
   getStatusColor(status) {
     switch (status) {
       case "idle":
-        return new vscode16.ThemeColor("charts.blue");
+        return new vscode17.ThemeColor("charts.blue");
       case "running":
-        return new vscode16.ThemeColor("charts.green");
+        return new vscode17.ThemeColor("charts.green");
       case "failed":
-        return new vscode16.ThemeColor("charts.red");
+        return new vscode17.ThemeColor("charts.red");
       case "terminated":
-        return new vscode16.ThemeColor("disabledForeground");
+        return new vscode17.ThemeColor("disabledForeground");
       default:
         return void 0;
     }
@@ -9997,25 +10927,25 @@ var SandboxTreeItem = class extends vscode16.TreeItem {
   setupCategoryItem() {
     switch (this.categoryType) {
       case "files":
-        this.iconPath = new vscode16.ThemeIcon("folder");
+        this.iconPath = new vscode17.ThemeIcon("folder");
         this.contextValue = "sandboxCategory.files";
         break;
       case "snapshots":
-        this.iconPath = new vscode16.ThemeIcon("device-camera");
+        this.iconPath = new vscode17.ThemeIcon("device-camera");
         this.contextValue = "sandboxCategory.snapshots";
         break;
       case "executions":
-        this.iconPath = new vscode16.ThemeIcon("terminal");
+        this.iconPath = new vscode17.ThemeIcon("terminal");
         this.contextValue = "sandboxCategory.executions";
         break;
     }
   }
   setupFileItem() {
     if (this.itemType === "directory") {
-      this.iconPath = new vscode16.ThemeIcon("folder");
+      this.iconPath = new vscode17.ThemeIcon("folder");
       this.contextValue = "sandboxFile.directory";
     } else {
-      this.iconPath = new vscode16.ThemeIcon("file");
+      this.iconPath = new vscode17.ThemeIcon("file");
       this.contextValue = "sandboxFile";
       this.command = {
         command: "agentuity.sandbox.viewFile",
@@ -10038,7 +10968,7 @@ Modified: ${this.fileData.modTime}`;
   }
   setupSnapshotItem() {
     if (!this.snapshotData) return;
-    this.iconPath = new vscode16.ThemeIcon("device-camera");
+    this.iconPath = this.snapshotData.public ? new vscode17.ThemeIcon("globe") : new vscode17.ThemeIcon("device-camera");
     if (this.snapshotData.tag) {
       this.contextValue = "snapshot.tagged";
       this.description = `[${this.snapshotData.tag}] ${this.snapshotData.fileCount} files`;
@@ -10046,12 +10976,18 @@ Modified: ${this.fileData.modTime}`;
       this.contextValue = "snapshot";
       this.description = `${this.snapshotData.fileCount} files`;
     }
+    if (this.snapshotData.public) {
+      this.description = `\u{1F310} ${this.description}`;
+    }
     this.tooltip = [
+      this.snapshotData.fullName ? `Name: ${this.snapshotData.fullName}` : "",
       `ID: ${this.snapshotData.snapshotId}`,
       `Size: ${this.formatFileSize(this.snapshotData.sizeBytes)}`,
       `Files: ${this.snapshotData.fileCount}`,
       `Created: ${new Date(this.snapshotData.createdAt).toLocaleString()}`,
       this.snapshotData.tag ? `Tag: ${this.snapshotData.tag}` : "",
+      this.snapshotData.public ? "\u{1F310} Public snapshot" : "",
+      this.snapshotData.orgSlug ? `Org: @${this.snapshotData.orgSlug}` : "",
       "",
       "Click to view snapshot details"
     ].filter(Boolean).join("\n");
@@ -10062,7 +10998,7 @@ Modified: ${this.fileData.modTime}`;
     };
   }
   setupSnapshotFileItem() {
-    this.iconPath = new vscode16.ThemeIcon("file");
+    this.iconPath = new vscode17.ThemeIcon("file");
     this.contextValue = "snapshotFile";
     if (this.fileData) {
       this.description = this.formatFileSize(this.fileData.size);
@@ -10082,7 +11018,7 @@ Click to view file (readonly)`;
     const status = this.executionData.status;
     const icon = this.getExecutionIcon(status);
     const color = this.getExecutionColor(status);
-    this.iconPath = new vscode16.ThemeIcon(icon, color);
+    this.iconPath = new vscode17.ThemeIcon(icon, color);
     this.contextValue = status === "running" ? "execution.running" : "execution";
     const parts = [];
     if (this.executionData.exitCode !== void 0) {
@@ -10127,18 +11063,18 @@ Click to view file (readonly)`;
   getExecutionColor(status) {
     switch (status) {
       case "completed":
-        return new vscode16.ThemeColor("charts.green");
+        return new vscode17.ThemeColor("charts.green");
       case "failed":
       case "timeout":
-        return new vscode16.ThemeColor("charts.red");
+        return new vscode17.ThemeColor("charts.red");
       case "cancelled":
-        return new vscode16.ThemeColor("charts.orange");
+        return new vscode17.ThemeColor("charts.orange");
       default:
         return void 0;
     }
   }
   setupCreateItem() {
-    this.iconPath = new vscode16.ThemeIcon("add");
+    this.iconPath = new vscode17.ThemeIcon("add");
     this.contextValue = "createSandbox";
     this.command = {
       command: "agentuity.sandbox.create",
@@ -10147,7 +11083,7 @@ Click to view file (readonly)`;
   }
 };
 var SandboxTreeDataProvider = class {
-  _onDidChangeTreeData = new vscode16.EventEmitter();
+  _onDidChangeTreeData = new vscode17.EventEmitter();
   onDidChangeTreeData = this._onDidChangeTreeData.event;
   sandboxes = [];
   loading = false;
@@ -10195,7 +11131,7 @@ var SandboxTreeDataProvider = class {
       return [
         new SandboxTreeItem(
           "Checking auth...",
-          vscode16.TreeItemCollapsibleState.None,
+          vscode17.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -10204,26 +11140,26 @@ var SandboxTreeDataProvider = class {
       return [
         new SandboxTreeItem(
           "CLI not installed",
-          vscode16.TreeItemCollapsibleState.None,
+          vscode17.TreeItemCollapsibleState.None,
           "message"
         )
       ];
     }
     if (authStatus.state === "unauthenticated") {
       return [
-        new SandboxTreeItem("Not logged in", vscode16.TreeItemCollapsibleState.None, "message")
+        new SandboxTreeItem("Not logged in", vscode17.TreeItemCollapsibleState.None, "message")
       ];
     }
     if (this.loading) {
       return [
-        new SandboxTreeItem("Loading...", vscode16.TreeItemCollapsibleState.None, "message")
+        new SandboxTreeItem("Loading...", vscode17.TreeItemCollapsibleState.None, "message")
       ];
     }
     if (this.error) {
       return [
         new SandboxTreeItem(
           `Error: ${this.error}`,
-          vscode16.TreeItemCollapsibleState.None,
+          vscode17.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -10243,7 +11179,7 @@ var SandboxTreeDataProvider = class {
       items.push(
         new SandboxTreeItem(
           displayName,
-          vscode16.TreeItemCollapsibleState.Collapsed,
+          vscode17.TreeItemCollapsibleState.Collapsed,
           "sandbox",
           sandbox,
           void 0,
@@ -10258,7 +11194,7 @@ var SandboxTreeDataProvider = class {
     items.push(
       new SandboxTreeItem(
         "Create Sandbox",
-        vscode16.TreeItemCollapsibleState.None,
+        vscode17.TreeItemCollapsibleState.None,
         "createSandbox"
       )
     );
@@ -10266,7 +11202,7 @@ var SandboxTreeDataProvider = class {
       return [
         new SandboxTreeItem(
           "No sandboxes found",
-          vscode16.TreeItemCollapsibleState.None,
+          vscode17.TreeItemCollapsibleState.None,
           "message"
         ),
         items[0]
@@ -10278,7 +11214,7 @@ var SandboxTreeDataProvider = class {
     return [
       new SandboxTreeItem(
         "Files",
-        vscode16.TreeItemCollapsibleState.Collapsed,
+        vscode17.TreeItemCollapsibleState.Collapsed,
         "category",
         sandbox,
         void 0,
@@ -10290,7 +11226,7 @@ var SandboxTreeDataProvider = class {
       ),
       new SandboxTreeItem(
         "Snapshots",
-        vscode16.TreeItemCollapsibleState.Collapsed,
+        vscode17.TreeItemCollapsibleState.Collapsed,
         "category",
         sandbox,
         void 0,
@@ -10302,7 +11238,7 @@ var SandboxTreeDataProvider = class {
       ),
       new SandboxTreeItem(
         "Executions",
-        vscode16.TreeItemCollapsibleState.Collapsed,
+        vscode17.TreeItemCollapsibleState.Collapsed,
         "category",
         sandbox,
         void 0,
@@ -10325,7 +11261,7 @@ var SandboxTreeDataProvider = class {
         return [
           new SandboxTreeItem(
             `Error: ${result.error || "Failed to list files"}`,
-            vscode16.TreeItemCollapsibleState.None,
+            vscode17.TreeItemCollapsibleState.None,
             "message"
           )
         ];
@@ -10345,7 +11281,7 @@ var SandboxTreeDataProvider = class {
       }
     });
     if (directChildren.length === 0) {
-      return [new SandboxTreeItem("(empty)", vscode16.TreeItemCollapsibleState.None, "message")];
+      return [new SandboxTreeItem("(empty)", vscode17.TreeItemCollapsibleState.None, "message")];
     }
     const sorted = [...directChildren].sort((a, b) => {
       if (a.isDir && !b.isDir) return -1;
@@ -10355,7 +11291,7 @@ var SandboxTreeDataProvider = class {
     return sorted.map((file) => {
       return new SandboxTreeItem(
         file.name,
-        file.isDir ? vscode16.TreeItemCollapsibleState.Collapsed : vscode16.TreeItemCollapsibleState.None,
+        file.isDir ? vscode17.TreeItemCollapsibleState.Collapsed : vscode17.TreeItemCollapsibleState.None,
         file.isDir ? "directory" : "file",
         void 0,
         file,
@@ -10381,7 +11317,7 @@ var SandboxTreeDataProvider = class {
         return [
           new SandboxTreeItem(
             `Error: ${result.error || "Failed to list snapshots"}`,
-            vscode16.TreeItemCollapsibleState.None,
+            vscode17.TreeItemCollapsibleState.None,
             "message"
           )
         ];
@@ -10390,14 +11326,14 @@ var SandboxTreeDataProvider = class {
     const snapshots = this.snapshotsCache.get(sandboxId) || [];
     if (snapshots.length === 0) {
       return [
-        new SandboxTreeItem("No snapshots", vscode16.TreeItemCollapsibleState.None, "message")
+        new SandboxTreeItem("No snapshots", vscode17.TreeItemCollapsibleState.None, "message")
       ];
     }
     return snapshots.map(
       (snap) => new SandboxTreeItem(
         snap.tag || snap.snapshotId.slice(0, 12),
         // Make expandable to show files
-        vscode16.TreeItemCollapsibleState.Collapsed,
+        vscode17.TreeItemCollapsibleState.Collapsed,
         "snapshot",
         void 0,
         void 0,
@@ -10418,7 +11354,7 @@ var SandboxTreeDataProvider = class {
       return [
         new SandboxTreeItem(
           `Error: ${result.error || "Failed to get snapshot"}`,
-          vscode16.TreeItemCollapsibleState.None,
+          vscode17.TreeItemCollapsibleState.None,
           "message"
         )
       ];
@@ -10427,7 +11363,7 @@ var SandboxTreeDataProvider = class {
     const files = snapshotData.files || [];
     if (files.length === 0) {
       return [
-        new SandboxTreeItem("(no files)", vscode16.TreeItemCollapsibleState.None, "message")
+        new SandboxTreeItem("(no files)", vscode17.TreeItemCollapsibleState.None, "message")
       ];
     }
     const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
@@ -10435,7 +11371,7 @@ var SandboxTreeDataProvider = class {
       const fileName = file.path.split("/").pop() || file.path;
       return new SandboxTreeItem(
         fileName,
-        vscode16.TreeItemCollapsibleState.None,
+        vscode17.TreeItemCollapsibleState.None,
         "snapshotFile",
         void 0,
         {
@@ -10466,7 +11402,7 @@ var SandboxTreeDataProvider = class {
         return [
           new SandboxTreeItem(
             `Error: ${result.error || "Failed to list executions"}`,
-            vscode16.TreeItemCollapsibleState.None,
+            vscode17.TreeItemCollapsibleState.None,
             "message"
           )
         ];
@@ -10475,13 +11411,13 @@ var SandboxTreeDataProvider = class {
     const executions = this.executionsCache.get(sandboxId) || [];
     if (executions.length === 0) {
       return [
-        new SandboxTreeItem("No executions", vscode16.TreeItemCollapsibleState.None, "message")
+        new SandboxTreeItem("No executions", vscode17.TreeItemCollapsibleState.None, "message")
       ];
     }
     return executions.map(
       (exec2) => new SandboxTreeItem(
         exec2.executionId.slice(0, 12),
-        vscode16.TreeItemCollapsibleState.None,
+        vscode17.TreeItemCollapsibleState.None,
         "execution",
         void 0,
         void 0,
@@ -10542,19 +11478,19 @@ var SandboxTreeDataProvider = class {
 };
 
 // src/features/sandboxExplorer/statusBar.ts
-var vscode17 = __toESM(require("vscode"));
+var vscode18 = __toESM(require("vscode"));
 var statusBarItem;
 var syncStatusItem;
 var hideTimeoutId;
 function createSandboxStatusBar(context) {
-  statusBarItem = vscode17.window.createStatusBarItem(vscode17.StatusBarAlignment.Left, 50);
+  statusBarItem = vscode18.window.createStatusBarItem(vscode18.StatusBarAlignment.Left, 50);
   statusBarItem.command = "agentuity.sandbox.showQuickPick";
   context.subscriptions.push(statusBarItem);
-  syncStatusItem = vscode17.window.createStatusBarItem(vscode17.StatusBarAlignment.Left, 49);
+  syncStatusItem = vscode18.window.createStatusBarItem(vscode18.StatusBarAlignment.Left, 49);
   syncStatusItem.hide();
   context.subscriptions.push(syncStatusItem);
   context.subscriptions.push(
-    vscode17.commands.registerCommand("agentuity.sandbox.showQuickPick", showSandboxQuickPick)
+    vscode18.commands.registerCommand("agentuity.sandbox.showQuickPick", showSandboxQuickPick)
   );
   updateStatusBar();
 }
@@ -10600,7 +11536,7 @@ function showSyncProgress(message) {
   }
   syncStatusItem.text = `$(sync~spin) ${message}`;
   syncStatusItem.tooltip = message;
-  syncStatusItem.backgroundColor = new vscode17.ThemeColor("statusBarItem.warningBackground");
+  syncStatusItem.backgroundColor = new vscode18.ThemeColor("statusBarItem.warningBackground");
   syncStatusItem.show();
 }
 function hideSyncProgress() {
@@ -10628,7 +11564,7 @@ function showSyncError(error) {
   }
   syncStatusItem.text = "$(error) Sync failed";
   syncStatusItem.tooltip = `Sync failed: ${error}`;
-  syncStatusItem.backgroundColor = new vscode17.ThemeColor("statusBarItem.errorBackground");
+  syncStatusItem.backgroundColor = new vscode18.ThemeColor("statusBarItem.errorBackground");
   syncStatusItem.show();
   clearHideTimeout();
   hideTimeoutId = setTimeout(() => {
@@ -10642,7 +11578,7 @@ async function showSandboxQuickPick() {
   if (linked.length > 0) {
     items.push({
       label: "Linked Sandboxes",
-      kind: vscode17.QuickPickItemKind.Separator,
+      kind: vscode18.QuickPickItemKind.Separator,
       action: ""
     });
     for (const sandbox of linked) {
@@ -10658,7 +11594,7 @@ async function showSandboxQuickPick() {
     }
     items.push({
       label: "Actions",
-      kind: vscode17.QuickPickItemKind.Separator,
+      kind: vscode18.QuickPickItemKind.Separator,
       action: ""
     });
   }
@@ -10689,7 +11625,7 @@ async function showSandboxQuickPick() {
       action: "explorer"
     });
   }
-  const selected = await vscode17.window.showQuickPick(items, {
+  const selected = await vscode18.window.showQuickPick(items, {
     placeHolder: "Select a sandbox or action",
     title: "Agentuity Sandboxes"
   });
@@ -10703,10 +11639,10 @@ async function showSandboxQuickPick() {
       }
       break;
     case "create":
-      await vscode17.commands.executeCommand("agentuity.sandbox.create");
+      await vscode18.commands.executeCommand("agentuity.sandbox.create");
       break;
     case "link":
-      await vscode17.commands.executeCommand("agentuity.sandbox.link");
+      await vscode18.commands.executeCommand("agentuity.sandbox.link");
       break;
     case "sync":
       await promptAndSync();
@@ -10715,7 +11651,7 @@ async function showSandboxQuickPick() {
       await promptAndExec();
       break;
     case "explorer":
-      await vscode17.commands.executeCommand("agentuity.sandboxes.focus");
+      await vscode18.commands.executeCommand("agentuity.sandboxes.focus");
       break;
   }
 }
@@ -10754,7 +11690,7 @@ async function showSandboxActions(sandboxId) {
       action: "unlink"
     }
   ];
-  const selected = await vscode17.window.showQuickPick(items, {
+  const selected = await vscode18.window.showQuickPick(items, {
     placeHolder: `Actions for ${name2}`,
     title: `Sandbox: ${name2}`
   });
@@ -10763,19 +11699,19 @@ async function showSandboxActions(sandboxId) {
   }
   switch (selected.action) {
     case "sync":
-      await vscode17.commands.executeCommand("agentuity.sandbox.sync", { sandboxId });
+      await vscode18.commands.executeCommand("agentuity.sandbox.sync", { sandboxId });
       break;
     case "exec":
       await promptAndExecForSandbox(sandboxId);
       break;
     case "snapshot":
-      await vscode17.commands.executeCommand("agentuity.sandbox.snapshot.create", { sandboxId });
+      await vscode18.commands.executeCommand("agentuity.sandbox.snapshot.create", { sandboxId });
       break;
     case "browse":
-      await vscode17.commands.executeCommand("agentuity.sandboxes.focus");
+      await vscode18.commands.executeCommand("agentuity.sandboxes.focus");
       break;
     case "unlink":
-      await vscode17.commands.executeCommand("agentuity.sandbox.unlink", { sandboxId });
+      await vscode18.commands.executeCommand("agentuity.sandbox.unlink", { sandboxId });
       break;
   }
 }
@@ -10783,7 +11719,7 @@ async function promptAndSync() {
   const manager = getSandboxManager();
   const linked = manager.getLinkedSandboxes();
   if (linked.length === 0) {
-    vscode17.window.showWarningMessage("No sandboxes linked. Link a sandbox first.");
+    vscode18.window.showWarningMessage("No sandboxes linked. Link a sandbox first.");
     return;
   }
   let sandboxId;
@@ -10795,7 +11731,7 @@ async function promptAndSync() {
       description: s.sandboxId,
       sandboxId: s.sandboxId
     }));
-    const selected = await vscode17.window.showQuickPick(items, {
+    const selected = await vscode18.window.showQuickPick(items, {
       placeHolder: "Select sandbox to sync to"
     });
     if (!selected) {
@@ -10803,13 +11739,13 @@ async function promptAndSync() {
     }
     sandboxId = selected.sandboxId;
   }
-  await vscode17.commands.executeCommand("agentuity.sandbox.sync", { sandboxId });
+  await vscode18.commands.executeCommand("agentuity.sandbox.sync", { sandboxId });
 }
 async function promptAndExec() {
   const manager = getSandboxManager();
   const linked = manager.getLinkedSandboxes();
   if (linked.length === 0) {
-    vscode17.window.showWarningMessage("No sandboxes linked. Link a sandbox first.");
+    vscode18.window.showWarningMessage("No sandboxes linked. Link a sandbox first.");
     return;
   }
   let sandboxId;
@@ -10821,7 +11757,7 @@ async function promptAndExec() {
       description: s.sandboxId,
       sandboxId: s.sandboxId
     }));
-    const selected = await vscode17.window.showQuickPick(items, {
+    const selected = await vscode18.window.showQuickPick(items, {
       placeHolder: "Select sandbox to execute in"
     });
     if (!selected) {
@@ -10832,14 +11768,14 @@ async function promptAndExec() {
   await promptAndExecForSandbox(sandboxId);
 }
 async function promptAndExecForSandbox(sandboxId) {
-  const command = await vscode17.window.showInputBox({
+  const command = await vscode18.window.showInputBox({
     prompt: "Enter command to execute",
     placeHolder: "npm test"
   });
   if (!command) {
     return;
   }
-  await vscode17.commands.executeCommand("agentuity.sandbox.exec", { sandboxId, command });
+  await vscode18.commands.executeCommand("agentuity.sandbox.exec", { sandboxId, command });
 }
 function clearHideTimeout() {
   if (hideTimeoutId) {
@@ -10868,7 +11804,7 @@ var UPLOAD_DEBOUNCE_MS = 1e3;
 function registerSandboxExplorer(context) {
   initSandboxManager(context);
   const provider = new SandboxTreeDataProvider();
-  const treeView = vscode18.window.createTreeView("agentuity.sandboxes", {
+  const treeView = vscode19.window.createTreeView("agentuity.sandboxes", {
     treeDataProvider: provider,
     showCollapseAll: true
   });
@@ -10882,7 +11818,7 @@ function registerSandboxExplorer(context) {
     updateStatusBar();
   });
   registerCommands(context, provider);
-  saveListener = vscode18.workspace.onDidSaveTextDocument((doc) => {
+  saveListener = vscode19.workspace.onDidSaveTextDocument((doc) => {
     const mapping = sandboxFileMap.get(doc.uri.fsPath);
     if (mapping) {
       const existingTimer = uploadDebounceTimers.get(doc.uri.fsPath);
@@ -10896,7 +11832,7 @@ function registerSandboxExplorer(context) {
       uploadDebounceTimers.set(doc.uri.fsPath, timer);
     }
   });
-  const closeListener = vscode18.workspace.onDidCloseTextDocument((doc) => {
+  const closeListener = vscode19.workspace.onDidCloseTextDocument((doc) => {
     sandboxFileMap.delete(doc.uri.fsPath);
     const timer = uploadDebounceTimers.get(doc.uri.fsPath);
     if (timer) {
@@ -10927,18 +11863,18 @@ function registerSandboxExplorer(context) {
 }
 function registerCommands(context, provider) {
   context.subscriptions.push(
-    vscode18.commands.registerCommand("agentuity.sandbox.create", async () => {
+    vscode19.commands.registerCommand("agentuity.sandbox.create", async () => {
       await createSandbox(provider);
     })
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.createFromSnapshot",
       async (item) => {
         if (item?.snapshotData) {
           await createSandboxFromSnapshot(item.snapshotData.snapshotId, provider);
         } else {
-          const snapshotId = await vscode18.window.showInputBox({
+          const snapshotId = await vscode19.window.showInputBox({
             prompt: "Enter snapshot ID or tag",
             placeHolder: "snp_xxx or tag-name"
           });
@@ -10950,7 +11886,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.delete",
       async (item) => {
         if (!item?.sandboxData) return;
@@ -10959,13 +11895,13 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand("agentuity.sandbox.link", async (item) => {
+    vscode19.commands.registerCommand("agentuity.sandbox.link", async (item) => {
       if (!item?.sandboxData) return;
       await linkSandbox(item.sandboxData.sandboxId, provider);
     })
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.unlink",
       async (item) => {
         if (!item?.sandboxData) return;
@@ -10974,14 +11910,14 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand("agentuity.sandbox.sync", async (item) => {
+    vscode19.commands.registerCommand("agentuity.sandbox.sync", async (item) => {
       let sandboxId;
       if (item?.sandboxData) {
         sandboxId = item.sandboxData.sandboxId;
       } else {
         const linked = getSandboxManager().getLinkedSandboxes();
         if (linked.length === 0) {
-          vscode18.window.showWarningMessage(
+          vscode19.window.showWarningMessage(
             "No sandbox linked to this workspace. Link a sandbox first."
           );
           return;
@@ -10989,7 +11925,7 @@ function registerCommands(context, provider) {
         if (linked.length === 1) {
           sandboxId = linked[0].sandboxId;
         } else {
-          const picked = await vscode18.window.showQuickPick(
+          const picked = await vscode19.window.showQuickPick(
             linked.map((l) => ({
               label: l.name || l.sandboxId,
               description: l.sandboxId,
@@ -11008,7 +11944,7 @@ function registerCommands(context, provider) {
     })
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.exec",
       async (itemOrOptions) => {
         let sandboxId;
@@ -11025,7 +11961,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.viewFile",
       async (item) => {
         if (!item?.parentSandboxId || !item?.filePath) return;
@@ -11034,7 +11970,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.download",
       async (item) => {
         if (!item?.parentSandboxId || !item?.filePath) return;
@@ -11047,7 +11983,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.deleteFile",
       async (item) => {
         if (!item?.parentSandboxId || !item?.filePath) return;
@@ -11061,7 +11997,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.createFile",
       async (item) => {
         const sandboxId = item?.parentSandboxId || item?.sandboxData?.sandboxId;
@@ -11077,7 +12013,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.createFolder",
       async (item) => {
         const sandboxId = item?.parentSandboxId || item?.sandboxData?.sandboxId;
@@ -11093,17 +12029,17 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.copyPath",
       async (item) => {
         if (!item?.filePath) return;
-        await vscode18.env.clipboard.writeText(item.filePath);
-        vscode18.window.showInformationMessage(`Copied: ${item.filePath}`);
+        await vscode19.env.clipboard.writeText(item.filePath);
+        vscode19.window.showInformationMessage(`Copied: ${item.filePath}`);
       }
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.viewExecution",
       async (item) => {
         if (!item?.executionData) return;
@@ -11112,7 +12048,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.setEnv",
       async (item) => {
         if (!item?.sandboxData) return;
@@ -11121,7 +12057,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.viewEnv",
       async (item) => {
         if (!item?.sandboxData) return;
@@ -11130,7 +12066,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.syncEnvFile",
       async (item) => {
         if (!item?.sandboxData) return;
@@ -11139,7 +12075,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.snapshot.create",
       async (item) => {
         if (!item?.sandboxData) return;
@@ -11148,7 +12084,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.snapshot.delete",
       async (item) => {
         if (!item?.snapshotData) return;
@@ -11157,7 +12093,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.snapshot.tag",
       async (item) => {
         if (!item?.snapshotData) return;
@@ -11166,7 +12102,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.snapshot.viewDetails",
       async (item) => {
         if (!item?.snapshotData) return;
@@ -11175,7 +12111,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand(
+    vscode19.commands.registerCommand(
       "agentuity.sandbox.snapshot.viewFile",
       async (item) => {
         if (!item?.snapshotData || !item?.filePath) return;
@@ -11184,7 +12120,7 @@ function registerCommands(context, provider) {
     )
   );
   context.subscriptions.push(
-    vscode18.commands.registerCommand("agentuity.sandbox.upload", async (uri) => {
+    vscode19.commands.registerCommand("agentuity.sandbox.upload", async (uri) => {
       if (!uri) return;
       await uploadToSandbox(uri);
     })
@@ -11192,16 +12128,16 @@ function registerCommands(context, provider) {
 }
 async function pickSandboxRuntime() {
   const cli = getCliClient();
-  const result = await vscode18.window.withProgress(
+  const result = await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Loading runtimes...",
       cancellable: false
     },
     async () => cli.sandboxRuntimeList({ limit: 50 })
   );
   if (!result.success || !result.data || !result.data.runtimes.length) {
-    const choice = await vscode18.window.showQuickPick(
+    const choice = await vscode19.window.showQuickPick(
       [
         { label: "Use default runtime (base:latest)", runtime: void 0 },
         { label: "Cancel", runtime: "__cancel__" }
@@ -11220,18 +12156,18 @@ async function pickSandboxRuntime() {
     runtime: rt.name,
     runtimeId: rt.id
   }));
-  const picked = await vscode18.window.showQuickPick(items, {
+  const picked = await vscode19.window.showQuickPick(items, {
     placeHolder: "Select a sandbox runtime"
   });
   if (!picked) return void 0;
   return { runtime: picked.runtime, runtimeId: picked.runtimeId };
 }
 async function createSandbox(provider) {
-  const config = vscode18.workspace.getConfiguration("agentuity");
+  const config = vscode19.workspace.getConfiguration("agentuity");
   const defaultMemory = config.get("sandbox.defaultMemory", "512Mi");
   const defaultCpu = config.get("sandbox.defaultCpu", "500m");
   const defaultNetwork = config.get("sandbox.defaultNetwork", false);
-  const mode = await vscode18.window.showQuickPick(
+  const mode = await vscode19.window.showQuickPick(
     [
       { label: "Quick Create", description: "bun:1 runtime with default settings" },
       { label: "Custom", description: "Configure runtime, resources and options" }
@@ -11241,13 +12177,13 @@ async function createSandbox(provider) {
   if (!mode) return;
   let options = {};
   if (mode.label === "Custom") {
-    const name2 = await vscode18.window.showInputBox({
+    const name2 = await vscode19.window.showInputBox({
       prompt: "Sandbox name (optional)",
       placeHolder: "e.g., my-feature-env"
     });
     if (name2 === void 0) return;
     options.name = name2 || void 0;
-    const description = await vscode18.window.showInputBox({
+    const description = await vscode19.window.showInputBox({
       prompt: "Sandbox description (optional)",
       placeHolder: "e.g., Sandbox for feature-xyz integration tests"
     });
@@ -11257,21 +12193,21 @@ async function createSandbox(provider) {
     if (runtimeSelection === void 0) return;
     options.runtime = runtimeSelection.runtime;
     options.runtimeId = runtimeSelection.runtimeId;
-    const memory = await vscode18.window.showInputBox({
+    const memory = await vscode19.window.showInputBox({
       prompt: "Memory limit",
       value: defaultMemory,
       placeHolder: "e.g., 512Mi, 1Gi, 2Gi"
     });
     if (memory === void 0) return;
     options.memory = memory || void 0;
-    const cpu = await vscode18.window.showInputBox({
+    const cpu = await vscode19.window.showInputBox({
       prompt: "CPU limit (millicores)",
       value: defaultCpu,
       placeHolder: "e.g., 500m, 1000m"
     });
     if (cpu === void 0) return;
     options.cpu = cpu || void 0;
-    const network = await vscode18.window.showQuickPick(
+    const network = await vscode19.window.showQuickPick(
       [
         { label: "Disabled", description: "No outbound network access", value: false },
         { label: "Enabled", description: "Allow outbound network access", value: true }
@@ -11280,7 +12216,7 @@ async function createSandbox(provider) {
     );
     if (!network) return;
     options.network = network.value;
-    const deps = await vscode18.window.showInputBox({
+    const deps = await vscode19.window.showInputBox({
       prompt: "APT packages to install (optional)",
       placeHolder: "e.g., python3 nodejs git"
     });
@@ -11295,9 +12231,9 @@ async function createSandbox(provider) {
       network: defaultNetwork
     };
   }
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Creating sandbox...",
       cancellable: false
     },
@@ -11308,32 +12244,32 @@ async function createSandbox(provider) {
         const info = result.data;
         const displayName = info.name || info.sandboxId.slice(0, 12);
         const runtimeDisplay = info.runtime?.name ?? info.runtime?.id ?? "bun:1";
-        vscode18.window.showInformationMessage(
+        vscode19.window.showInformationMessage(
           `Sandbox "${displayName}" created with runtime ${runtimeDisplay}`
         );
         await provider.forceRefresh();
       } else {
-        vscode18.window.showErrorMessage(`Failed to create sandbox: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to create sandbox: ${result.error}`);
       }
     }
   );
 }
 async function createSandboxFromSnapshot(snapshotId, provider) {
-  const name2 = await vscode18.window.showInputBox({
+  const name2 = await vscode19.window.showInputBox({
     prompt: "Sandbox name (optional)",
     placeHolder: "e.g., my-feature-env"
   });
   if (name2 === void 0) return;
-  const description = await vscode18.window.showInputBox({
+  const description = await vscode19.window.showInputBox({
     prompt: "Sandbox description (optional)",
     placeHolder: "e.g., Restored from snapshot for testing"
   });
   if (description === void 0) return;
   const runtimeSelection = await pickSandboxRuntime();
   if (runtimeSelection === void 0) return;
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Creating sandbox from snapshot...",
       cancellable: false
     },
@@ -11350,26 +12286,26 @@ async function createSandboxFromSnapshot(snapshotId, provider) {
         const info = result.data;
         const displayName = info.name || info.sandboxId.slice(0, 12);
         const runtimeDisplay = info.runtime?.name ?? info.runtime?.id ?? "bun:1";
-        vscode18.window.showInformationMessage(
+        vscode19.window.showInformationMessage(
           `Sandbox "${displayName}" created from snapshot with runtime ${runtimeDisplay}`
         );
         await provider.forceRefresh();
       } else {
-        vscode18.window.showErrorMessage(`Failed to create sandbox: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to create sandbox: ${result.error}`);
       }
     }
   );
 }
 async function deleteSandbox(sandboxId, provider) {
-  const confirm = await vscode18.window.showWarningMessage(
+  const confirm = await vscode19.window.showWarningMessage(
     `Are you sure you want to delete sandbox ${sandboxId}?`,
     { modal: true },
     "Delete"
   );
   if (confirm !== "Delete") return;
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Deleting sandbox...",
       cancellable: false
     },
@@ -11381,20 +12317,20 @@ async function deleteSandbox(sandboxId, provider) {
           await getSandboxManager().unlinkSandbox(sandboxId);
         } catch {
         }
-        vscode18.window.showInformationMessage("Sandbox deleted");
+        vscode19.window.showInformationMessage("Sandbox deleted");
         await provider.forceRefresh();
       } else {
-        vscode18.window.showErrorMessage(`Failed to delete sandbox: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to delete sandbox: ${result.error}`);
       }
     }
   );
 }
 async function linkSandbox(sandboxId, provider) {
-  const name2 = await vscode18.window.showInputBox({
+  const name2 = await vscode19.window.showInputBox({
     prompt: "Enter a friendly name for this sandbox (optional)",
     placeHolder: "my-dev-sandbox"
   });
-  const remotePath = await vscode18.window.showInputBox({
+  const remotePath = await vscode19.window.showInputBox({
     prompt: "Remote path for synced files",
     value: DEFAULT_SANDBOX_PATH,
     placeHolder: DEFAULT_SANDBOX_PATH
@@ -11405,10 +12341,10 @@ async function linkSandbox(sandboxId, provider) {
       name: name2 || void 0,
       remotePath: remotePath || DEFAULT_SANDBOX_PATH
     });
-    vscode18.window.showInformationMessage(`Sandbox linked to workspace`);
+    vscode19.window.showInformationMessage(`Sandbox linked to workspace`);
     provider.refresh();
   } catch (err) {
-    vscode18.window.showErrorMessage(
+    vscode19.window.showErrorMessage(
       `Failed to link sandbox: ${err instanceof Error ? err.message : "Unknown error"}`
     );
   }
@@ -11416,19 +12352,19 @@ async function linkSandbox(sandboxId, provider) {
 async function unlinkSandbox(sandboxId, provider) {
   try {
     await getSandboxManager().unlinkSandbox(sandboxId);
-    vscode18.window.showInformationMessage("Sandbox unlinked from workspace");
+    vscode19.window.showInformationMessage("Sandbox unlinked from workspace");
     provider.refresh();
   } catch (err) {
-    vscode18.window.showErrorMessage(
+    vscode19.window.showErrorMessage(
       `Failed to unlink sandbox: ${err instanceof Error ? err.message : "Unknown error"}`
     );
   }
 }
 async function syncToSandbox(sandboxId, provider) {
   showSyncProgress("Syncing to sandbox...");
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Syncing files to sandbox...",
       cancellable: false
     },
@@ -11436,7 +12372,7 @@ async function syncToSandbox(sandboxId, provider) {
       try {
         const manager = getSandboxManager();
         const result = await manager.syncToSandbox(sandboxId);
-        vscode18.window.showInformationMessage(
+        vscode19.window.showInformationMessage(
           `Synced ${result.filesUploaded} files (${formatBytes(result.bytesTransferred)}) in ${(result.duration / 1e3).toFixed(1)}s`
         );
         showSyncSuccess(result.filesUploaded, result.bytesTransferred);
@@ -11445,14 +12381,14 @@ async function syncToSandbox(sandboxId, provider) {
         updateStatusBar();
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : "Unknown error";
-        vscode18.window.showErrorMessage(`Failed to sync: ${errorMessage}`);
+        vscode19.window.showErrorMessage(`Failed to sync: ${errorMessage}`);
         showSyncError(errorMessage);
       }
     }
   );
 }
 async function execInSandbox(sandboxId, prefilledCommand) {
-  const command = prefilledCommand ?? await vscode18.window.showInputBox({
+  const command = prefilledCommand ?? await vscode19.window.showInputBox({
     prompt: "Enter command to execute",
     placeHolder: "npm test"
   });
@@ -11464,9 +12400,9 @@ function executeInTerminal(sandboxId, command) {
   const cliPath = cli.getCliPath();
   let terminal = sandboxTerminals.get(sandboxId);
   if (!terminal || terminal.exitStatus !== void 0) {
-    terminal = vscode18.window.createTerminal({
+    terminal = vscode19.window.createTerminal({
       name: `Sandbox: ${sandboxId.slice(0, 8)}`,
-      iconPath: new vscode18.ThemeIcon("vm")
+      iconPath: new vscode19.ThemeIcon("vm")
     });
     sandboxTerminals.set(sandboxId, terminal);
   }
@@ -11480,9 +12416,9 @@ function disposeTerminals() {
   sandboxTerminals.clear();
 }
 async function viewSandboxFile(sandboxId, filePath) {
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Fetching file...",
       cancellable: false
     },
@@ -11499,10 +12435,10 @@ async function viewSandboxFile(sandboxId, filePath) {
           sandboxId,
           remotePath: fullRemotePath
         });
-        const doc = await vscode18.workspace.openTextDocument(localPath);
-        await vscode18.window.showTextDocument(doc, { preview: false });
+        const doc = await vscode19.workspace.openTextDocument(localPath);
+        await vscode19.window.showTextDocument(doc, { preview: false });
       } else {
-        vscode18.window.showErrorMessage(`Failed to fetch file: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to fetch file: ${result.error}`);
       }
     }
   );
@@ -11511,15 +12447,15 @@ async function uploadSavedFile(sandboxId, localPath, remotePath, provider) {
   const cli = getCliClient();
   const result = await cli.sandboxCpToSandbox(sandboxId, localPath, remotePath, false);
   if (result.success) {
-    vscode18.window.showInformationMessage(`Saved to sandbox: ${path13.basename(remotePath)}`);
+    vscode19.window.showInformationMessage(`Saved to sandbox: ${path13.basename(remotePath)}`);
     provider.clearSandboxCache(sandboxId);
     provider.refresh();
   } else {
-    vscode18.window.showErrorMessage(`Failed to save to sandbox: ${result.error}`);
+    vscode19.window.showErrorMessage(`Failed to save to sandbox: ${result.error}`);
   }
 }
 async function createSandboxFile(sandboxId, parentDir, _provider) {
-  const fileName = await vscode18.window.showInputBox({
+  const fileName = await vscode19.window.showInputBox({
     prompt: "Enter new file name",
     placeHolder: "newfile.ts",
     validateInput: (value) => {
@@ -11542,12 +12478,12 @@ async function createSandboxFile(sandboxId, parentDir, _provider) {
     sandboxId,
     remotePath
   });
-  const doc = await vscode18.workspace.openTextDocument(localPath);
-  await vscode18.window.showTextDocument(doc, { preview: false });
-  vscode18.window.showInformationMessage(`New file will be created at ${remotePath} when you save`);
+  const doc = await vscode19.workspace.openTextDocument(localPath);
+  await vscode19.window.showTextDocument(doc, { preview: false });
+  vscode19.window.showInformationMessage(`New file will be created at ${remotePath} when you save`);
 }
 async function createSandboxFolder(sandboxId, parentDir, provider) {
-  const folderName = await vscode18.window.showInputBox({
+  const folderName = await vscode19.window.showInputBox({
     prompt: "Enter new folder name",
     placeHolder: "newfolder",
     validateInput: (value) => {
@@ -11565,24 +12501,24 @@ async function createSandboxFolder(sandboxId, parentDir, provider) {
   const cli = getCliClient();
   const result = await cli.sandboxMkdir(sandboxId, remotePath, true);
   if (result.success) {
-    vscode18.window.showInformationMessage(`Created folder: ${folderName}`);
+    vscode19.window.showInformationMessage(`Created folder: ${folderName}`);
     provider.clearSandboxCache(sandboxId);
     provider.refresh();
   } else {
-    vscode18.window.showErrorMessage(`Failed to create folder: ${result.error}`);
+    vscode19.window.showErrorMessage(`Failed to create folder: ${result.error}`);
   }
 }
 async function downloadFromSandbox(sandboxId, remotePath, isDirectory) {
-  const defaultUri = vscode18.workspace.workspaceFolders?.[0]?.uri;
-  const saveUri = await vscode18.window.showSaveDialog({
-    defaultUri: defaultUri ? vscode18.Uri.joinPath(defaultUri, path13.basename(remotePath)) : void 0,
+  const defaultUri = vscode19.workspace.workspaceFolders?.[0]?.uri;
+  const saveUri = await vscode19.window.showSaveDialog({
+    defaultUri: defaultUri ? vscode19.Uri.joinPath(defaultUri, path13.basename(remotePath)) : void 0,
     saveLabel: "Download",
     filters: isDirectory ? { Archives: ["tar.gz", "zip"] } : {}
   });
   if (!saveUri) return;
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Downloading...",
       cancellable: false
     },
@@ -11595,15 +12531,15 @@ async function downloadFromSandbox(sandboxId, remotePath, isDirectory) {
         isDirectory
       );
       if (result.success) {
-        vscode18.window.showInformationMessage(`Downloaded to ${saveUri.fsPath}`);
+        vscode19.window.showInformationMessage(`Downloaded to ${saveUri.fsPath}`);
       } else {
-        vscode18.window.showErrorMessage(`Failed to download: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to download: ${result.error}`);
       }
     }
   );
 }
 async function deleteFile(sandboxId, filePath, isDirectory, provider) {
-  const confirm = await vscode18.window.showWarningMessage(
+  const confirm = await vscode19.window.showWarningMessage(
     `Delete ${isDirectory ? "directory" : "file"} ${filePath}?`,
     { modal: true },
     "Delete"
@@ -11612,17 +12548,17 @@ async function deleteFile(sandboxId, filePath, isDirectory, provider) {
   const cli = getCliClient();
   const result = isDirectory ? await cli.sandboxRmdir(sandboxId, filePath, true) : await cli.sandboxRm(sandboxId, filePath);
   if (result.success) {
-    vscode18.window.showInformationMessage(`Deleted ${filePath}`);
+    vscode19.window.showInformationMessage(`Deleted ${filePath}`);
     provider.clearSandboxCache(sandboxId);
     provider.refresh();
   } else {
-    vscode18.window.showErrorMessage(`Failed to delete: ${result.error}`);
+    vscode19.window.showErrorMessage(`Failed to delete: ${result.error}`);
   }
 }
 async function viewExecution(executionId) {
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Fetching execution details...",
       cancellable: false
     },
@@ -11672,7 +12608,7 @@ async function viewExecution(executionId) {
           `execution-${executionId.slice(0, 8)}`
         );
       } else {
-        vscode18.window.showErrorMessage(`Failed to get execution: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to get execution: ${result.error}`);
       }
     }
   );
@@ -11704,7 +12640,7 @@ async function fetchStreamContent(url) {
   });
 }
 async function setEnvVar(sandboxId) {
-  const input = await vscode18.window.showInputBox({
+  const input = await vscode19.window.showInputBox({
     prompt: "Enter environment variable (KEY=value)",
     placeHolder: "MY_VAR=my_value"
   });
@@ -11712,21 +12648,21 @@ async function setEnvVar(sandboxId) {
   const [key, ...valueParts] = input.split("=");
   const value = valueParts.join("=");
   if (!key || value === void 0) {
-    vscode18.window.showErrorMessage("Invalid format. Use KEY=value");
+    vscode19.window.showErrorMessage("Invalid format. Use KEY=value");
     return;
   }
   const cli = getCliClient();
   const result = await cli.sandboxEnvSet(sandboxId, { [key]: value });
   if (result.success) {
-    vscode18.window.showInformationMessage(`Set ${key}=${value}`);
+    vscode19.window.showInformationMessage(`Set ${key}=${value}`);
   } else {
-    vscode18.window.showErrorMessage(`Failed to set env var: ${result.error}`);
+    vscode19.window.showErrorMessage(`Failed to set env var: ${result.error}`);
   }
 }
 async function viewEnv(sandboxId) {
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Fetching environment variables...",
       cancellable: false
     },
@@ -11741,20 +12677,20 @@ async function viewEnv(sandboxId) {
           `sandbox-env-${sandboxId.slice(0, 8)}`
         );
       } else {
-        vscode18.window.showErrorMessage(`Failed to get env: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to get env: ${result.error}`);
       }
     }
   );
 }
 async function syncEnvFile(sandboxId) {
-  const workspaceFolder = vscode18.workspace.workspaceFolders?.[0];
+  const workspaceFolder = vscode19.workspace.workspaceFolders?.[0];
   if (!workspaceFolder) {
-    vscode18.window.showWarningMessage("No workspace folder open");
+    vscode19.window.showWarningMessage("No workspace folder open");
     return;
   }
   const envPath = path13.join(workspaceFolder.uri.fsPath, ".env");
   try {
-    const content = await vscode18.workspace.fs.readFile(vscode18.Uri.file(envPath));
+    const content = await vscode19.workspace.fs.readFile(vscode19.Uri.file(envPath));
     const text = new TextDecoder().decode(content);
     const vars = {};
     for (const line of text.split("\n")) {
@@ -11766,30 +12702,30 @@ async function syncEnvFile(sandboxId) {
       }
     }
     if (Object.keys(vars).length === 0) {
-      vscode18.window.showWarningMessage("No variables found in .env file");
+      vscode19.window.showWarningMessage("No variables found in .env file");
       return;
     }
     const cli = getCliClient();
     const result = await cli.sandboxEnvSet(sandboxId, vars);
     if (result.success) {
-      vscode18.window.showInformationMessage(
+      vscode19.window.showInformationMessage(
         `Synced ${Object.keys(vars).length} environment variables`
       );
     } else {
-      vscode18.window.showErrorMessage(`Failed to sync env: ${result.error}`);
+      vscode19.window.showErrorMessage(`Failed to sync env: ${result.error}`);
     }
   } catch {
-    vscode18.window.showWarningMessage("No .env file found in workspace root");
+    vscode19.window.showWarningMessage("No .env file found in workspace root");
   }
 }
 async function createSnapshot(sandboxId, provider) {
-  const tag = await vscode18.window.showInputBox({
+  const tag = await vscode19.window.showInputBox({
     prompt: "Enter a tag for this snapshot (optional)",
     placeHolder: "v1.0 or latest"
   });
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Creating snapshot...",
       cancellable: false
     },
@@ -11797,19 +12733,19 @@ async function createSnapshot(sandboxId, provider) {
       const cli = getCliClient();
       const result = await cli.snapshotCreate(sandboxId, tag || void 0);
       if (result.success && result.data) {
-        vscode18.window.showInformationMessage(
+        vscode19.window.showInformationMessage(
           `Snapshot created: ${result.data.snapshotId}${tag ? ` [${tag}]` : ""}`
         );
         provider.clearSandboxCache(sandboxId);
         provider.refresh();
       } else {
-        vscode18.window.showErrorMessage(`Failed to create snapshot: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to create snapshot: ${result.error}`);
       }
     }
   );
 }
 async function deleteSnapshot(snapshotId, provider) {
-  const confirm = await vscode18.window.showWarningMessage(
+  const confirm = await vscode19.window.showWarningMessage(
     `Are you sure you want to delete snapshot ${snapshotId}?`,
     { modal: true },
     "Delete"
@@ -11818,14 +12754,14 @@ async function deleteSnapshot(snapshotId, provider) {
   const cli = getCliClient();
   const result = await cli.snapshotDelete(snapshotId);
   if (result.success) {
-    vscode18.window.showInformationMessage("Snapshot deleted");
+    vscode19.window.showInformationMessage("Snapshot deleted");
     await provider.forceRefresh();
   } else {
-    vscode18.window.showErrorMessage(`Failed to delete snapshot: ${result.error}`);
+    vscode19.window.showErrorMessage(`Failed to delete snapshot: ${result.error}`);
   }
 }
 async function tagSnapshot(snapshotId, provider) {
-  const tag = await vscode18.window.showInputBox({
+  const tag = await vscode19.window.showInputBox({
     prompt: "Enter new tag (leave empty to remove tag)",
     placeHolder: "v1.0 or latest"
   });
@@ -11833,16 +12769,16 @@ async function tagSnapshot(snapshotId, provider) {
   const cli = getCliClient();
   const result = await cli.snapshotTag(snapshotId, tag || null);
   if (result.success) {
-    vscode18.window.showInformationMessage(tag ? `Tagged as: ${tag}` : "Tag removed");
+    vscode19.window.showInformationMessage(tag ? `Tagged as: ${tag}` : "Tag removed");
     await provider.forceRefresh();
   } else {
-    vscode18.window.showErrorMessage(`Failed to update tag: ${result.error}`);
+    vscode19.window.showErrorMessage(`Failed to update tag: ${result.error}`);
   }
 }
 async function viewSnapshotDetails(snapshotId) {
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Fetching snapshot details...",
       cancellable: false
     },
@@ -11853,19 +12789,19 @@ async function viewSnapshotDetails(snapshotId) {
         const content = JSON.stringify(result.data, null, 2);
         await openReadonlyDocument(content, "json", `snapshot-${snapshotId.slice(0, 8)}`);
       } else {
-        vscode18.window.showErrorMessage(`Failed to get snapshot: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to get snapshot: ${result.error}`);
       }
     }
   );
 }
 async function viewSnapshotFile(snapshot, filePath) {
   if (!snapshot.downloadUrl) {
-    vscode18.window.showErrorMessage("Snapshot does not have a download URL");
+    vscode19.window.showErrorMessage("Snapshot does not have a download URL");
     return;
   }
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: `Fetching ${path13.basename(filePath)}...`,
       cancellable: false
     },
@@ -11890,7 +12826,7 @@ async function viewSnapshotFile(snapshot, filePath) {
         }
         const targetFile = path13.join(extractDir, filePath);
         if (!fs14.existsSync(targetFile)) {
-          vscode18.window.showErrorMessage(`File not found in snapshot: ${filePath}`);
+          vscode19.window.showErrorMessage(`File not found in snapshot: ${filePath}`);
           return;
         }
         const content = fs14.readFileSync(targetFile, "utf-8");
@@ -11901,7 +12837,7 @@ async function viewSnapshotFile(snapshot, filePath) {
           `snapshot-${snapshot.snapshotId.slice(0, 8)}-${path13.basename(filePath)}`
         );
       } catch (err) {
-        vscode18.window.showErrorMessage(
+        vscode19.window.showErrorMessage(
           `Failed to view snapshot file: ${err instanceof Error ? err.message : "unknown error"}`
         );
       }
@@ -11961,20 +12897,20 @@ async function downloadFile(url, destPath) {
 }
 async function uploadToSandbox(uri) {
   const cli = getCliClient();
-  const listResult = await vscode18.window.withProgress(
+  const listResult = await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Loading sandboxes...",
       cancellable: false
     },
     async () => cli.sandboxList()
   );
   if (!listResult.success || !listResult.data || listResult.data.length === 0) {
-    vscode18.window.showWarningMessage("No sandboxes available. Create a sandbox first.");
+    vscode19.window.showWarningMessage("No sandboxes available. Create a sandbox first.");
     return;
   }
   const sandboxes = listResult.data;
-  const picked = await vscode18.window.showQuickPick(
+  const picked = await vscode19.window.showQuickPick(
     sandboxes.map((s) => ({
       label: s.name || s.sandboxId.slice(0, 12),
       description: `${s.status} \xB7 ${s.runtime?.name ?? s.runtime?.id ?? "base"}`,
@@ -11985,20 +12921,20 @@ async function uploadToSandbox(uri) {
   );
   if (!picked) return;
   const selectedSandbox = picked.sandbox;
-  const remotePath = await vscode18.window.showInputBox({
+  const remotePath = await vscode19.window.showInputBox({
     prompt: "Remote path",
     value: DEFAULT_SANDBOX_PATH
   });
   if (!remotePath) return;
-  await vscode18.window.withProgress(
+  await vscode19.window.withProgress(
     {
-      location: vscode18.ProgressLocation.Notification,
+      location: vscode19.ProgressLocation.Notification,
       title: "Uploading...",
       cancellable: false
     },
     async () => {
-      const stats = await vscode18.workspace.fs.stat(uri);
-      const isDir = stats.type === vscode18.FileType.Directory;
+      const stats = await vscode19.workspace.fs.stat(uri);
+      const isDir = stats.type === vscode19.FileType.Directory;
       const fileName = path13.basename(uri.fsPath);
       const fullRemotePath = remotePath.endsWith("/") ? `${remotePath}${fileName}` : `${remotePath}/${fileName}`;
       const result = await cli.sandboxCpToSandbox(
@@ -12008,32 +12944,31 @@ async function uploadToSandbox(uri) {
         isDir
       );
       if (result.success) {
-        vscode18.window.showInformationMessage(`Uploaded to ${remotePath}`);
+        vscode19.window.showInformationMessage(`Uploaded to ${remotePath}`);
       } else {
-        vscode18.window.showErrorMessage(`Failed to upload: ${result.error}`);
+        vscode19.window.showErrorMessage(`Failed to upload: ${result.error}`);
       }
     }
   );
 }
 
 // src/features/workbench/index.ts
-var vscode19 = __toESM(require("vscode"));
-var WORKBENCH_BASE_URL = "https://app-v1.agentuity.com";
+var vscode20 = __toESM(require("vscode"));
 function registerWorkbenchCommands(context) {
   context.subscriptions.push(
-    vscode19.commands.registerCommand("agentuity.workbench.open", async () => {
+    vscode20.commands.registerCommand("agentuity.workbench.open", async () => {
       const project = getCurrentProject();
-      let url = WORKBENCH_BASE_URL;
+      let url = getAppUrl();
       if (project) {
-        url = `${WORKBENCH_BASE_URL}/projects/${project.projectId}`;
+        url = getWorkbenchUrl(project.projectId);
       }
-      await vscode19.env.openExternal(vscode19.Uri.parse(url));
+      await vscode20.env.openExternal(vscode20.Uri.parse(url));
     })
   );
 }
 
 // src/features/chat/agentuityParticipant.ts
-var vscode20 = __toESM(require("vscode"));
+var vscode21 = __toESM(require("vscode"));
 var CLI_REFERENCE_FALLBACK = `
 # Agentuity CLI Quick Reference
 
@@ -12063,15 +12998,15 @@ var SLASH_COMMANDS = [
   { name: "logs", description: "View logs for a session" }
 ];
 function registerChatParticipant(context) {
-  if (!vscode20.chat?.createChatParticipant) {
+  if (!vscode21.chat?.createChatParticipant) {
     return;
   }
   try {
-    const participant = vscode20.chat.createChatParticipant(
+    const participant = vscode21.chat.createChatParticipant(
       "agentuity.assistant",
       handleChatRequest
     );
-    participant.iconPath = vscode20.Uri.joinPath(context.extensionUri, "resources", "icon.svg");
+    participant.iconPath = vscode21.Uri.joinPath(context.extensionUri, "resources", "icon.svg");
     context.subscriptions.push(participant);
   } catch {
   }
@@ -12179,7 +13114,7 @@ async function handleNaturalLanguage(request, _context, stream, token) {
   if (prompt.includes("log") && (prompt.includes("session") || prompt.includes("view") || prompt.includes("show"))) {
     return handleLogs("", stream);
   }
-  const models = await vscode20.lm.selectChatModels({
+  const models = await vscode21.lm.selectChatModels({
     vendor: "copilot",
     family: "gpt-4o"
   });
@@ -12220,8 +13155,8 @@ ${projectContext}
 - For destructive operations (delete, deploy), always confirm with the user first
 - Link to https://agentuity.dev for documentation`;
   const messages = [
-    vscode20.LanguageModelChatMessage.User(systemPrompt),
-    vscode20.LanguageModelChatMessage.User(request.prompt)
+    vscode21.LanguageModelChatMessage.User(systemPrompt),
+    vscode21.LanguageModelChatMessage.User(request.prompt)
   ];
   try {
     const response = await model.sendRequest(messages, {}, token);
@@ -12235,7 +13170,7 @@ ${projectContext}
     if (token.isCancellationRequested) {
       return { metadata: { command: "cancelled" } };
     }
-    if (err instanceof vscode20.LanguageModelError) {
+    if (err instanceof vscode21.LanguageModelError) {
       stream.markdown(`Error: ${err.message}
 
 `);
@@ -12743,7 +13678,7 @@ async function handleFallback(_prompt, stream) {
 }
 
 // src/features/chat/cliTool.ts
-var vscode21 = __toESM(require("vscode"));
+var vscode22 = __toESM(require("vscode"));
 var DESTRUCTIVE_PATTERNS = [
   /^auth\s+logout/i,
   /\bdelete\b/i,
@@ -12772,7 +13707,7 @@ var AgentuityCliTool = class {
       throw new Error(`CLI command failed: ${result.error}`);
     }
     const output = typeof result.data === "string" ? result.data : JSON.stringify(result.data, null, 2);
-    return new vscode21.LanguageModelToolResult([new vscode21.LanguageModelTextPart(output)]);
+    return new vscode22.LanguageModelToolResult([new vscode22.LanguageModelTextPart(output)]);
   }
   async prepareInvocation(options, _token) {
     const { command } = options.input;
@@ -12782,7 +13717,7 @@ var AgentuityCliTool = class {
           invocationMessage: `Run deployment command: \`agentuity ${command}\``,
           confirmationMessages: {
             title: "Deploy to Agentuity Cloud",
-            message: new vscode21.MarkdownString(
+            message: new vscode22.MarkdownString(
               `This will deploy your project to Agentuity Cloud.
 
 \`\`\`bash
@@ -12801,27 +13736,27 @@ Do you want to continue?`
   }
 };
 function registerCliTool(context) {
-  if (!vscode21.lm?.registerTool) {
+  if (!vscode22.lm?.registerTool) {
     return;
   }
   try {
     const tool = new AgentuityCliTool();
-    const disposable = vscode21.lm.registerTool("agentuity_run_cli", tool);
+    const disposable = vscode22.lm.registerTool("agentuity_run_cli", tool);
     context.subscriptions.push(disposable);
   } catch {
   }
 }
 
 // src/features/chat/contextProvider.ts
-var vscode22 = __toESM(require("vscode"));
+var vscode23 = __toESM(require("vscode"));
 var CONTEXT_PROVIDER_ID = "agentuity.context";
 function registerChatContextProvider(context) {
-  if (!vscode22.chat?.registerChatContextProvider) {
+  if (!vscode23.chat?.registerChatContextProvider) {
     return;
   }
   try {
     const provider = new AgentuityContextProvider();
-    const disposable = vscode22.chat.registerChatContextProvider(
+    const disposable = vscode23.chat.registerChatContextProvider(
       [
         { language: "typescript" },
         { language: "javascript" },
@@ -12836,7 +13771,7 @@ function registerChatContextProvider(context) {
   }
 }
 var AgentuityContextProvider = class {
-  _onDidChangeWorkspaceChatContext = new vscode22.EventEmitter();
+  _onDidChangeWorkspaceChatContext = new vscode23.EventEmitter();
   onDidChangeWorkspaceChatContext = this._onDidChangeWorkspaceChatContext.event;
   _disposables = [];
   constructor() {
@@ -12859,7 +13794,7 @@ var AgentuityContextProvider = class {
     }
     const items = [];
     items.push({
-      icon: new vscode22.ThemeIcon("rocket"),
+      icon: new vscode23.ThemeIcon("rocket"),
       label: "Agentuity Project",
       modelDescription: "Summary of the Agentuity AI agent project including authentication, agents, deployments, and dev server status",
       contextType: "workspace"
@@ -12872,25 +13807,25 @@ var AgentuityContextProvider = class {
     }
     const items = [];
     items.push({
-      icon: new vscode22.ThemeIcon("rocket"),
+      icon: new vscode23.ThemeIcon("rocket"),
       label: "Agentuity: Full Project Context",
       modelDescription: "Complete Agentuity project context including all agents, deployments, data stores, and dev server status",
       contextType: "workspace"
     });
     items.push({
-      icon: new vscode22.ThemeIcon("hubot"),
+      icon: new vscode23.ThemeIcon("hubot"),
       label: "Agentuity: Agents",
       modelDescription: "List of all agents in this Agentuity project with their configuration",
       contextType: "agents"
     });
     items.push({
-      icon: new vscode22.ThemeIcon("cloud-upload"),
+      icon: new vscode23.ThemeIcon("cloud-upload"),
       label: "Agentuity: Deployments",
       modelDescription: "Recent deployments and their status for this Agentuity project",
       contextType: "deployments"
     });
     items.push({
-      icon: new vscode22.ThemeIcon("server-process"),
+      icon: new vscode23.ThemeIcon("server-process"),
       label: "Agentuity: Dev Server",
       modelDescription: "Current dev server status and configuration",
       contextType: "devServer"
@@ -12901,7 +13836,7 @@ var AgentuityContextProvider = class {
       if (agentsResult.success && agentsResult.data) {
         for (const agent of agentsResult.data) {
           items.push({
-            icon: new vscode22.ThemeIcon("hubot"),
+            icon: new vscode23.ThemeIcon("hubot"),
             label: `Agentuity Agent: ${agent.name}`,
             modelDescription: `Details for the "${agent.name}" agent including configuration, tools, and recent sessions`,
             contextType: "agent-detail",
@@ -13110,7 +14045,7 @@ var AgentuityContextProvider = class {
 };
 
 // src/features/chat/agentTools.ts
-var vscode23 = __toESM(require("vscode"));
+var vscode24 = __toESM(require("vscode"));
 var GetAgentsTool = class {
   async invoke(_options, _token) {
     if (!hasProject()) {
@@ -13123,8 +14058,8 @@ var GetAgentsTool = class {
     }
     const agents = result.data;
     if (agents.length === 0) {
-      return new vscode23.LanguageModelToolResult([
-        new vscode23.LanguageModelTextPart("No agents found in this project.")
+      return new vscode24.LanguageModelToolResult([
+        new vscode24.LanguageModelTextPart("No agents found in this project.")
       ]);
     }
     const output = agents.map((agent) => ({
@@ -13134,8 +14069,8 @@ var GetAgentsTool = class {
       description: agent.description,
       sourceFile: agent.metadata?.filename
     }));
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(output, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(output, null, 2))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13178,8 +14113,8 @@ var GetProjectStatusTool = class {
         status.totalDeployments = deploymentsResult.data.length;
       }
     }
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(status, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(status, null, 2))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13195,7 +14130,10 @@ var GetSessionsTool = class {
     }
     const cli = getCliClient();
     const count = options.input.count || 10;
-    const result = await cli.listSessions({ count });
+    const result = await cli.listSessions({
+      count,
+      agentIdentifier: options.input.agentName
+    });
     if (!result.success || !result.data) {
       throw new Error(`Failed to list sessions: ${result.error || "Unknown error"}`);
     }
@@ -13207,8 +14145,8 @@ var GetSessionsTool = class {
       trigger: session.trigger,
       env: session.env
     }));
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(sessions, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(sessions, null, 2))
     ]);
   }
   async prepareInvocation(options, _token) {
@@ -13237,8 +14175,8 @@ var GetSessionLogsTool = class {
       severity: log2.severity,
       message: log2.body
     }));
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(logs, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(logs, null, 2))
     ]);
   }
   async prepareInvocation(options, _token) {
@@ -13257,32 +14195,32 @@ var ControlDevServerTool = class {
     switch (action) {
       case "start":
         if (devServer.getState() === "running") {
-          return new vscode23.LanguageModelToolResult([
-            new vscode23.LanguageModelTextPart("Dev server is already running.")
+          return new vscode24.LanguageModelToolResult([
+            new vscode24.LanguageModelTextPart("Dev server is already running.")
           ]);
         }
         await devServer.start();
-        return new vscode23.LanguageModelToolResult([
-          new vscode23.LanguageModelTextPart("Dev server started successfully.")
+        return new vscode24.LanguageModelToolResult([
+          new vscode24.LanguageModelTextPart("Dev server started successfully.")
         ]);
       case "stop":
         if (devServer.getState() === "stopped") {
-          return new vscode23.LanguageModelToolResult([
-            new vscode23.LanguageModelTextPart("Dev server is not running.")
+          return new vscode24.LanguageModelToolResult([
+            new vscode24.LanguageModelTextPart("Dev server is not running.")
           ]);
         }
         await devServer.stop();
-        return new vscode23.LanguageModelToolResult([
-          new vscode23.LanguageModelTextPart("Dev server stopped.")
+        return new vscode24.LanguageModelToolResult([
+          new vscode24.LanguageModelTextPart("Dev server stopped.")
         ]);
       case "restart":
         await devServer.restart();
-        return new vscode23.LanguageModelToolResult([
-          new vscode23.LanguageModelTextPart("Dev server restarted.")
+        return new vscode24.LanguageModelToolResult([
+          new vscode24.LanguageModelTextPart("Dev server restarted.")
         ]);
       case "status":
-        return new vscode23.LanguageModelToolResult([
-          new vscode23.LanguageModelTextPart(
+        return new vscode24.LanguageModelToolResult([
+          new vscode24.LanguageModelTextPart(
             JSON.stringify({ state: devServer.getState() }, null, 2)
           )
         ]);
@@ -13299,7 +14237,7 @@ var ControlDevServerTool = class {
         invocationMessage: `${action === "start" ? "Starting" : "Restarting"} dev server...`,
         confirmationMessages: {
           title: `${action === "start" ? "Start" : "Restart"} Dev Server`,
-          message: new vscode23.MarkdownString(
+          message: new vscode24.MarkdownString(
             `This will ${action} the Agentuity dev server for local testing.
 
 Do you want to continue?`
@@ -13330,8 +14268,8 @@ var GetDeploymentsTool = class {
       createdAt: dep.createdAt,
       tags: dep.tags
     }));
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(deployments, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(deployments, null, 2))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13349,11 +14287,11 @@ var DeployProjectTool = class {
     if (authStatus.state !== "authenticated") {
       throw new Error('You must be logged in to deploy. Run "agentuity auth login" first.');
     }
-    const terminal = vscode23.window.createTerminal("Agentuity Deploy");
+    const terminal = vscode24.window.createTerminal("Agentuity Deploy");
     terminal.sendText("agentuity cloud deploy");
     terminal.show();
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(
         "Deployment started in terminal. Check the terminal output for progress."
       )
     ]);
@@ -13363,7 +14301,7 @@ var DeployProjectTool = class {
       invocationMessage: "Preparing deployment...",
       confirmationMessages: {
         title: "Deploy to Agentuity Cloud",
-        message: new vscode23.MarkdownString(
+        message: new vscode24.MarkdownString(
           "This will deploy your Agentuity project to the cloud.\n\n**Warning**: This will make your agents publicly accessible.\n\nDo you want to continue?"
         )
       }
@@ -13428,8 +14366,8 @@ var GetHealthSummaryTool = class {
     health.devServer = {
       state: devServer.getState()
     };
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(health, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(health, null, 2))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13457,8 +14395,8 @@ var ListSandboxesTool = class {
       resources: s.resources,
       executions: s.executions
     }));
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(sandboxes, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(sandboxes, null, 2))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13482,8 +14420,8 @@ var ListSandboxRuntimesTool = class {
       tags: rt.tags,
       url: rt.url
     }));
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(JSON.stringify(output, null, 2))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(output, null, 2))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13521,8 +14459,8 @@ var CreateSandboxTool = class {
       `Status: ${info.status}`,
       `Region: ${info.region}`
     ].filter(Boolean);
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(lines.join("\n"))
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(lines.join("\n"))
     ]);
   }
   async prepareInvocation(_options, _token) {
@@ -13530,7 +14468,7 @@ var CreateSandboxTool = class {
       invocationMessage: "Creating sandbox...",
       confirmationMessages: {
         title: "Create Sandbox",
-        message: new vscode23.MarkdownString(
+        message: new vscode24.MarkdownString(
           "This will create a new sandbox environment in the cloud.\n\nDo you want to continue?"
         )
       }
@@ -13543,14 +14481,14 @@ var SyncToSandboxTool = class {
     if (!sandboxId) {
       throw new Error("Sandbox ID is required.");
     }
-    if (!vscode23.workspace.workspaceFolders?.length) {
+    if (!vscode24.workspace.workspaceFolders?.length) {
       throw new Error("No workspace folder open to sync.");
     }
     try {
       const manager = getSandboxManager();
       const result = await manager.syncToSandbox(sandboxId);
-      return new vscode23.LanguageModelToolResult([
-        new vscode23.LanguageModelTextPart(
+      return new vscode24.LanguageModelToolResult([
+        new vscode24.LanguageModelTextPart(
           `Synced ${result.filesUploaded} files (${formatBytes(result.bytesTransferred)}) in ${(result.duration / 1e3).toFixed(1)}s`
         )
       ]);
@@ -13563,7 +14501,7 @@ var SyncToSandboxTool = class {
       invocationMessage: `Syncing workspace to sandbox ${options.input.sandboxId?.substring(0, 8)}...`,
       confirmationMessages: {
         title: "Sync to Sandbox",
-        message: new vscode23.MarkdownString(
+        message: new vscode24.MarkdownString(
           "This will upload your workspace files to the sandbox.\n\nDo you want to continue?"
         )
       }
@@ -13578,14 +14516,14 @@ var ExecuteInSandboxTool = class {
     }
     const cli = getCliClient();
     const cliPath = cli.getCliPath();
-    const terminal = vscode23.window.createTerminal({
+    const terminal = vscode24.window.createTerminal({
       name: `Sandbox: ${sandboxId.slice(0, 8)}`,
-      iconPath: new vscode23.ThemeIcon("vm")
+      iconPath: new vscode24.ThemeIcon("vm")
     });
     terminal.show();
     terminal.sendText(`${cliPath} cloud sandbox exec ${sandboxId} -- ${command}`);
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(
         `Executing "${command}" in sandbox ${sandboxId}. Check the terminal for output.`
       )
     ]);
@@ -13595,7 +14533,7 @@ var ExecuteInSandboxTool = class {
       invocationMessage: `Executing command in sandbox ${options.input.sandboxId?.substring(0, 8)}...`,
       confirmationMessages: {
         title: "Execute in Sandbox",
-        message: new vscode23.MarkdownString(
+        message: new vscode24.MarkdownString(
           `This will execute the following command in the sandbox:
 
 \`\`\`
@@ -13619,8 +14557,8 @@ var CreateSnapshotTool = class {
     if (!result.success || !result.data) {
       throw new Error(`Failed to create snapshot: ${result.error || "Unknown error"}`);
     }
-    return new vscode23.LanguageModelToolResult([
-      new vscode23.LanguageModelTextPart(
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(
         `Snapshot created!
 
 ID: ${result.data.snapshotId}
@@ -13636,66 +14574,324 @@ Tag: ${tag}` : ""}`
     };
   }
 };
+var DeleteSandboxTool = class {
+  async invoke(options, _token) {
+    const { sandboxId } = options.input;
+    if (!sandboxId) {
+      throw new Error("Sandbox ID is required.");
+    }
+    const cli = getCliClient();
+    const result = await cli.sandboxDelete(sandboxId);
+    if (!result.success) {
+      throw new Error(`Failed to delete sandbox: ${result.error || "Unknown error"}`);
+    }
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(`Sandbox ${sandboxId} deleted successfully.`)
+    ]);
+  }
+  async prepareInvocation(options, _token) {
+    return {
+      invocationMessage: `Deleting sandbox ${options.input.sandboxId?.substring(0, 8)}...`,
+      confirmationMessages: {
+        title: "Delete Sandbox",
+        message: new vscode24.MarkdownString(
+          `Are you sure you want to delete sandbox **${options.input.sandboxId}**?
+
+This action cannot be undone.`
+        )
+      }
+    };
+  }
+};
+var ListQueuesTool = class {
+  async invoke(options, _token) {
+    if (!hasProject()) {
+      throw new Error("No Agentuity project found in the current workspace.");
+    }
+    const cli = getCliClient();
+    const result = await cli.listQueues({ limit: options.input.limit });
+    if (!result.success || !result.data) {
+      throw new Error(`Failed to list queues: ${result.error || "Unknown error"}`);
+    }
+    const queues = result.data.queues;
+    if (queues.length === 0) {
+      return new vscode24.LanguageModelToolResult([
+        new vscode24.LanguageModelTextPart("No queues found.")
+      ]);
+    }
+    const output = queues.map((q) => ({
+      name: q.name,
+      type: q.queue_type,
+      messageCount: q.message_count,
+      dlqCount: q.dlq_count,
+      createdAt: q.created_at
+    }));
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(output, null, 2))
+    ]);
+  }
+  async prepareInvocation(_options, _token) {
+    return {
+      invocationMessage: "Fetching queues..."
+    };
+  }
+};
+var PublishQueueMessageTool = class {
+  async invoke(options, _token) {
+    if (!hasProject()) {
+      throw new Error("No Agentuity project found in the current workspace.");
+    }
+    const { queueName, payload, metadata, ttl } = options.input;
+    if (!queueName || !payload) {
+      throw new Error("Queue name and payload are required.");
+    }
+    try {
+      JSON.parse(payload);
+    } catch {
+      throw new Error("Payload must be valid JSON.");
+    }
+    if (metadata) {
+      try {
+        JSON.parse(metadata);
+      } catch {
+        throw new Error("Metadata must be valid JSON.");
+      }
+    }
+    const cli = getCliClient();
+    const result = await cli.publishQueueMessage(queueName, payload, { metadata, ttl });
+    if (!result.success || !result.data) {
+      throw new Error(`Failed to publish message: ${result.error || "Unknown error"}`);
+    }
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(
+        `Published message to queue "${queueName}":
+
+ID: ${result.data.id}
+Offset: ${result.data.offset}
+State: ${result.data.state}`
+      )
+    ]);
+  }
+  async prepareInvocation(options, _token) {
+    return {
+      invocationMessage: `Publishing message to queue "${options.input.queueName}"...`,
+      confirmationMessages: {
+        title: "Publish Message",
+        message: new vscode24.MarkdownString(
+          `Publish message to queue **${options.input.queueName}**?
+
+\`\`\`json
+${options.input.payload}
+\`\`\``
+        )
+      }
+    };
+  }
+};
+var ListQueueMessagesTool = class {
+  async invoke(options, _token) {
+    if (!hasProject()) {
+      throw new Error("No Agentuity project found in the current workspace.");
+    }
+    const { queueName, limit } = options.input;
+    if (!queueName) {
+      throw new Error("Queue name is required.");
+    }
+    const cli = getCliClient();
+    const result = await cli.listQueueMessages(queueName, { limit: limit || 20 });
+    if (!result.success || !result.data) {
+      throw new Error(`Failed to list messages: ${result.error || "Unknown error"}`);
+    }
+    const messages = result.data.data?.messages || [];
+    if (messages.length === 0) {
+      return new vscode24.LanguageModelToolResult([
+        new vscode24.LanguageModelTextPart(`No messages in queue "${queueName}".`)
+      ]);
+    }
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(messages, null, 2))
+    ]);
+  }
+  async prepareInvocation(options, _token) {
+    return {
+      invocationMessage: `Fetching messages from queue "${options.input.queueName}"...`
+    };
+  }
+};
+var PauseResumeQueueTool = class {
+  async invoke(options, _token) {
+    if (!hasProject()) {
+      throw new Error("No Agentuity project found in the current workspace.");
+    }
+    const { queueName, action } = options.input;
+    if (!queueName || !action) {
+      throw new Error("Queue name and action are required.");
+    }
+    const cli = getCliClient();
+    const result = action === "pause" ? await cli.pauseQueue(queueName) : await cli.resumeQueue(queueName);
+    if (!result.success) {
+      throw new Error(`Failed to ${action} queue: ${result.error || "Unknown error"}`);
+    }
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(`Queue "${queueName}" ${action}d successfully.`)
+    ]);
+  }
+  async prepareInvocation(options, _token) {
+    return {
+      invocationMessage: `${options.input.action === "pause" ? "Pausing" : "Resuming"} queue "${options.input.queueName}"...`
+    };
+  }
+};
+var ListDlqMessagesTool = class {
+  async invoke(options, _token) {
+    if (!hasProject()) {
+      throw new Error("No Agentuity project found in the current workspace.");
+    }
+    const { queueName, limit } = options.input;
+    if (!queueName) {
+      throw new Error("Queue name is required.");
+    }
+    const cli = getCliClient();
+    const result = await cli.listDlqMessages(queueName, { limit: limit || 20 });
+    if (!result.success || !result.data) {
+      throw new Error(`Failed to list DLQ messages: ${result.error || "Unknown error"}`);
+    }
+    const messages = result.data.messages || [];
+    if (messages.length === 0) {
+      return new vscode24.LanguageModelToolResult([
+        new vscode24.LanguageModelTextPart(`No messages in DLQ for queue "${queueName}".`)
+      ]);
+    }
+    const output = messages.map((m) => ({
+      id: m.id,
+      offset: m.offset,
+      failureReason: m.failure_reason,
+      deliveryAttempts: m.delivery_attempts,
+      movedAt: m.moved_at
+    }));
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(JSON.stringify(output, null, 2))
+    ]);
+  }
+  async prepareInvocation(options, _token) {
+    return {
+      invocationMessage: `Fetching DLQ messages from queue "${options.input.queueName}"...`
+    };
+  }
+};
+var ReplayDlqMessageTool = class {
+  async invoke(options, _token) {
+    if (!hasProject()) {
+      throw new Error("No Agentuity project found in the current workspace.");
+    }
+    const { queueName, messageId } = options.input;
+    if (!queueName || !messageId) {
+      throw new Error("Queue name and message ID are required.");
+    }
+    const cli = getCliClient();
+    const result = await cli.replayDlqMessage(queueName, messageId);
+    if (!result.success || !result.data) {
+      throw new Error(`Failed to replay message: ${result.error || "Unknown error"}`);
+    }
+    return new vscode24.LanguageModelToolResult([
+      new vscode24.LanguageModelTextPart(
+        `Replayed DLQ message ${messageId}. New offset: ${result.data.message.offset}`
+      )
+    ]);
+  }
+  async prepareInvocation(options, _token) {
+    return {
+      invocationMessage: `Replaying DLQ message ${options.input.messageId?.substring(0, 8)}...`,
+      confirmationMessages: {
+        title: "Replay DLQ Message",
+        message: new vscode24.MarkdownString(
+          `Replay message **${options.input.messageId}** from the dead letter queue back to queue **${options.input.queueName}**?`
+        )
+      }
+    };
+  }
+};
 function registerAgentTools(context) {
-  if (!vscode23.lm?.registerTool) {
+  if (!vscode24.lm?.registerTool) {
     return;
   }
   try {
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_get_agents", new GetAgentsTool())
+      vscode24.lm.registerTool("agentuity_get_agents", new GetAgentsTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_get_project_status", new GetProjectStatusTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_get_sessions", new GetSessionsTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_get_session_logs", new GetSessionLogsTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_control_dev_server", new ControlDevServerTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_get_deployments", new GetDeploymentsTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_deploy_project", new DeployProjectTool())
+    );
+    context.subscriptions.push(
+      vscode24.lm.registerTool("agentuity_get_health_summary", new GetHealthSummaryTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_get_project_status", new GetProjectStatusTool())
+      vscode24.lm.registerTool("agentuity_list_sandboxes", new ListSandboxesTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_get_sessions", new GetSessionsTool())
+      vscode24.lm.registerTool("agentuity_list_sandbox_runtimes", new ListSandboxRuntimesTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_get_session_logs", new GetSessionLogsTool())
+      vscode24.lm.registerTool("agentuity_create_sandbox", new CreateSandboxTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_control_dev_server", new ControlDevServerTool())
+      vscode24.lm.registerTool("agentuity_sync_to_sandbox", new SyncToSandboxTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_get_deployments", new GetDeploymentsTool())
+      vscode24.lm.registerTool("agentuity_execute_in_sandbox", new ExecuteInSandboxTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_deploy_project", new DeployProjectTool())
+      vscode24.lm.registerTool("agentuity_create_snapshot", new CreateSnapshotTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_get_health_summary", new GetHealthSummaryTool())
+      vscode24.lm.registerTool("agentuity_delete_sandbox", new DeleteSandboxTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_list_sandboxes", new ListSandboxesTool())
+      vscode24.lm.registerTool("agentuity_list_queues", new ListQueuesTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_list_sandbox_runtimes", new ListSandboxRuntimesTool())
+      vscode24.lm.registerTool("agentuity_publish_queue_message", new PublishQueueMessageTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_create_sandbox", new CreateSandboxTool())
+      vscode24.lm.registerTool("agentuity_list_queue_messages", new ListQueueMessagesTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_sync_to_sandbox", new SyncToSandboxTool())
+      vscode24.lm.registerTool("agentuity_pause_resume_queue", new PauseResumeQueueTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_execute_in_sandbox", new ExecuteInSandboxTool())
+      vscode24.lm.registerTool("agentuity_list_dlq_messages", new ListDlqMessagesTool())
     );
     context.subscriptions.push(
-      vscode23.lm.registerTool("agentuity_create_snapshot", new CreateSnapshotTool())
+      vscode24.lm.registerTool("agentuity_replay_dlq_message", new ReplayDlqMessageTool())
     );
   } catch {
   }
 }
 
 // src/features/codeLens/index.ts
-var vscode25 = __toESM(require("vscode"));
+var vscode26 = __toESM(require("vscode"));
 var fs15 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
 
 // src/features/codeLens/agentCodeLensProvider.ts
-var vscode24 = __toESM(require("vscode"));
+var vscode25 = __toESM(require("vscode"));
 var AgentCodeLensProvider = class {
-  _onDidChangeCodeLenses = new vscode24.EventEmitter();
+  _onDidChangeCodeLenses = new vscode25.EventEmitter();
   onDidChangeCodeLenses = this._onDidChangeCodeLenses.event;
   // Match both: createAgent('name', { and createAgent({
   createAgentRegex = /createAgent\s*\(/g;
@@ -13709,10 +14905,10 @@ var AgentCodeLensProvider = class {
     this.createAgentRegex.lastIndex = 0;
     while ((match = this.createAgentRegex.exec(text)) !== null) {
       const position = document.positionAt(match.index);
-      const range = new vscode24.Range(position, position);
+      const range = new vscode25.Range(position, position);
       const agentInfo = this.extractAgentInfo(document, match.index);
       codeLenses.push(
-        new vscode24.CodeLens(range, {
+        new vscode25.CodeLens(range, {
           title: "$(play) Open in Workbench",
           command: "agentuity.codeLens.openInWorkbench",
           arguments: [agentInfo],
@@ -13720,7 +14916,7 @@ var AgentCodeLensProvider = class {
         })
       );
       codeLenses.push(
-        new vscode24.CodeLens(range, {
+        new vscode25.CodeLens(range, {
           title: "$(pulse) View Sessions",
           command: "agentuity.codeLens.viewSessions",
           arguments: [agentInfo],
@@ -13749,7 +14945,7 @@ var AgentCodeLensProvider = class {
       identifier = identifierMatch[1];
     }
     if (!identifier) {
-      const relativePath = vscode24.workspace.asRelativePath(document.uri);
+      const relativePath = vscode25.workspace.asRelativePath(document.uri);
       const pathParts = relativePath.split("/");
       const agentsIndex = pathParts.indexOf("agents");
       if (agentsIndex !== -1 && agentsIndex < pathParts.length - 1) {
@@ -13777,7 +14973,6 @@ var AgentCodeLensProvider = class {
 };
 
 // src/features/codeLens/index.ts
-var SESSIONS_BASE_URL2 = "https://app-v1.agentuity.com";
 function findAgentIdFromMetadata(project, info) {
   try {
     const metadataPath = path14.join(project.rootPath, ".agentuity", "agentuity.metadata.json");
@@ -13815,30 +15010,30 @@ function registerCodeLens(context) {
     { language: "typescript", scheme: "file" },
     { language: "javascript", scheme: "file" }
   ];
-  context.subscriptions.push(vscode25.languages.registerCodeLensProvider(selector, provider));
+  context.subscriptions.push(vscode26.languages.registerCodeLensProvider(selector, provider));
   context.subscriptions.push(
-    vscode25.commands.registerCommand(
+    vscode26.commands.registerCommand(
       "agentuity.codeLens.openInWorkbench",
       async (info) => {
         const devServer2 = getDevServerManager();
         if (devServer2.getState() !== "running") {
-          const action = await vscode25.window.showWarningMessage(
+          const action = await vscode26.window.showWarningMessage(
             "Dev server is not running. Start it to open the Workbench.",
             "Start Dev Server",
             "Cancel"
           );
           if (action === "Start Dev Server") {
-            await vscode25.commands.executeCommand("agentuity.dev.start");
+            await vscode26.commands.executeCommand("agentuity.dev.start");
             await waitForDevServer(5e3);
             if (devServer2.getState() !== "running") {
-              vscode25.window.showErrorMessage("Failed to start dev server");
+              vscode26.window.showErrorMessage("Failed to start dev server");
               return;
             }
           } else {
             return;
           }
         }
-        const port = vscode25.workspace.getConfiguration("agentuity").get("devServer.port", 3500);
+        const port = vscode26.workspace.getConfiguration("agentuity").get("devServer.port", 3500);
         let url = `http://localhost:${port}/workbench`;
         const project = getCurrentProject();
         if (project) {
@@ -13847,37 +15042,37 @@ function registerCodeLens(context) {
             url += `?agent=${encodeURIComponent(agentId)}`;
           }
         }
-        await vscode25.env.openExternal(vscode25.Uri.parse(url));
+        await vscode26.env.openExternal(vscode26.Uri.parse(url));
       }
     )
   );
   context.subscriptions.push(
-    vscode25.commands.registerCommand(
+    vscode26.commands.registerCommand(
       "agentuity.codeLens.viewSessions",
       async (info) => {
         const project = getCurrentProject();
         if (!project) {
-          vscode25.window.showErrorMessage("No Agentuity project found");
+          vscode26.window.showErrorMessage("No Agentuity project found");
           return;
         }
         if (!info.identifier) {
-          vscode25.window.showErrorMessage("Could not determine agent identifier");
+          vscode26.window.showErrorMessage("Could not determine agent identifier");
           return;
         }
         const agentProvider2 = getAgentProvider();
         if (!agentProvider2) {
-          vscode25.window.showErrorMessage("Agent explorer not initialized");
+          vscode26.window.showErrorMessage("Agent explorer not initialized");
           return;
         }
         const agent = agentProvider2.findAgentByIdentifier(info.identifier);
         if (!agent) {
-          vscode25.window.showWarningMessage(
+          vscode26.window.showWarningMessage(
             `Agent "${info.identifier}" not found. Deploy your project first to view sessions.`
           );
           return;
         }
-        const url = `${SESSIONS_BASE_URL2}/projects/${project.projectId}/sessions?agent=${agent.id}`;
-        await vscode25.env.openExternal(vscode25.Uri.parse(url));
+        const url = getSessionsUrl(project.projectId, agent.id);
+        await vscode26.env.openExternal(vscode26.Uri.parse(url));
       }
     )
   );
@@ -13914,18 +15109,18 @@ async function waitForDevServer(timeoutMs) {
 }
 
 // src/features/customAgents/index.ts
-var vscode26 = __toESM(require("vscode"));
+var vscode27 = __toESM(require("vscode"));
 var path15 = __toESM(require("path"));
 var AGENTUITY_DEVELOPER_AGENT = `---
 name: Agentuity Developer
 description: Expert at building and debugging Agentuity AI agents
 tools:
-  - agentuity-agents
-  - agentuity-status
-  - agentuity-sessions
-  - agentuity-logs
-  - agentuity-dev
-  - agentuity-deployments
+  - agentuity_get_agents
+  - agentuity_get_project_status
+  - agentuity_get_sessions
+  - agentuity_get_session_logs
+  - agentuity_control_dev_server
+  - agentuity_get_deployments
 ---
 
 You are an expert Agentuity developer assistant. You help build, debug, and deploy AI agents using the Agentuity platform.
@@ -13933,29 +15128,28 @@ You are an expert Agentuity developer assistant. You help build, debug, and depl
 ## Your Capabilities
 
 You have access to specialized Agentuity tools:
-- **#agentuity-agents**: List all agents in the project
-- **#agentuity-status**: Get project status (auth, config, dev server, deployments)
-- **#agentuity-sessions**: View recent agent execution sessions
-- **#agentuity-logs**: Get detailed logs for a specific session
-- **#agentuity-dev**: Control the dev server (start/stop/restart/status)
-- **#agentuity-deployments**: List deployment history
+- **agentuity_get_agents**: List all agents in the project
+- **agentuity_get_project_status**: Get project status (auth, config, dev server, deployments)
+- **agentuity_get_sessions**: View recent agent execution sessions
+- **agentuity_get_session_logs**: Get detailed logs for a specific session
+- **agentuity_control_dev_server**: Control the dev server (start/stop/restart/status)
+- **agentuity_get_deployments**: List deployment history
 
 ## Guidelines
 
-1. **Before making changes**, always check the current project status with #agentuity-status
+1. **Before making changes**, always check the current project status with agentuity_get_project_status
 2. **For debugging**, fetch recent sessions and their logs to understand what went wrong
 3. **For testing**, ensure the dev server is running before suggesting tests
 4. **For deployment**, verify authentication status first
 
 ## Agentuity Agent Structure
 
-Agentuity agents are TypeScript/JavaScript files that export a handler:
+Agentuity agents are TypeScript/JavaScript files that export a default agent:
 
 \`\`\`typescript
-import { Agent } from '@agentuity/sdk';
+import { createAgent } from '@agentuity/sdk';
 
-export default new Agent({
-  name: 'my-agent',
+export default createAgent('my-agent', {
   description: 'What this agent does',
   async handler(request, context) {
     // Agent logic here
@@ -13975,8 +15169,8 @@ var AGENTUITY_REVIEWER_AGENT = `---
 name: Agentuity Reviewer
 description: Reviews Agentuity agent code for best practices and issues
 tools:
-  - agentuity-agents
-  - agentuity-status
+  - agentuity_get_agents
+  - agentuity_get_project_status
 ---
 
 You are an Agentuity code reviewer. You review agent implementations for:
@@ -14016,11 +15210,11 @@ var AGENTUITY_DEBUGGER_AGENT = `---
 name: Agentuity Debugger
 description: Diagnoses and fixes issues with Agentuity agents
 tools:
-  - agentuity-agents
-  - agentuity-status
-  - agentuity-sessions
-  - agentuity-logs
-  - agentuity-dev
+  - agentuity_get_agents
+  - agentuity_get_project_status
+  - agentuity_get_sessions
+  - agentuity_get_session_logs
+  - agentuity_control_dev_server
 ---
 
 You are an Agentuity debugging specialist. Your job is to diagnose and fix issues with AI agents.
@@ -14028,9 +15222,9 @@ You are an Agentuity debugging specialist. Your job is to diagnose and fix issue
 ## Debugging Workflow
 
 1. **Gather Context**
-   - Use #agentuity-status to check project state
-   - Use #agentuity-sessions to find recent failures
-   - Use #agentuity-logs to get detailed error information
+   - Use agentuity_get_project_status to check project state
+   - Use agentuity_get_sessions to find recent failures
+   - Use agentuity_get_session_logs to get detailed error information
 
 2. **Analyze**
    - Identify error patterns
@@ -14045,12 +15239,12 @@ You are an Agentuity debugging specialist. Your job is to diagnose and fix issue
 ## Common Issues
 
 ### Agent Not Responding
-- Check if dev server is running (#agentuity-dev status)
+- Check if dev server is running (agentuity_control_dev_server with action: status)
 - Verify agent is properly exported
 - Check for infinite loops or blocking calls
 
 ### Authentication Errors
-- Verify #agentuity-status shows authenticated
+- Verify agentuity_get_project_status shows authenticated
 - Check API key configuration
 - Ensure correct environment variables
 
@@ -14065,9 +15259,9 @@ You are an Agentuity debugging specialist. Your job is to diagnose and fix issue
 - Validate JSON serialization
 `;
 async function scaffoldCustomAgents() {
-  const workspaceFolders = vscode26.workspace.workspaceFolders;
+  const workspaceFolders = vscode27.workspace.workspaceFolders;
   if (!workspaceFolders || workspaceFolders.length === 0) {
-    vscode26.window.showErrorMessage("No workspace folder open. Open a folder first.");
+    vscode27.window.showErrorMessage("No workspace folder open. Open a folder first.");
     return;
   }
   const rootPath = workspaceFolders[0].uri.fsPath;
@@ -14077,7 +15271,7 @@ async function scaffoldCustomAgents() {
     { name: "agentuity-reviewer.agent.md", content: AGENTUITY_REVIEWER_AGENT },
     { name: "agentuity-debugger.agent.md", content: AGENTUITY_DEBUGGER_AGENT }
   ];
-  const selected = await vscode26.window.showQuickPick(
+  const selected = await vscode27.window.showQuickPick(
     [
       { label: "All Agents", description: "Create all Agentuity custom agents", value: "all" },
       {
@@ -14104,18 +15298,18 @@ async function scaffoldCustomAgents() {
   if (!selected) {
     return;
   }
-  const agentsDirUri = vscode26.Uri.file(agentsDir);
+  const agentsDirUri = vscode27.Uri.file(agentsDir);
   try {
-    await vscode26.workspace.fs.createDirectory(agentsDirUri);
+    await vscode27.workspace.fs.createDirectory(agentsDirUri);
   } catch {
   }
   const toCreate = selected.value === "all" ? agents : agents.filter((a) => a.name.includes(selected.value));
   const writtenFiles = [];
   for (const agent of toCreate) {
-    const filePath = vscode26.Uri.file(path15.join(agentsDir, agent.name));
+    const filePath = vscode27.Uri.file(path15.join(agentsDir, agent.name));
     try {
-      await vscode26.workspace.fs.stat(filePath);
-      const overwrite = await vscode26.window.showWarningMessage(
+      await vscode27.workspace.fs.stat(filePath);
+      const overwrite = await vscode27.window.showWarningMessage(
         `${agent.name} already exists. Overwrite?`,
         "Yes",
         "No"
@@ -14125,21 +15319,21 @@ async function scaffoldCustomAgents() {
       }
     } catch {
     }
-    await vscode26.workspace.fs.writeFile(filePath, Buffer.from(agent.content, "utf-8"));
+    await vscode27.workspace.fs.writeFile(filePath, Buffer.from(agent.content, "utf-8"));
     writtenFiles.push(filePath);
   }
   if (writtenFiles.length === 0) {
-    vscode26.window.showInformationMessage("No custom agents were created.");
+    vscode27.window.showInformationMessage("No custom agents were created.");
     return;
   }
-  vscode26.window.showInformationMessage(
+  vscode27.window.showInformationMessage(
     `Created ${writtenFiles.length} custom agent${writtenFiles.length > 1 ? "s" : ""} in .github/agents/`
   );
-  await vscode26.window.showTextDocument(writtenFiles[0]);
+  await vscode27.window.showTextDocument(writtenFiles[0]);
 }
 function registerCustomAgentCommands(context) {
   context.subscriptions.push(
-    vscode26.commands.registerCommand("agentuity.createCustomAgents", () => scaffoldCustomAgents())
+    vscode27.commands.registerCommand("agentuity.createCustomAgents", () => scaffoldCustomAgents())
   );
 }
 
@@ -14161,10 +15355,11 @@ async function activate(context) {
   registerAiCommands(context);
   registerSetupCommands(context);
   registerDeployCommand(context);
+  registerOrgRegionCommands(context);
   const walkthroughShown = context.globalState.get("agentuity.walkthroughShown", false);
   if (!walkthroughShown) {
     await context.globalState.update("agentuity.walkthroughShown", true);
-    void vscode27.commands.executeCommand(
+    void vscode28.commands.executeCommand(
       "workbench.action.openWalkthrough",
       "agentuity.agentuity#gettingStarted",
       false
@@ -14200,11 +15395,11 @@ async function activate(context) {
 }
 function registerAuthCommands(context) {
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.login", () => {
-      const terminal = vscode27.window.createTerminal("Agentuity Login");
+    vscode28.commands.registerCommand("agentuity.login", () => {
+      const terminal = vscode28.window.createTerminal("Agentuity Login");
       terminal.sendText("agentuity auth login");
       terminal.show();
-      vscode27.window.showInformationMessage(
+      vscode28.window.showInformationMessage(
         "Complete login in the terminal, then refresh the extension.",
         "Refresh"
       ).then((action) => {
@@ -14215,35 +15410,35 @@ function registerAuthCommands(context) {
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.logout", async () => {
+    vscode28.commands.registerCommand("agentuity.logout", async () => {
       const cli = getCliClient();
       const result = await cli.exec(["auth", "logout"]);
       if (result.success) {
-        vscode27.window.showInformationMessage("Logged out of Agentuity");
+        vscode28.window.showInformationMessage("Logged out of Agentuity");
         await checkAuth();
       } else {
-        vscode27.window.showErrorMessage(`Logout failed: ${result.error}`);
+        vscode28.window.showErrorMessage(`Logout failed: ${result.error}`);
       }
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.whoami", async () => {
+    vscode28.commands.registerCommand("agentuity.whoami", async () => {
       const cli = getCliClient();
       const result = await cli.whoami();
       if (result.success && result.data) {
         const user = result.data;
-        vscode27.window.showInformationMessage(
+        vscode28.window.showInformationMessage(
           `Logged in as: ${user.firstName} ${user.lastName}`
         );
       } else {
-        vscode27.window.showWarningMessage("Not logged in to Agentuity");
+        vscode28.window.showWarningMessage("Not logged in to Agentuity");
       }
     })
   );
 }
 function registerAiCommands(context) {
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.getAiCapabilities", async () => {
+    vscode28.commands.registerCommand("agentuity.getAiCapabilities", async () => {
       if (!await requireAuth()) {
         return void 0;
       }
@@ -14252,13 +15447,13 @@ function registerAiCommands(context) {
       if (result.success) {
         return result.data;
       } else {
-        vscode27.window.showErrorMessage(`Failed to get capabilities: ${result.error}`);
+        vscode28.window.showErrorMessage(`Failed to get capabilities: ${result.error}`);
         return void 0;
       }
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.getAiSchema", async () => {
+    vscode28.commands.registerCommand("agentuity.getAiSchema", async () => {
       if (!await requireAuth()) {
         return void 0;
       }
@@ -14267,7 +15462,7 @@ function registerAiCommands(context) {
       if (result.success) {
         return result.data;
       } else {
-        vscode27.window.showErrorMessage(`Failed to get schema: ${result.error}`);
+        vscode28.window.showErrorMessage(`Failed to get schema: ${result.error}`);
         return void 0;
       }
     })
@@ -14275,27 +15470,27 @@ function registerAiCommands(context) {
 }
 function registerSetupCommands(context) {
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.installCli", () => {
-      void vscode27.env.openExternal(
-        vscode27.Uri.parse("https://agentuity.dev/Introduction/getting-started")
+    vscode28.commands.registerCommand("agentuity.installCli", () => {
+      void vscode28.env.openExternal(
+        vscode28.Uri.parse("https://agentuity.dev/Introduction/getting-started")
       );
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.createProject", () => {
-      const terminal = vscode27.window.createTerminal("Agentuity");
+    vscode28.commands.registerCommand("agentuity.createProject", () => {
+      const terminal = vscode28.window.createTerminal("Agentuity");
       terminal.sendText("agentuity project new");
       terminal.show();
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.generateSkills", async () => {
-      const workspaceFolder = vscode27.workspace.workspaceFolders?.[0];
+    vscode28.commands.registerCommand("agentuity.generateSkills", async () => {
+      const workspaceFolder = vscode28.workspace.workspaceFolders?.[0];
       if (!workspaceFolder) {
-        vscode27.window.showErrorMessage("No workspace folder open");
+        vscode28.window.showErrorMessage("No workspace folder open");
         return;
       }
-      const outputPath = await vscode27.window.showInputBox({
+      const outputPath = await vscode28.window.showInputBox({
         prompt: "Output directory for generated skills",
         value: workspaceFolder.uri.fsPath,
         placeHolder: "/path/to/output"
@@ -14303,20 +15498,20 @@ function registerSetupCommands(context) {
       if (!outputPath) {
         return;
       }
-      const terminal = vscode27.window.createTerminal("Agentuity Skills");
+      const terminal = vscode28.window.createTerminal("Agentuity Skills");
       terminal.sendText(`agentuity ai skills generate --output "${outputPath}"`);
       terminal.show();
-      vscode27.window.showInformationMessage("Generating AI skills...");
+      vscode28.window.showInformationMessage("Generating AI skills...");
     })
   );
 }
 function registerDeployCommand(context) {
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.deploy", async () => {
+    vscode28.commands.registerCommand("agentuity.deploy", async () => {
       if (!await requireAuth()) {
         return;
       }
-      const answer = await vscode27.window.showWarningMessage(
+      const answer = await vscode28.window.showWarningMessage(
         "Deploy to Agentuity Cloud?",
         { modal: true },
         "Deploy"
@@ -14324,41 +15519,107 @@ function registerDeployCommand(context) {
       if (answer !== "Deploy") {
         return;
       }
-      const terminal = vscode27.window.createTerminal("Agentuity Deploy");
+      const terminal = vscode28.window.createTerminal("Agentuity Deploy");
       terminal.sendText("agentuity cloud deploy");
       terminal.show();
     })
   );
 }
+function registerOrgRegionCommands(context) {
+  context.subscriptions.push(
+    vscode28.commands.registerCommand("agentuity.org.select", async () => {
+      if (!await requireAuth()) {
+        return;
+      }
+      const cli = getCliClient();
+      const result = await cli.orgList();
+      if (!result.success || !result.data || result.data.length === 0) {
+        vscode28.window.showWarningMessage("No organizations found");
+        return;
+      }
+      const items = result.data.map((org) => ({
+        label: org.name,
+        description: org.id,
+        orgId: org.id
+      }));
+      const selected = await vscode28.window.showQuickPick(items, {
+        placeHolder: "Select an organization",
+        title: "Switch Organization"
+      });
+      if (!selected) {
+        return;
+      }
+      const selectResult = await cli.orgSelect(selected.orgId);
+      if (selectResult.success) {
+        vscode28.window.showInformationMessage(`Switched to organization: ${selected.label}`);
+        void vscode28.commands.executeCommand("agentuity.refresh");
+      } else {
+        vscode28.window.showErrorMessage(`Failed to switch organization: ${selectResult.error}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode28.commands.registerCommand("agentuity.region.select", async () => {
+      if (!await requireAuth()) {
+        return;
+      }
+      const cli = getCliClient();
+      const result = await cli.regionList();
+      if (!result.success || !result.data || result.data.length === 0) {
+        vscode28.window.showWarningMessage("No regions available");
+        return;
+      }
+      const items = result.data.map((region) => ({
+        label: region.description,
+        description: region.region,
+        region: region.region
+      }));
+      const selected = await vscode28.window.showQuickPick(items, {
+        placeHolder: "Select a region",
+        title: "Switch Region"
+      });
+      if (!selected) {
+        return;
+      }
+      const selectResult = await cli.regionSelect(selected.region);
+      if (selectResult.success) {
+        vscode28.window.showInformationMessage(`Switched to region: ${selected.label}`);
+        void vscode28.commands.executeCommand("agentuity.sandbox.refresh");
+      } else {
+        vscode28.window.showErrorMessage(`Failed to switch region: ${selectResult.error}`);
+      }
+    })
+  );
+}
 function registerRefreshCommands(context, providers) {
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.refresh", async () => {
+    vscode28.commands.registerCommand("agentuity.refresh", async () => {
       await checkAuth();
       await detectProject();
       providers.agents.forceRefresh();
       providers.data.refresh();
       providers.deployments.forceRefresh();
       providers.sandboxes.forceRefresh();
-      vscode27.window.showInformationMessage("Agentuity refreshed");
+      vscode28.window.showInformationMessage("Agentuity refreshed");
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.agents.refresh", () => {
+    vscode28.commands.registerCommand("agentuity.agents.refresh", () => {
       void providers.agents.forceRefresh();
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.deployments.refresh", () => {
+    vscode28.commands.registerCommand("agentuity.deployments.refresh", () => {
       void providers.deployments.forceRefresh();
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.data.refresh", () => {
+    vscode28.commands.registerCommand("agentuity.data.refresh", () => {
       providers.data.refresh();
     })
   );
   context.subscriptions.push(
-    vscode27.commands.registerCommand("agentuity.sandbox.refresh", () => {
+    vscode28.commands.registerCommand("agentuity.sandbox.refresh", () => {
       void providers.sandboxes.forceRefresh();
     })
   );