@hatchway/cli 0.50.68 → 0.50.70

package/dist/index.js

@@ -1,5 +1,4 @@
 // Hatchway CLI - Built with Rollup
-import * as Sentry from '@sentry/node';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { Codex } from '@openai/codex-sdk';
 import { a as streamLog, f as fileLog, i as initRunnerLogger, s as setFileLoggerTuiMode, b as getLogger } from './chunks/runner-logger-instance-Dj_JMznn.js';
@@ -9,13 +8,13 @@ import { fileURLToPath } from 'node:url';
 import { existsSync, readdirSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { readFile } from 'fs/promises';
 import * as path from 'path';
-import { join as join$1 } from 'path';
+import { join as join$1, resolve as resolve$1, relative as relative$1, isAbsolute as isAbsolute$1 } from 'path';
 import WebSocket$1, { WebSocketServer, WebSocket } from 'ws';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import pg from 'pg';
 import { pgTable, timestamp, boolean, text, uuid, index, uniqueIndex, integer, jsonb } from 'drizzle-orm/pg-core';
 import { sql, eq, and, desc, isNull } from 'drizzle-orm';
-import { randomUUID, createHash } from 'crypto';
+import { randomUUID, timingSafeEqual, createHash } from 'crypto';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
 import { z } from 'zod';
 import { spawn } from 'node:child_process';
@@ -28,8 +27,7 @@ import { readFile as readFile$1, rm, writeFile, readdir } from 'node:fs/promises
 import { simpleGit } from 'simple-git';
 import * as os from 'os';
 import { existsSync as existsSync$1, mkdirSync as mkdirSync$1 } from 'fs';
-import { tunnelManager } from './chunks/manager-DjVI7erc.js';
-import { a as getPackageVersion } from './chunks/version-info-CDtU8Ta2.js';
+import { tunnelManager } from './chunks/manager-0U0BIO9r.js';
 import 'chalk';
 import 'http';
 import 'http-proxy';
@@ -183,14 +181,6 @@ function getPlatformPluginDir() {
             if (process.env.SILENT_MODE !== '1') {
                 process.stderr.write('[skills] Platform plugin directory not found\n');
             }
-            Sentry.logger.error('Platform plugin directory not found — agent will run without core skills', {
-                candidatePaths: [
-                    join(__dirname$3, 'skills', 'platform-plugin'),
-                    join(__dirname$3, 'lib', 'skills', 'platform-plugin'),
-                    join(__dirname$3, '..', 'src', 'lib', 'skills', 'platform-plugin'),
-                ].join(', '),
-                __dirname: __dirname$3,
-            });
         }
     }
     return _pluginDir;
@@ -277,12 +267,12 @@ var init_tags$1 = __esm$1({
             sdk: "agent"
           },
           {
-            value: "claude-opus-4-6",
-            label: "Claude Opus 4.6",
+            value: "claude-opus-4-8",
+            label: "Claude Opus 4.8",
             description: "Anthropic Claude - Most capable for complex tasks",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-opus-4-6",
+            model: "claude-opus-4-8",
             sdk: "agent"
           },
           {
@@ -306,10 +296,10 @@ var init_tags$1 = __esm$1({
           {
             value: "factory-droid-opus",
             label: "Factory Droid (Opus)",
-            description: "Factory Droid SDK with Claude Opus 4.6",
+            description: "Factory Droid SDK with Claude Opus 4.8",
             logo: "/factory.svg",
             provider: "factory-droid",
-            model: "claude-opus-4-6-20251101",
+            model: "claude-opus-4-8",
             sdk: "droid"
           },
           {
@@ -1539,7 +1529,10 @@ var DEFAULT_OPENCODE_MODEL_ID = "anthropic/claude-sonnet-4-6";
 var LEGACY_MODEL_MAP = {
   "claude-haiku-4-5": "anthropic/claude-haiku-4-5",
   "claude-sonnet-4-6": "anthropic/claude-sonnet-4-6",
-  "claude-opus-4-6": "anthropic/claude-opus-4-6",
+  "claude-opus-4-8": "anthropic/claude-opus-4-8",
+  // Legacy aliases — upgrade previously-saved selections to the current model
+  "claude-opus-4-6": "anthropic/claude-opus-4-8",
+  "claude-opus-4-6-20251101": "anthropic/claude-opus-4-8",
   "gpt-5-codex": "openai/gpt-5.2-codex",
   "gpt-5.2-codex": "openai/gpt-5.2-codex"
 };
@@ -1568,8 +1561,8 @@ var CLAUDE_MODEL_METADATA = {
     description: "Balanced performance and quality",
     provider: "anthropic"
   },
-  "claude-opus-4-6": {
-    label: "Claude Opus 4.6",
+  "claude-opus-4-8": {
+    label: "Claude Opus 4.8",
     description: "Most capable Claude model for complex tasks",
     provider: "anthropic"
   }
@@ -1585,8 +1578,8 @@ var MODEL_METADATA = {
     description: "Balanced performance and quality",
     provider: "anthropic"
   },
-  "anthropic/claude-opus-4-6": {
-    label: "Claude Opus 4.6",
+  "anthropic/claude-opus-4-8": {
+    label: "Claude Opus 4.8",
     description: "Most capable for complex tasks",
     provider: "anthropic"
   },
@@ -1683,6 +1676,8 @@ async function resolveAgentStrategy$1(agentId) {
 
 // src/index.ts
 init_config_server$1();
+
+// src/lib/logging/build-logger.ts
 var BuildLogger$1 = class BuildLogger {
   buildId = null;
   projectId = null;
@@ -1733,23 +1728,6 @@ var BuildLogger$1 = class BuildLogger {
     } else {
       logFn(`${icon} ${prefix} ${message}`);
     }
-    if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-      try {
-        if (level === "warn" || level === "error") {
-          Sentry.addBreadcrumb({
-            category: `build-logger.${context}`,
-            message,
-            level: level === "error" ? "error" : "warning",
-            data: {
-              ...data,
-              buildId: this.buildId,
-              projectId: this.projectId
-            }
-          });
-        }
-      } catch {
-      }
-    }
   }
   /**
    * Orchestrator-specific logging methods
@@ -2269,6 +2247,17 @@ var projects = pgTable("projects", {
   // 'deploying' | 'success' | 'failed' | 'crashed'
   railwayLastDeployedAt: timestamp("railway_last_deployed_at"),
   // Last successful deployment
+  // Execution mode: where builds run for this project
+  executionMode: text("execution_mode").default("local"),
+  // 'local' | 'sandbox'
+  sandboxId: text("sandbox_id"),
+  // Railway sandbox id when executionMode='sandbox' and currently running (warm)
+  sandboxStatus: text("sandbox_status"),
+  // 'provisioning' | 'running' | 'stopped' | 'failed'
+  sandboxCheckpoint: text("sandbox_checkpoint"),
+  // Railway checkpoint key for this project's saved workspace (restore point)
+  sandboxSubdomain: text("sandbox_subdomain"),
+  // Stable railgate subdomain so the preview URL persists across restarts
   createdAt: timestamp("created_at").notNull().defaultNow(),
   updatedAt: timestamp("updated_at").notNull().defaultNow()
 }, (table) => ({
@@ -3087,8 +3076,18 @@ var RunnerCommandQueue = class {
   }
 };
 var commandQueue = new RunnerCommandQueue();
+function timingSafeEqualString(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length) {
+    return false;
+  }
+  return timingSafeEqual(bufA, bufB);
+}
 
 // src/lib/websocket/server.ts
+var isLocalMode = () => process.env.HATCHWAY_LOCAL_MODE === "true";
+var upgradeAuthContext = /* @__PURE__ */ new WeakMap();
 var getSharedSecret = () => process.env.RUNNER_SHARED_SECRET;
 function hashRunnerKey(key) {
   return createHash("sha256").update(key).digest("hex");
@@ -3143,6 +3142,18 @@ var BuildWebSocketServer = class {
   initialized = false;
   // Callback for runner status changes (set by app layer)
   onRunnerStatusChangeCallback = null;
+  // Client auth hooks (set by app layer). Without these, client connections are
+  // only accepted in local mode - default deny in hosted deployments.
+  authenticateClient = null;
+  authorizeProjectAccess = null;
+  /**
+   * Install authentication hooks for frontend client connections.
+   * Must be called by the app layer before clients connect in hosted mode.
+   */
+  setClientAuth(authenticate, authorize) {
+    this.authenticateClient = authenticate;
+    this.authorizeProjectAccess = authorize;
+  }
   constructor() {
     buildLogger$2.websocket.serverCreated(this.instanceId);
   }
@@ -3162,7 +3173,13 @@ var BuildWebSocketServer = class {
       // Disable compression for lower latency
     });
     this.wss.on("connection", (ws, req) => {
-      this.handleConnection(ws, req);
+      this.handleConnection(ws, req).catch((error) => {
+        buildLogger$2.websocket.error("Failed to handle client connection", error);
+        try {
+          ws.close(1011, "Internal error");
+        } catch {
+        }
+      });
     });
     this.runnerWss = new WebSocketServer({
       noServer: true,
@@ -3178,8 +3195,20 @@ var BuildWebSocketServer = class {
           this.runnerWss.emit("connection", ws, request);
         });
       } else if (pathname === path || pathname === "/ws") {
-        this.wss.handleUpgrade(request, socket, head, (ws) => {
-          this.wss.emit("connection", ws, request);
+        this.resolveClientAuth(request).then((auth) => {
+          if (!auth.allowed) {
+            buildLogger$2.log("warn", "websocket", "Rejected unauthenticated client upgrade");
+            socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+            socket.destroy();
+            return;
+          }
+          upgradeAuthContext.set(request, { userId: auth.userId });
+          this.wss.handleUpgrade(request, socket, head, (ws) => {
+            this.wss.emit("connection", ws, request);
+          });
+        }).catch((error) => {
+          buildLogger$2.websocket.error("Client upgrade auth failed", error);
+          socket.destroy();
         });
       } else {
         if (pathname && pathname !== "/") {
@@ -3205,19 +3234,58 @@ var BuildWebSocketServer = class {
   // ============================================================
   // FRONTEND CLIENT HANDLING
   // ============================================================
+  /**
+   * Authenticate a client upgrade request.
+   * Local mode: always allowed. Hosted mode: requires the app layer to have
+   * installed an authenticator via setClientAuth() - otherwise deny.
+   */
+  async resolveClientAuth(req) {
+    if (isLocalMode()) {
+      return { allowed: true };
+    }
+    if (!this.authenticateClient) {
+      buildLogger$2.log("warn", "websocket", "No client authenticator configured - denying client connection");
+      return { allowed: false };
+    }
+    const auth = await this.authenticateClient(req);
+    if (!auth) {
+      return { allowed: false };
+    }
+    return { allowed: true, userId: auth.userId };
+  }
+  /**
+   * Check whether a user may access a project. Local mode always allows.
+   */
+  async canAccessProject(userId, projectId) {
+    if (isLocalMode()) return true;
+    if (!this.authorizeProjectAccess || !userId) return false;
+    try {
+      return await this.authorizeProjectAccess(userId, projectId);
+    } catch (error) {
+      buildLogger$2.websocket.error("Project access check failed", error, { projectId });
+      return false;
+    }
+  }
   /**
    * Handle new frontend WebSocket connection
    */
-  handleConnection(ws, req) {
+  async handleConnection(ws, req) {
     const clientId = this.generateClientId();
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const projectId = url.searchParams.get("projectId") || "";
     const sessionId = url.searchParams.get("sessionId") || void 0;
+    const userId = upgradeAuthContext.get(req)?.userId;
+    if (projectId && !await this.canAccessProject(userId, projectId)) {
+      buildLogger$2.log("warn", "websocket", `Client denied access to project ${projectId}`);
+      ws.close(4403, "Forbidden");
+      return;
+    }
     buildLogger$2.websocket.clientConnected(clientId, projectId, sessionId);
     this.clients.set(clientId, {
       ws,
       projectId,
       sessionId,
+      userId,
       lastHeartbeat: Date.now()
     });
     this.sendMessage(ws, {
@@ -3230,7 +3298,9 @@ var BuildWebSocketServer = class {
     ws.on("message", (data) => {
       try {
         const message = JSON.parse(data.toString());
-        this.handleClientMessage(clientId, message);
+        this.handleClientMessage(clientId, message).catch((error) => {
+          buildLogger$2.websocket.error("Failed to handle client message", error, { clientId });
+        });
       } catch (error) {
         buildLogger$2.websocket.error("Failed to parse client message", error, { clientId });
       }
@@ -3267,7 +3337,7 @@ var BuildWebSocketServer = class {
         const result = await validateRunnerKey(token);
         isAuthenticated = result.valid;
         runnerUserId = result.userId;
-      } else if (sharedSecret && token === sharedSecret) {
+      } else if (sharedSecret && timingSafeEqualString(token, sharedSecret)) {
         isAuthenticated = true;
       }
     }
@@ -3283,6 +3353,19 @@ var BuildWebSocketServer = class {
     }
     const url = new URL(req.url || "", `http://${req.headers.host}`);
     const runnerId = url.searchParams.get("runnerId") ?? "default";
+    const existing = this.runnerConnections.get(runnerId);
+    if (existing) {
+      if (existing.userId !== runnerUserId) {
+        buildLogger$2.log("warn", "websocket", `Rejected runner connection: runnerId '${runnerId}' already claimed by another user`);
+        ws.close(1008, "Runner ID already in use");
+        return;
+      }
+      clearInterval(existing.pingInterval);
+      try {
+        existing.socket.close(1e3, "Replaced by new connection");
+      } catch {
+      }
+    }
     buildLogger$2.websocket.runnerConnected(runnerId);
     const pingInterval = setInterval(() => {
       if (ws.readyState === WebSocket.OPEN) {
@@ -3296,11 +3379,6 @@ var BuildWebSocketServer = class {
       pingInterval,
       userId: runnerUserId
     });
-    Sentry.addBreadcrumb({
-      category: "websocket",
-      message: `Runner connected: ${runnerId}`,
-      level: "info"
-    });
     const queueResult = commandQueue.processQueue(runnerId);
     if (queueResult.sent > 0 || queueResult.failed > 0) {
       buildLogger$2.log("info", "websocket", `Runner ${runnerId} reconnected - processed queued commands`, {
@@ -3330,16 +3408,15 @@ var BuildWebSocketServer = class {
         }
       } catch (error) {
         this.runnerTotalErrors++;
-        Sentry.captureException(error, {
-          tags: { runnerId, source: "websocket_message" },
-          level: "error"
-        });
         buildLogger$2.websocket.error("Failed to handle runner message", error, { runnerId });
       }
     });
     ws.on("close", (code) => {
-      buildLogger$2.websocket.runnerDisconnected(runnerId, code);
       const conn = this.runnerConnections.get(runnerId);
+      if (conn && conn.socket !== ws) {
+        return;
+      }
+      buildLogger$2.websocket.runnerDisconnected(runnerId, code);
       if (conn) {
         clearInterval(conn.pingInterval);
       }
@@ -3347,20 +3424,10 @@ var BuildWebSocketServer = class {
       httpProxyManager.cancelRequestsForRunner(runnerId);
       hmrProxyManager$1.disconnectRunner(runnerId);
       this.cleanupRunnerProcesses(runnerId);
-      Sentry.addBreadcrumb({
-        category: "websocket",
-        message: `Runner disconnected: ${runnerId}`,
-        level: "info",
-        data: { code }
-      });
     });
     ws.on("error", (error) => {
       buildLogger$2.websocket.error("Runner socket error", error, { runnerId });
       this.runnerTotalErrors++;
-      Sentry.captureException(error, {
-        tags: { runnerId, source: "websocket_error" },
-        level: "error"
-      });
       const conn = this.runnerConnections.get(runnerId);
       if (conn) {
         clearInterval(conn.pingInterval);
@@ -3398,30 +3465,12 @@ var BuildWebSocketServer = class {
       return false;
     }
     try {
-      const activeSpan = Sentry.getActiveSpan();
-      const hasTrace = !!activeSpan;
-      if (activeSpan) {
-        const traceData = Sentry.getTraceData();
-        if (traceData["sentry-trace"]) {
-          command._sentry = {
-            trace: traceData["sentry-trace"],
-            baggage: traceData.baggage
-          };
-          buildLogger$2.log("debug", "websocket", `Attaching trace to command ${command.type}`, {
-            tracePreview: traceData["sentry-trace"].substring(0, 50)
-          });
-        }
-      }
-      buildLogger$2.websocket.commandSent(runnerId, command.type, hasTrace);
+      buildLogger$2.websocket.commandSent(runnerId, command.type, false);
       connection.socket.send(JSON.stringify(command));
       this.runnerTotalCommands++;
       return true;
     } catch (error) {
       this.runnerTotalErrors++;
-      Sentry.captureException(error, {
-        tags: { runnerId, commandType: command.type },
-        level: "error"
-      });
       buildLogger$2.websocket.error("Failed to send command to runner", error, { runnerId, commandType: command.type });
       return false;
     }
@@ -3484,12 +3533,6 @@ var BuildWebSocketServer = class {
     for (const [runnerId, conn] of this.runnerConnections.entries()) {
       if (now - conn.lastHeartbeat > this.RUNNER_HEARTBEAT_TIMEOUT) {
         buildLogger$2.websocket.runnerStaleRemoved(runnerId);
-        Sentry.addBreadcrumb({
-          category: "websocket",
-          message: `Stale runner connection removed: ${runnerId}`,
-          level: "warning",
-          data: { age: now - conn.lastHeartbeat }
-        });
         clearInterval(conn.pingInterval);
         conn.socket.close(1e3, "Heartbeat timeout");
         this.runnerConnections.delete(runnerId);
@@ -3527,12 +3570,6 @@ var BuildWebSocketServer = class {
         runnerId,
         projectIds
       });
-      Sentry.addBreadcrumb({
-        category: "websocket",
-        message: `Cleaned up processes for disconnected runner`,
-        level: "info",
-        data: { runnerId, processCount: projectIds.length }
-      });
       if (this.onRunnerStatusChangeCallback) {
         try {
           this.onRunnerStatusChangeCallback(runnerId, false, projectIds);
@@ -3542,10 +3579,6 @@ var BuildWebSocketServer = class {
       }
     } catch (error) {
       buildLogger$2.websocket.error("Failed to cleanup runner processes", error, { runnerId });
-      Sentry.captureException(error, {
-        tags: { runnerId, source: "runner_cleanup" },
-        level: "error"
-      });
     }
   }
   /**
@@ -3570,7 +3603,7 @@ var BuildWebSocketServer = class {
   /**
    * Handle messages from client (heartbeat, resubscribe, HMR, etc.)
    */
-  handleClientMessage(clientId, message) {
+  async handleClientMessage(clientId, message) {
     const client = this.clients.get(clientId);
     if (!client) return;
     switch (message.type) {
@@ -3578,11 +3611,19 @@ var BuildWebSocketServer = class {
         client.lastHeartbeat = Date.now();
         this.sendMessage(client.ws, { type: "heartbeat-ack", timestamp: Date.now() });
         break;
-      case "subscribe":
-        client.projectId = message.projectId;
+      case "subscribe": {
+        const targetProjectId = typeof message.projectId === "string" ? message.projectId : "";
+        const alreadyVerified = targetProjectId === client.projectId;
+        if (targetProjectId && !alreadyVerified && !await this.canAccessProject(client.userId, targetProjectId)) {
+          buildLogger$2.log("warn", "websocket", `Client ${clientId} denied subscribe to project ${targetProjectId}`);
+          this.sendMessage(client.ws, { type: "error", error: "Forbidden", projectId: targetProjectId });
+          break;
+        }
+        client.projectId = targetProjectId;
         client.sessionId = message.sessionId;
-        buildLogger$2.websocket.clientSubscribed(clientId, message.projectId);
+        buildLogger$2.websocket.clientSubscribed(clientId, targetProjectId);
         break;
+      }
       case "get-state":
         this.sendCurrentState(client);
         break;
@@ -3601,10 +3642,18 @@ var BuildWebSocketServer = class {
   /**
    * Handle HMR connect request from frontend
    */
-  handleHmrConnect(clientId, client, message) {
-    const { connectionId, port, protocol, runnerId } = message;
-    const targetRunnerId = runnerId || this.getRunnerIdForProject(client.projectId);
-    if (!targetRunnerId) {
+  async handleHmrConnect(clientId, client, message) {
+    const { connectionId, protocol } = message;
+    if (!client.projectId) {
+      this.sendMessage(client.ws, {
+        type: "hmr-error",
+        connectionId,
+        error: "Not subscribed to a project"
+      });
+      return;
+    }
+    const target = await this.getHmrTargetForProject(client.projectId);
+    if (!target) {
       this.sendMessage(client.ws, {
         type: "hmr-error",
         connectionId,
@@ -3612,6 +3661,7 @@ var BuildWebSocketServer = class {
       });
       return;
     }
+    const { runnerId: targetRunnerId, port } = target;
     if (!client.hmrConnections) {
       client.hmrConnections = /* @__PURE__ */ new Set();
     }
@@ -3672,12 +3722,22 @@ var BuildWebSocketServer = class {
     hmrProxyManager$1.disconnect(connectionId);
   }
   /**
-   * Get the runner ID for a project (looks up from connected runners)
-   * In a multi-runner setup, this would query the database
+   * Resolve the HMR tunnel target (runner + dev server port) for a project.
+   * The project's assigned runner must be connected and its dev server port
+   * recorded - no fallback to "any runner".
    */
-  getRunnerIdForProject(projectId) {
-    const runners = this.listRunnerConnections();
-    return runners.length > 0 ? runners[0].runnerId : null;
+  async getHmrTargetForProject(projectId) {
+    try {
+      const rows = await db.select({ runnerId: projects.runnerId, devServerPort: projects.devServerPort }).from(projects).where(eq(projects.id, projectId)).limit(1);
+      if (rows.length === 0) return null;
+      const { runnerId, devServerPort } = rows[0];
+      if (!runnerId || !devServerPort) return null;
+      if (!this.runnerConnections.has(runnerId)) return null;
+      return { runnerId, port: devServerPort };
+    } catch (error) {
+      buildLogger$2.websocket.error("Failed to resolve HMR target", error, { projectId });
+      return null;
+    }
   }
   /**
    * @deprecated Use discrete event broadcasts instead (broadcastBuildStarted, broadcastTodosUpdate,
@@ -3693,11 +3753,7 @@ var BuildWebSocketServer = class {
         updates: []
       });
     }
-    const activeSpan = Sentry.getActiveSpan();
-    const traceContext = activeSpan ? {
-      trace: Sentry.getTraceData()["sentry-trace"],
-      baggage: Sentry.getTraceData().baggage
-    } : void 0;
+    const traceContext = void 0;
     const batch = this.pendingUpdates.get(key);
     batch.updates.push({
       type: "state-update",
@@ -3728,11 +3784,7 @@ var BuildWebSocketServer = class {
         updates: []
       });
     }
-    const activeSpan = Sentry.getActiveSpan();
-    const traceContext = activeSpan ? {
-      trace: Sentry.getTraceData()["sentry-trace"],
-      baggage: Sentry.getTraceData().baggage
-    } : void 0;
+    const traceContext = void 0;
     const batch = this.pendingUpdates.get(key);
     batch.updates.push({
       type: "tool-call",
@@ -4333,12 +4385,6 @@ function buildPromptWithImages(prompt, messageParts) {
  *
  * With:
  * query() SDK function -> minimal transformation -> output
- *
- * Sentry Integration:
- * - Manual gen_ai.* spans for AI Agent Monitoring in Sentry
- * - gen_ai.invoke_agent wraps the full query lifecycle
- * - gen_ai.execute_tool spans are emitted per tool call
- * - Token usage and cost are captured from the SDK result message
  */
 function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortController) {
     return async function* nativeClaudeQuery(prompt, workingDirectory, systemPrompt, _agent, _codexThreadId, messageParts) {
@@ -4362,12 +4408,6 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         const platformPlugins = platformPluginDir
             ? [{ type: 'local', path: platformPluginDir }]
             : [];
-        if (platformPlugins.length === 0) {
-            Sentry.logger.warn('Agent starting without platform skills — degraded capabilities', {
-                model: modelId,
-                workingDirectory,
-            });
-        }
         // Check for multi-modal content
         const hasImages = messageParts?.some(p => p.type === 'image');
         if (hasImages) {
@@ -4430,28 +4470,6 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         let pendingRequestMessages = [
             { role: 'user', content: finalPrompt.substring(0, 1000) },
         ];
-        // Create the gen_ai.invoke_agent span as a child of the current active span.
-        //
-        // We use startInactiveSpan because this is an async generator — we can't use
-        // startSpan/startSpanManual (both require a callback, and yields can't cross
-        // callback boundaries). startInactiveSpan creates a span that inherits the
-        // parent from the current active span (build.runner, restored by engine.ts
-        // via Sentry.withActiveSpan).
-        //
-        // For tool spans, we use Sentry.withActiveSpan(agentSpan, ...) to temporarily
-        // make the agent span active so tool spans become its children.
-        const agentSpan = Sentry.startInactiveSpan({
-            op: 'gen_ai.invoke_agent',
-            name: 'invoke_agent hatchway-builder',
-            attributes: {
-                'gen_ai.operation.name': 'invoke_agent',
-                'gen_ai.agent.name': 'hatchway-builder',
-                'gen_ai.request.model': modelId,
-                'gen_ai.request.messages': JSON.stringify([{ role: 'user', content: finalPrompt.substring(0, 1000) }]),
-                'gen_ai.request.available_tools': JSON.stringify(['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Task', 'TodoWrite', 'WebFetch']
-                    .map(name => ({ name, type: 'function' }))),
-            },
-        });
         try {
             // Stream messages directly from the SDK
             for await (const sdkMessage of query({ prompt: finalPrompt, options })) {
@@ -4465,65 +4483,17 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                     // pendingRequestMessages) and the response text / tool calls.
                     if (transformed.type === 'assistant' && transformed.message?.content) {
                         turnCount++;
-                        // Collect response text and tool calls from this turn
-                        const responseTexts = [];
-                        const responseToolCalls = [];
                         for (const block of transformed.message.content) {
                             if (block.type === 'tool_use') {
                                 toolCallCount++;
                                 debugLog$4(`[runner] [native-sdk] 🔧 Tool call: ${block.name}\n`);
-                                responseToolCalls.push({
-                                    name: block.name ?? 'unknown',
-                                    type: 'function_call',
-                                    arguments: JSON.stringify(block.input).substring(0, 500),
-                                });
                             }
                             else if (block.type === 'text' && block.text) {
                                 textBlockCount++;
-                                responseTexts.push(block.text);
                             }
                         }
-                        // Emit gen_ai.request span as a child of the agent span
-                        Sentry.withActiveSpan(agentSpan, () => {
-                            Sentry.startSpan({
-                                op: 'gen_ai.request',
-                                name: `request ${modelId}`,
-                                attributes: {
-                                    'gen_ai.request.model': modelId,
-                                    'gen_ai.operation.name': 'request',
-                                    'gen_ai.request.messages': JSON.stringify(pendingRequestMessages),
-                                    ...(responseTexts.length > 0
-                                        ? { 'gen_ai.response.text': JSON.stringify(responseTexts.map(t => t.substring(0, 500))) }
-                                        : {}),
-                                    ...(responseToolCalls.length > 0
-                                        ? { 'gen_ai.response.tool_calls': JSON.stringify(responseToolCalls) }
-                                        : {}),
-                                },
-                            }, () => {
-                                // Span marks the LLM request/response for this turn
-                            });
-                        });
                         // Reset pending messages — the next turn's input will be tool results
                         pendingRequestMessages = [];
-                        // Emit gen_ai.execute_tool spans for each tool call in this turn
-                        for (const block of transformed.message.content) {
-                            if (block.type === 'tool_use') {
-                                Sentry.withActiveSpan(agentSpan, () => {
-                                    Sentry.startSpan({
-                                        op: 'gen_ai.execute_tool',
-                                        name: `execute_tool ${block.name}`,
-                                        attributes: {
-                                            'gen_ai.tool.name': block.name,
-                                            'gen_ai.tool.call_id': block.id,
-                                            'gen_ai.tool.input': JSON.stringify(block.input).substring(0, 1000),
-                                            'gen_ai.request.model': modelId,
-                                        },
-                                    }, () => {
-                                        // Span marks the tool invocation point
-                                    });
-                                });
-                            }
-                        }
                     }
                     // --- Accumulate tool results for the next gen_ai.request span ---
                     // 'user' messages contain tool_result blocks that feed the next LLM turn.
@@ -4550,32 +4520,6 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                         process.stderr.write(`[native-sdk] SDK init — plugins: ${JSON.stringify(loadedPlugins)}\n`);
                         process.stderr.write(`[native-sdk] SDK init — tools: ${toolCount} loaded\n`);
                     }
-                    // Set discovered skills on the agent span
-                    if (agentSpan) {
-                        agentSpan.setAttribute('gen_ai.agent.skills', discoveredSkills.join(', '));
-                        agentSpan.setAttribute('gen_ai.agent.skill_count', discoveredSkills.length);
-                    }
-                    if (discoveredSkills.length > 0) {
-                        Sentry.logger.info('SDK initialized with skills', {
-                            skillCount: String(discoveredSkills.length),
-                            skills: discoveredSkills.join(', '),
-                            pluginCount: String(loadedPlugins.length),
-                            plugins: loadedPlugins.map(p => p.name).join(', '),
-                            toolCount: String(toolCount),
-                            model: initMsg.model ?? modelId,
-                            workingDirectory,
-                        });
-                    }
-                    else {
-                        Sentry.logger.warn('SDK initialized but no skills discovered', {
-                            pluginCount: String(loadedPlugins.length),
-                            plugins: JSON.stringify(loadedPlugins),
-                            toolCount: String(toolCount),
-                            model: initMsg.model ?? modelId,
-                            workingDirectory,
-                            platformPluginDir: platformPluginDir ?? 'null',
-                        });
-                    }
                 }
                 // Capture tool_use_summary messages — these indicate skill content loading
                 if (sdkMessage.type === 'tool_use_summary') {
@@ -4587,29 +4531,6 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                 // Capture result messages — record token usage and cost on the agent span
                 if (sdkMessage.type === 'result') {
                     const resultMsg = sdkMessage;
-                    if (agentSpan) {
-                        // Standard gen_ai token usage attributes (Sentry AI Agent Monitoring spec)
-                        agentSpan.setAttribute('gen_ai.usage.input_tokens', resultMsg.usage?.input_tokens ?? 0);
-                        agentSpan.setAttribute('gen_ai.usage.output_tokens', resultMsg.usage?.output_tokens ?? 0);
-                        agentSpan.setAttribute('gen_ai.usage.total_tokens', (resultMsg.usage?.input_tokens ?? 0) + (resultMsg.usage?.output_tokens ?? 0));
-                        if (resultMsg.usage?.cache_read_input_tokens) {
-                            agentSpan.setAttribute('gen_ai.usage.input_tokens.cached', resultMsg.usage.cache_read_input_tokens);
-                        }
-                        if (resultMsg.usage?.cache_creation_input_tokens) {
-                            agentSpan.setAttribute('gen_ai.usage.input_tokens.cache_write', resultMsg.usage.cache_creation_input_tokens);
-                        }
-                        // Response text (truncated for span safety)
-                        if (resultMsg.result) {
-                            agentSpan.setAttribute('gen_ai.response.text', JSON.stringify(resultMsg.result.substring(0, 1000)));
-                        }
-                        // Custom (non-spec) attributes for operational insight
-                        agentSpan.setAttribute('hatchway.cost_usd', resultMsg.total_cost_usd ?? 0);
-                        agentSpan.setAttribute('hatchway.num_turns', resultMsg.num_turns ?? 0);
-                        agentSpan.setAttribute('hatchway.num_tool_calls', toolCallCount);
-                        agentSpan.setAttribute('hatchway.result', resultMsg.subtype ?? 'unknown');
-                        agentSpan.setAttribute('hatchway.duration_ms', resultMsg.duration_ms ?? 0);
-                        agentSpan.setAttribute('hatchway.duration_api_ms', resultMsg.duration_api_ms ?? 0);
-                    }
                     if (resultMsg.subtype === 'success') {
                         debugLog$4(`[runner] [native-sdk] ✅ Query complete - ${resultMsg.num_turns} turns, $${resultMsg.total_cost_usd?.toFixed(4)} USD\n`);
                     }
@@ -4622,16 +4543,8 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         }
         catch (error) {
             debugLog$4(`[runner] [native-sdk] ❌ Error: ${error instanceof Error ? error.message : String(error)}\n`);
-            if (agentSpan) {
-                agentSpan.setStatus({ code: 2, message: error instanceof Error ? error.message : String(error) });
-            }
-            Sentry.captureException(error);
             throw error;
         }
-        finally {
-            // End the agent span regardless of success/failure
-            agentSpan?.end();
-        }
     };
 }
 
@@ -4840,20 +4753,6 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
         // Parse model ID
         const { provider: providerID, model: modelID } = parseModelId(normalizeModelId(modelId));
         let sessionId = null;
-        // Start Sentry AI agent span for the entire OpenCode query
-        // This provides visibility into AI operations in Sentry's trace view
-        const aiSpan = Sentry.startInactiveSpan({
-            name: 'opencode.query',
-            op: 'ai.pipeline',
-            attributes: {
-                'ai.pipeline.name': 'opencode',
-                'ai.model_id': `${providerID}/${modelID}`,
-                'ai.provider': providerID,
-                'ai.streaming': true,
-                'gen_ai.system': 'opencode',
-                'gen_ai.request.model': modelID,
-            },
-        });
         try {
             // Step 1: Create a session
             debugLog$3('[runner] [opencode-sdk] Creating session...');
@@ -4871,10 +4770,6 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
             const session = await sessionResponse.json();
             sessionId = session.id;
             debugLog$3(`[runner] [opencode-sdk] Session created: ${sessionId}`);
-            // Update span with session info
-            if (sessionId) {
-                aiSpan?.setAttribute('opencode.session_id', sessionId);
-            }
             // Step 2: Subscribe to events
             debugLog$3('[runner] [opencode-sdk] Subscribing to events...');
             const eventResponse = await fetch(`${baseUrl}/event`, {
@@ -5000,16 +4895,9 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
                 };
             }
             debugLog$3('[runner] [opencode-sdk] Query complete');
-            // Update span with final metrics
-            aiSpan?.setAttribute('opencode.tool_calls', toolCallCount);
-            aiSpan?.setAttribute('opencode.messages', messageCount);
-            aiSpan?.setStatus({ code: 1 }); // OK status
         }
         catch (error) {
             debugLog$3(`[runner] [opencode-sdk] Error: ${error instanceof Error ? error.message : String(error)}`);
-            Sentry.captureException(error);
-            // Mark span as errored
-            aiSpan?.setStatus({ code: 2, message: error instanceof Error ? error.message : String(error) });
             // Yield error result
             yield {
                 type: 'result',
@@ -5019,10 +4907,6 @@ function createOpenCodeQuery(modelId = DEFAULT_OPENCODE_MODEL_ID) {
             };
             throw error;
         }
-        finally {
-            // End the AI span
-            aiSpan?.end();
-        }
     };
 }
 /**
@@ -5524,15 +5408,6 @@ function createDroidQuery(modelId) {
             process.stderr.write(`[runner] [droid-sdk] Events received: ${messageCount}\n`);
             process.stderr.write(`[runner] [droid-sdk] Tool calls: ${toolCallCount}\n`);
             process.stderr.write(`[runner] [droid-sdk] Last event type: ${lastEventType}\n\n`);
-            Sentry.captureException(error, {
-                extra: {
-                    modelId,
-                    workingDirectory,
-                    promptLength: prompt.length,
-                    eventsReceived: messageCount,
-                    toolCalls: toolCallCount,
-                }
-            });
             throw error;
         }
         finally {
@@ -5542,6 +5417,39 @@ function createDroidQuery(modelId) {
     };
 }
 
+// src/lib/path-safety.ts
+var SLUG_PATTERN = /^[a-zA-Z0-9._-]+$/;
+var MAX_SLUG_LENGTH = 128;
+function isValidProjectSlug(slug) {
+  return typeof slug === "string" && slug.length > 0 && slug.length <= MAX_SLUG_LENGTH && SLUG_PATTERN.test(slug) && !slug.includes("..");
+}
+function assertValidProjectSlug(slug) {
+  if (!isValidProjectSlug(slug)) {
+    throw new Error(`Invalid project slug: ${String(slug)}`);
+  }
+}
+function resolveProjectPath(workspaceRoot, slug) {
+  assertValidProjectSlug(slug);
+  const root = resolve$1(workspaceRoot);
+  const projectPath = resolve$1(root, slug);
+  const rel = relative$1(root, projectPath);
+  if (!rel || rel.startsWith("..") || isAbsolute$1(rel)) {
+    throw new Error(`Invalid project slug: ${slug}`);
+  }
+  return projectPath;
+}
+function resolveWithinProject(projectPath, relPath) {
+  if (typeof relPath !== "string" || relPath.length === 0 || relPath.includes("\0")) {
+    throw new Error(`Invalid file path: ${String(relPath)}`);
+  }
+  const fullPath = resolve$1(projectPath, relPath);
+  const rel = relative$1(projectPath, fullPath);
+  if (!rel || rel.startsWith("..") || isAbsolute$1(rel)) {
+    throw new Error("Invalid file path - outside project directory");
+  }
+  return fullPath;
+}
+
 // src/lib/logging/build-logger.ts
 var BuildLogger = class {
   buildId = null;
@@ -5593,23 +5501,6 @@ var BuildLogger = class {
     } else {
       logFn(`${icon} ${prefix} ${message}`);
     }
-    if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-      try {
-        if (level === "warn" || level === "error") {
-          Sentry.addBreadcrumb({
-            category: `build-logger.${context}`,
-            message,
-            level: level === "error" ? "error" : "warning",
-            data: {
-              ...data,
-              buildId: this.buildId,
-              projectId: this.projectId
-            }
-          });
-        }
-      } catch {
-      }
-    }
   }
   /**
    * Orchestrator-specific logging methods
@@ -5986,12 +5877,12 @@ var init_tags = __esm({
             sdk: "agent"
           },
           {
-            value: "claude-opus-4-6",
-            label: "Claude Opus 4.6",
+            value: "claude-opus-4-8",
+            label: "Claude Opus 4.8",
             description: "Anthropic Claude - Most capable for complex tasks",
             logo: "/claude.png",
             provider: "claude-code",
-            model: "claude-opus-4-6",
+            model: "claude-opus-4-8",
             sdk: "agent"
           },
           {
@@ -6015,10 +5906,10 @@ var init_tags = __esm({
           {
             value: "factory-droid-opus",
             label: "Factory Droid (Opus)",
-            description: "Factory Droid SDK with Claude Opus 4.6",
+            description: "Factory Droid SDK with Claude Opus 4.8",
             logo: "/factory.svg",
             provider: "factory-droid",
-            model: "claude-opus-4-6-20251101",
+            model: "claude-opus-4-8",
             sdk: "droid"
           },
           {
@@ -7257,12 +7148,6 @@ async function createBuildStream(options) {
     debugLog$1();
     const generator = query(fullPrompt, actualWorkingDir, systemPrompt, agent, options.codexThreadId, messageParts);
     debugLog$1();
-    // Capture the active Sentry span BEFORE creating the ReadableStream.
-    // The ReadableStream.start() callback runs in a new async context where the
-    // parent build.runner span is no longer active. We restore it with withActiveSpan()
-    // so that gen_ai.invoke_agent spans created inside the query generator are
-    // properly nested as children of the build.runner span.
-    const parentSpan = Sentry.getActiveSpan();
     // Create a ReadableStream from the AsyncGenerator
     const stream = new ReadableStream({
         async start(controller) {
@@ -7298,13 +7183,7 @@ async function createBuildStream(options) {
                     process.chdir(originalCwd);
                 }
             };
-            // Restore the parent span context so child spans nest correctly
-            if (parentSpan) {
-                await Sentry.withActiveSpan(parentSpan, consume);
-            }
-            else {
-                await consume();
-            }
+            await consume();
         },
     });
     debugLog$1();
@@ -7935,6 +7814,12 @@ async function runHealthCheck(projectId, port) {
         };
     }
 }
+/**
+ * Get active process for a project
+ */
+function getDevServer(projectId) {
+    return activeProcesses.get(projectId);
+}
 /**
  * Get all active project IDs
  */
@@ -7960,6 +7845,7 @@ var processManager = /*#__PURE__*/Object.freeze({
     checkPortInUse: checkPortInUse,
     findAvailablePort: findAvailablePort,
     getAllActiveProjectIds: getAllActiveProjectIds,
+    getDevServer: getDevServer,
     runHealthCheck: runHealthCheck,
     setSilentMode: setSilentMode$1,
     startDevServer: startDevServer,
@@ -9876,12 +9762,12 @@ var TAG_DEFINITIONS = [
         sdk: "agent"
       },
       {
-        value: "claude-opus-4-6",
-        label: "Claude Opus 4.6",
+        value: "claude-opus-4-8",
+        label: "Claude Opus 4.8",
         description: "Anthropic Claude - Most capable for complex tasks",
         logo: "/claude.png",
         provider: "claude-code",
-        model: "claude-opus-4-6",
+        model: "claude-opus-4-8",
         sdk: "agent"
       },
       {
@@ -9905,10 +9791,10 @@ var TAG_DEFINITIONS = [
       {
         value: "factory-droid-opus",
         label: "Factory Droid (Opus)",
-        description: "Factory Droid SDK with Claude Opus 4.6",
+        description: "Factory Droid SDK with Claude Opus 4.8",
         logo: "/factory.svg",
         provider: "factory-droid",
-        model: "claude-opus-4-6-20251101",
+        model: "claude-opus-4-8",
         sdk: "droid"
       },
       {
@@ -10127,7 +10013,7 @@ var TAG_DEFINITIONS = [
 const MODEL_MAP = {
     'claude-haiku-4-5': 'claude-sonnet-4-6', // Haiku 4.5 not yet available, use Sonnet
     'claude-sonnet-4-6': 'claude-sonnet-4-6',
-    'claude-opus-4-6': 'claude-opus-4-6',
+    'claude-opus-4-8': 'claude-opus-4-8',
 };
 function resolveModelName(modelId) {
     return MODEL_MAP[modelId] || 'claude-sonnet-4-6';
@@ -10195,7 +10081,6 @@ CRITICAL: Your response must START with { and END with }. Output only the JSON o
     }
     catch (error) {
         console.error('[project-analyzer] SDK query failed:', error);
-        Sentry.captureException(error);
         throw error;
     }
     if (!responseText) {
@@ -10731,8 +10616,6 @@ class HmrProxyManager {
 // Export singleton instance
 const hmrProxyManager = new HmrProxyManager();
 
-// Sentry is initialized via --import flag (see package.json scripts)
-// This ensures instrumentation loads before any other modules
 // AI SDK log warnings disabled (legacy - no longer using AI SDK)
 /**
  * Truncate strings for logging to prevent excessive output
@@ -10898,13 +10781,6 @@ function createCodexQuery() {
             log(`🚀 [codex-query] Turn ${turnCount}: ${turnCount === 1 ? 'Initial request' : 'Continuing work'}...`);
             // Log full prompt being sent to Codex
             if (turnCount === 1) {
-                Sentry.logger.info(Sentry.logger.fmt `Full Codex prompt (Turn 1) ${{
-                    prompt: turnPrompt,
-                    promptLength: turnPrompt.length,
-                    promptPreview: turnPrompt.substring(0, 200),
-                    operation: 'codex_query',
-                    turnCount: 1,
-                }}`);
                 // Also log to file
                 fileLog.info('━━━ FULL CODEX PROMPT ━━━');
                 fileLog.info(turnPrompt);
@@ -11297,29 +11173,11 @@ async function startRunner(options = {}) {
         throw lastError || new Error('Persistence failed after retries');
     }
     async function persistBuildEventDirect(context, event) {
-        return Sentry.startSpan({
-            name: `persist.build-event.${event.type}`,
-            op: 'http.client',
-            attributes: {
-                'http.method': 'POST',
-                'http.url': `${apiBaseUrl}/api/build-events`,
-                'event.type': event.type,
-                'event.tool_name': event.toolName || undefined,
-            },
-        }, async () => {
-            // Get trace context for propagation
-            const traceData = Sentry.getTraceData();
+        return await (async () => {
             const headers = {
                 'Authorization': `Bearer ${runnerSharedSecret}`,
                 'Content-Type': 'application/json',
             };
-            // Add Sentry trace headers for distributed tracing
-            if (traceData['sentry-trace']) {
-                headers['sentry-trace'] = traceData['sentry-trace'];
-            }
-            if (traceData.baggage) {
-                headers['baggage'] = traceData.baggage;
-            }
             const response = await fetchWithRetry(`${apiBaseUrl}/api/build-events`, {
                 method: 'POST',
                 headers,
@@ -11337,7 +11195,7 @@ async function startRunner(options = {}) {
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-        });
+        })();
     }
     /**
      * Send a build event to the HTTP persistence endpoint.
@@ -11415,16 +11273,7 @@ async function startRunner(options = {}) {
      * Send a runner lifecycle event to the HTTP persistence endpoint.
      */
     async function persistRunnerEvent(event) {
-        // Wrap in Sentry span to create proper trace hierarchy
-        return Sentry.startSpan({
-            name: `persist.runner-event.${event.type}`,
-            op: 'http.client',
-            attributes: {
-                'http.method': 'POST',
-                'http.url': `${apiBaseUrl}/api/runner/events`,
-                'event.type': event.type,
-            },
-        }, async () => {
+        return await (async () => {
             try {
                 const response = await fetch(`${apiBaseUrl}/api/runner/events`, {
                     method: 'POST',
@@ -11440,9 +11289,9 @@ async function startRunner(options = {}) {
             }
             catch (error) {
                 console.error('[runner] Error persisting runner event:', error);
-                throw error; // Re-throw so Sentry span records the error
+                throw error;
             }
-        });
+        })();
     }
     // Event types that trigger DB writes and should be persisted via HTTP
     const DB_WORTHY_RUNNER_EVENTS = [
@@ -11468,16 +11317,6 @@ async function startRunner(options = {}) {
         }
         const sendOperation = () => {
             try {
-                // Attach trace context to ALL events for distributed tracing
-                // This allows events to be linked back to the originating frontend request
-                const span = Sentry.getActiveSpan();
-                if (span) {
-                    const traceData = Sentry.getTraceData();
-                    event._sentry = {
-                        trace: traceData['sentry-trace'],
-                        baggage: traceData.baggage,
-                    };
-                }
                 const eventJson = JSON.stringify(event);
                 // Only log important events
                 if (event.type === "error") {
@@ -11963,7 +11802,6 @@ async function startRunner(options = {}) {
                 break;
             }
             case "start-tunnel": {
-                const tunnelStartTime = Date.now();
                 try {
                     const { port } = command.payload;
                     log(`🔗 Starting tunnel for port ${port}...`);
@@ -11978,15 +11816,6 @@ async function startRunner(options = {}) {
                     // Create tunnel
                     const tunnelUrl = await tunnelManager.createTunnel(port);
                     logger.tunnel({ port, url: tunnelUrl, status: 'created' });
-                    // Instrument tunnel startup timing
-                    const tunnelDuration = Date.now() - tunnelStartTime;
-                    Sentry.metrics.distribution('tunnel_startup_duration', tunnelDuration, {
-                        unit: 'millisecond',
-                        attributes: {
-                            port: port.toString(),
-                            success: 'true'
-                        }
-                    });
                     sendEvent({
                         type: "tunnel-created",
                         ...buildEventBase(command.projectId, command.id),
@@ -11996,16 +11825,6 @@ async function startRunner(options = {}) {
                 }
                 catch (error) {
                     console.error("Failed to create tunnel:", error);
-                    // Instrument failed tunnel startup timing
-                    const tunnelDuration = Date.now() - tunnelStartTime;
-                    Sentry.metrics.distribution('tunnel_startup_duration', tunnelDuration, {
-                        unit: 'millisecond',
-                        attributes: {
-                            port: command.payload.port.toString(),
-                            success: 'false',
-                            error_type: error instanceof Error ? error.constructor.name : 'unknown'
-                        }
-                    });
                     sendEvent({
                         type: "error",
                         ...buildEventBase(command.projectId, command.id),
@@ -12054,7 +11873,8 @@ async function startRunner(options = {}) {
             case "delete-project-files": {
                 try {
                     const { slug } = command.payload;
-                    const projectPath = join(WORKSPACE_ROOT, slug);
+                    // Validates the slug and guarantees the path stays inside the workspace
+                    const projectPath = resolveProjectPath(WORKSPACE_ROOT, slug);
                     console.log(`[runner] 🗑️  Deleting project files for slug: ${slug}`);
                     console.log(`[runner]   Path: ${projectPath}`);
                     // First, stop any running dev server for this project to release file locks
@@ -12126,13 +11946,9 @@ async function startRunner(options = {}) {
             case "read-file": {
                 try {
                     const { slug, filePath } = command.payload;
-                    const projectPath = join(WORKSPACE_ROOT, slug);
-                    const fullPath = join(projectPath, filePath);
+                    const projectPath = resolveProjectPath(WORKSPACE_ROOT, slug);
+                    const fullPath = resolveWithinProject(projectPath, filePath);
                     console.log(`[runner] 📖 Reading file: ${filePath} from project: ${slug}`);
-                    // Security: Ensure path is within project directory
-                    if (!fullPath.startsWith(projectPath)) {
-                        throw new Error("Invalid file path - outside project directory");
-                    }
                     const { readFile, stat } = await import('node:fs/promises');
                     const stats = await stat(fullPath);
                     const content = await readFile(fullPath, "utf-8");
@@ -12160,13 +11976,9 @@ async function startRunner(options = {}) {
             case "write-file": {
                 try {
                     const { slug, filePath, content } = command.payload;
-                    const projectPath = join(WORKSPACE_ROOT, slug);
-                    const fullPath = join(projectPath, filePath);
+                    const projectPath = resolveProjectPath(WORKSPACE_ROOT, slug);
+                    const fullPath = resolveWithinProject(projectPath, filePath);
                     console.log(`[runner] 💾 Writing file: ${filePath} to project: ${slug}`);
-                    // Security: Ensure path is within project directory
-                    if (!fullPath.startsWith(projectPath)) {
-                        throw new Error("Invalid file path - outside project directory");
-                    }
                     const { writeFile } = await import('node:fs/promises');
                     await writeFile(fullPath, content, "utf-8");
                     console.log(`[runner] ✅ File written successfully (${content.length} bytes)`);
@@ -12191,14 +12003,12 @@ async function startRunner(options = {}) {
             case "list-files": {
                 try {
                     const { slug, path: subPath } = command.payload;
-                    const projectPath = join(WORKSPACE_ROOT, slug);
-                    const targetPath = subPath ? join(projectPath, subPath) : projectPath;
+                    const projectPath = resolveProjectPath(WORKSPACE_ROOT, slug);
+                    const targetPath = subPath
+                        ? resolveWithinProject(projectPath, subPath)
+                        : projectPath;
                     console.log(`[runner] 📁 Listing files for project: ${slug}`);
                     console.log(`[runner]   Path: ${targetPath}`);
-                    // Security: Ensure path is within project directory
-                    if (!targetPath.startsWith(projectPath)) {
-                        throw new Error("Invalid path - outside project directory");
-                    }
                     const { readdir, stat } = await import('node:fs/promises');
                     const entries = await readdir(targetPath);
                     const files = await Promise.all(entries.map(async (name) => {
@@ -12241,7 +12051,7 @@ async function startRunner(options = {}) {
                 const model = agent === 'claude-code' &&
                     (claudeModelFromPayload === 'claude-haiku-4-5' ||
                         claudeModelFromPayload === 'claude-sonnet-4-6' ||
-                        claudeModelFromPayload === 'claude-opus-4-6')
+                        claudeModelFromPayload === 'claude-opus-4-8')
                     ? claudeModelFromPayload
                     : DEFAULT_CLAUDE_MODEL_ID;
                 logger.buildReceived({
@@ -12262,7 +12072,6 @@ async function startRunner(options = {}) {
                 fileLog.info("Agent:", command.payload?.agent);
                 fileLog.info("Template:", command.payload?.template);
                 // REMOVED: Manual Sentry span creation - rely on automatic instrumentation
-                // await Sentry.startSpan({ name: "runner.build", op: "ai.build", ... }, async () => {
                 // Build operation (previously wrapped in Sentry span)
                 try {
                     loggedFirstChunk = false;
@@ -12270,9 +12079,11 @@ async function startRunner(options = {}) {
                         throw new Error("Invalid build payload");
                     }
                     // Calculate the project directory using slug
+                    // Slug may be LLM-derived from the user prompt - validate before
+                    // it touches the filesystem
                     const projectSlug = command.payload.projectSlug || command.projectId;
                     const projectName = command.payload.projectName || projectSlug;
-                    const projectDirectory = resolve(WORKSPACE_ROOT, projectSlug);
+                    const projectDirectory = resolveProjectPath(WORKSPACE_ROOT, projectSlug);
                     log("project directory:", projectDirectory);
                     log("project slug:", projectSlug);
                     log("project name:", projectName);
@@ -12283,7 +12094,7 @@ async function startRunner(options = {}) {
                     const claudeModel = agent === "claude-code" &&
                         (command.payload.claudeModel === "claude-haiku-4-5" ||
                             command.payload.claudeModel === "claude-sonnet-4-6" ||
-                            command.payload.claudeModel === "claude-opus-4-6")
+                            command.payload.claudeModel === "claude-opus-4-8")
                         ? command.payload.claudeModel
                         : DEFAULT_CLAUDE_MODEL_ID;
                     // For factory-droid, use the droidModel from payload
@@ -12708,7 +12519,7 @@ async function startRunner(options = {}) {
                     // Detect framework from generated files
                     let detectedFramework = null;
                     try {
-                        const { detectFrameworkFromFilesystem } = await import('./chunks/port-allocator-BENntRMG.js');
+                        const { detectFrameworkFromFilesystem } = await import('./chunks/port-allocator-DAjm7X-F.js');
                         const framework = await detectFrameworkFromFilesystem(projectDirectory);
                         detectedFramework = framework;
                         if (framework) {
@@ -12810,10 +12621,6 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : "Failed to run build";
                     logger.buildFailed(errorMessage);
-                    Sentry.getActiveSpan()?.setStatus({
-                        code: 2, // SPAN_STATUS_ERROR
-                        message: "Build failed",
-                    });
                     sendEvent({
                         type: "build-failed",
                         ...buildEventBase(command.projectId, command.id),
@@ -12836,9 +12643,22 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 // HTTP proxy request - fetch from local dev server and return response
                 try {
                     const { requestId, method, path: reqPath, headers, body, port } = command.payload;
-                    debugLog(`🔀 HTTP proxy request: ${method} ${reqPath} → localhost:${port}`);
+                    // SSRF guard: only proxy to the dev server this runner started for
+                    // this project - never to arbitrary localhost ports
+                    const devServer = getDevServer(command.projectId);
+                    if (!devServer?.port) {
+                        throw new Error(`No active dev server for project ${command.projectId}`);
+                    }
+                    if (port !== undefined && port !== devServer.port) {
+                        throw new Error(`Port ${port} does not match project dev server port ${devServer.port}`);
+                    }
+                    const targetPort = devServer.port;
+                    if (typeof reqPath !== 'string' || !reqPath.startsWith('/')) {
+                        throw new Error(`Invalid proxy path: ${String(reqPath)}`);
+                    }
+                    debugLog(`🔀 HTTP proxy request: ${method} ${reqPath} → localhost:${targetPort}`);
                     // Build the target URL
-                    const targetUrl = `http://localhost:${port}${reqPath}`;
+                    const targetUrl = `http://localhost:${targetPort}${reqPath}`;
                     // Decode body if present
                     const requestBody = body ? Buffer.from(body, 'base64') : undefined;
                     // Fetch from dev server
@@ -12847,7 +12667,7 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                         headers: {
                             ...headers,
                             // Remove hop-by-hop headers
-                            'host': `localhost:${port}`,
+                            'host': `localhost:${targetPort}`,
                         },
                         body: requestBody,
                         // Don't follow redirects - let the client handle them
@@ -12917,8 +12737,33 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
             }
             case "hmr-connect": {
                 // Connect to local HMR WebSocket server
+                // SSRF guard: only connect to the dev server this runner started for
+                // this project - never to an arbitrary server-supplied port
                 const { connectionId, port, protocol } = command.payload;
-                hmrProxyManager.connect(connectionId, port, command.projectId, protocol);
+                const hmrDevServer = getDevServer(command.projectId);
+                // Surface a hmr-error (not a silent break) so the frontend's pending
+                // connection fails fast instead of hanging until its timeout.
+                if (!hmrDevServer?.port) {
+                    console.warn(`[runner] ⚠️  hmr-connect rejected: no active dev server for project ${command.projectId}`);
+                    sendEvent({
+                        type: "hmr-error",
+                        ...buildEventBase(command.projectId, command.id),
+                        connectionId,
+                        error: "No active dev server for project",
+                    });
+                    break;
+                }
+                if (port !== undefined && port !== hmrDevServer.port) {
+                    console.warn(`[runner] ⚠️  hmr-connect rejected: port ${port} does not match dev server port ${hmrDevServer.port}`);
+                    sendEvent({
+                        type: "hmr-error",
+                        ...buildEventBase(command.projectId, command.id),
+                        connectionId,
+                        error: "Requested port does not match the project's dev server",
+                    });
+                    break;
+                }
+                hmrProxyManager.connect(connectionId, hmrDevServer.port, command.projectId, protocol);
                 break;
             }
             case "hmr-message": {
@@ -13115,15 +12960,6 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
             lastCommandReceived = Date.now(); // Reset command timer on new connection
             // Update logger connection status
             logger.setConnected(true);
-            Sentry.logger.info('Runner connected to server', {
-                runnerId: RUNNER_ID,
-                version: getPackageVersion(),
-                user: os$1.userInfo().username,
-                hostname: os$1.hostname(),
-                platform: os$1.platform(),
-                serverUrl: WS_URL,
-                workspace: WORKSPACE_ROOT,
-            });
             debugLog("Health check: ping/pong enabled, command timeout: 5 minutes");
             publishStatus();
             scheduleHeartbeat();
@@ -13164,107 +13000,10 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 const command = JSON.parse(String(data));
                 // BUG FIX: Update lastCommandReceived timestamp
                 lastCommandReceived = Date.now();
-                // Get projectId - analyze-project commands don't have one yet
-                const projectIdForTelemetry = command.type === 'analyze-project'
-                    ? 'pending-analysis'
-                    : command.projectId;
-                // Continue trace from frontend - each build now starts its trace in the frontend
-                // This creates a span within the continued trace for the runner's work
-                if (command._sentry?.trace) {
-                    console.log("[runner] Continuing trace from frontend:", command._sentry.trace.substring(0, 50));
-                    await Sentry.continueTrace({
-                        sentryTrace: command._sentry.trace,
-                        baggage: command._sentry.baggage,
-                    }, async () => {
-                        // Create a span for this command execution within the continued trace
-                        await Sentry.startSpan({
-                            name: `runner.${command.type}`,
-                            op: command.type === 'start-build' ? 'build.runner' : `runner.${command.type}`,
-                            attributes: {
-                                'command.type': command.type,
-                                'command.id': command.id,
-                                'project.id': projectIdForTelemetry,
-                                'trace.continued': true,
-                            },
-                        }, async (span) => {
-                            try {
-                                Sentry.setTag("command_type", command.type);
-                                Sentry.setTag("project_id", projectIdForTelemetry);
-                                Sentry.setTag("command_id", command.id);
-                                // Capture build metrics for start-build commands
-                                if (command.type === 'start-build' && command.payload) {
-                                    const agent = command.payload.agent ?? 'claude-code';
-                                    const claudeModel = agent === 'claude-code' &&
-                                        (command.payload.claudeModel === 'claude-haiku-4-5' ||
-                                            command.payload.claudeModel === 'claude-sonnet-4-6' ||
-                                            command.payload.claudeModel === 'claude-opus-4-6')
-                                        ? command.payload.claudeModel
-                                        : 'claude-sonnet-4-6';
-                                    Sentry.metrics.count('runner.build.started', 1, {
-                                        attributes: {
-                                            project_id: command.projectId,
-                                            model: agent === 'claude-code' ? claudeModel : agent,
-                                            framework: command.payload.template?.framework || 'unknown',
-                                            operation_type: command.payload.operationType || 'initial-build',
-                                        }
-                                    });
-                                }
-                                await handleCommand(command);
-                            }
-                            catch (error) {
-                                span.setStatus({ code: 2, message: error instanceof Error ? error.message : 'Command failed' });
-                                throw error;
-                            }
-                        });
-                    });
-                }
-                else {
-                    console.log("[runner] No trace context - starting isolated span");
-                    // Create an isolated span when no trace context is provided
-                    await Sentry.startSpan({
-                        name: `runner.${command.type}`,
-                        op: command.type === 'start-build' ? 'build.runner' : `runner.${command.type}`,
-                        attributes: {
-                            'command.type': command.type,
-                            'command.id': command.id,
-                            'project.id': projectIdForTelemetry,
-                            'trace.continued': false,
-                        },
-                    }, async (span) => {
-                        try {
-                            Sentry.setTag("command_type", command.type);
-                            Sentry.setTag("project_id", projectIdForTelemetry);
-                            Sentry.setTag("command_id", command.id);
-                            // Capture build metrics for start-build commands
-                            if (command.type === 'start-build' && command.payload) {
-                                const agent = command.payload.agent ?? 'claude-code';
-                                const claudeModel = agent === 'claude-code' &&
-                                    (command.payload.claudeModel === 'claude-haiku-4-5' ||
-                                        command.payload.claudeModel === 'claude-sonnet-4-6' ||
-                                        command.payload.claudeModel === 'claude-opus-4-6')
-                                    ? command.payload.claudeModel
-                                    : 'claude-sonnet-4-6';
-                                Sentry.metrics.count('runner.build.started', 1, {
-                                    attributes: {
-                                        project_id: command.projectId,
-                                        model: agent === 'claude-code' ? claudeModel : agent,
-                                        framework: command.payload.template?.framework || 'unknown',
-                                        operation_type: command.payload.operationType || 'initial-build',
-                                    }
-                                });
-                            }
-                            await handleCommand(command);
-                        }
-                        catch (error) {
-                            span.setStatus({ code: 2, message: error instanceof Error ? error.message : 'Command failed' });
-                            throw error;
-                        }
-                    });
-                }
+                await handleCommand(command);
             }
             catch (error) {
                 console.error("Failed to parse command", error);
-                Sentry.captureException(error);
                 sendEvent({
                     type: "error",
                     ...buildEventBase(undefined, randomUUID$1()),
@@ -13355,8 +13094,6 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
         await stopAllDevServers(tunnelManager);
         // Final cleanup of any remaining tunnels
         await tunnelManager.closeAll();
-        // Flush Sentry events before exiting
-        await Sentry.flush(2000);
         log("shutdown complete");
     };
     process.on("SIGINT", async () => {