@buildautomaton/cli 0.1.58 → 0.1.60

package/dist/cli.js

@@ -973,7 +973,7 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path75 = __require("node:path");
+    var path76 = __require("node:path");
     var fs53 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1906,9 +1906,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path75.resolve(baseDir, baseName);
+          const localBin = path76.resolve(baseDir, baseName);
           if (fs53.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path75.extname(baseName))) return void 0;
+          if (sourceExt.includes(path76.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs53.existsSync(`${localBin}${ext}`)
           );
@@ -1926,17 +1926,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path75.resolve(
-            path75.dirname(resolvedScriptPath),
+          executableDir = path76.resolve(
+            path76.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path75.basename(
+            const legacyName = path76.basename(
               this._scriptPath,
-              path75.extname(this._scriptPath)
+              path76.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path75.extname(executableFile));
+        launchWithNode = sourceExt.includes(path76.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path75.basename(filename, path75.extname(filename));
+        this._name = path76.basename(filename, path76.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path76) {
-        if (path76 === void 0) return this._executableDir;
-        this._executableDir = path76;
+      executableDir(path77) {
+        if (path77 === void 0) return this._executableDir;
+        this._executableDir = path77;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path75, errorMaps, issueData } = params;
-      const fullPath = [...path75, ...issueData.path || []];
+      const { data, path: path76, errorMaps, issueData } = params;
+      const fullPath = [...path76, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path75, key) {
+      constructor(parent, value, path76, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path75;
+        this._path = path76;
         this._key = key;
       }
       get path() {
@@ -11099,10 +11099,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path75) {
-  if (!path75)
+function getElementAtPath(obj, path76) {
+  if (!path76)
     return obj;
-  return path75.reduce((acc, key) => acc?.[key], obj);
+  return path76.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11351,11 +11351,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path75, issues) {
+function prefixIssues(path76, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path75);
+    iss.path.unshift(path76);
     return iss;
   });
 }
@@ -11544,7 +11544,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path75 = []) => {
+  const processError = (error41, path76 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -11554,7 +11554,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path75, ...issue2.path];
+        const fullpath = [...path76, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -11584,9 +11584,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path75) {
+function toDotPath(path76) {
   const segs = [];
-  for (const seg of path75) {
+  for (const seg of path76) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24592,7 +24592,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path75, checkUnignored, mode) {
+      test(path76, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -24601,7 +24601,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path75);
+          const matched = rule[mode].test(path76);
           if (!matched) {
             return;
           }
@@ -24622,17 +24622,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path75, originalPath, doThrow) => {
-      if (!isString(path75)) {
+    var checkPath = (path76, originalPath, doThrow) => {
+      if (!isString(path76)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path75) {
+      if (!path76) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path75)) {
+      if (checkPath.isNotRelative(path76)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -24641,7 +24641,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path75) => REGEX_TEST_INVALID_PATH.test(path75);
+    var isNotRelative = (path76) => REGEX_TEST_INVALID_PATH.test(path76);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -24671,19 +24671,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path75 = originalPath && checkPath.convert(originalPath);
+        const path76 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path75,
+          path76,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path75, cache2, checkUnignored, slices);
+        return this._t(path76, cache2, checkUnignored, slices);
       }
-      checkIgnore(path75) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path75)) {
-          return this.test(path75);
+      checkIgnore(path76) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path76)) {
+          return this.test(path76);
         }
-        const slices = path75.split(SLASH).filter(Boolean);
+        const slices = path76.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -24696,18 +24696,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path75, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path76, false, MODE_CHECK_IGNORE);
       }
-      _t(path75, cache2, checkUnignored, slices) {
-        if (path75 in cache2) {
-          return cache2[path75];
+      _t(path76, cache2, checkUnignored, slices) {
+        if (path76 in cache2) {
+          return cache2[path76];
         }
         if (!slices) {
-          slices = path75.split(SLASH).filter(Boolean);
+          slices = path76.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path75] = this._rules.test(path75, checkUnignored, MODE_IGNORE);
+          return cache2[path76] = this._rules.test(path76, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -24715,29 +24715,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path75] = parent.ignored ? parent : this._rules.test(path75, checkUnignored, MODE_IGNORE);
+        return cache2[path76] = parent.ignored ? parent : this._rules.test(path76, checkUnignored, MODE_IGNORE);
       }
-      ignores(path75) {
-        return this._test(path75, this._ignoreCache, false).ignored;
+      ignores(path76) {
+        return this._test(path76, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path75) => !this.ignores(path75);
+        return (path76) => !this.ignores(path76);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path75) {
-        return this._test(path75, this._testCache, true);
+      test(path76) {
+        return this._test(path76, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path75) => checkPath(path75 && checkPath.convert(path75), path75, RETURN_FALSE);
+    var isPathValid = (path76) => checkPath(path76 && checkPath.convert(path76), path76, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path75) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path75) || isNotRelative(path75);
+      checkPath.isNotRelative = (path76) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path76) || isNotRelative(path76);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -25526,10 +25526,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path75, isFile, isDirectory) {
-      log2(`checking %s`, path75);
+    function check2(path76, isFile, isDirectory) {
+      log2(`checking %s`, path76);
       try {
-        const stat3 = fs_1.statSync(path75);
+        const stat3 = fs_1.statSync(path76);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -25549,8 +25549,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path75, type = exports.READABLE) {
-      return check2(path75, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path76, type = exports.READABLE) {
+      return check2(path76, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -25631,7 +25631,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.58".length > 0 ? "0.1.58" : "0.0.0-dev";
+var CLI_VERSION = "0.1.60".length > 0 ? "0.1.60" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -25639,7 +25639,7 @@ var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
 import * as fs52 from "node:fs";
-import * as path74 from "node:path";
+import * as path75 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -27439,8 +27439,8 @@ function runPendingAuth(options) {
   };
 }
 
-// src/dev-servers/manager/dev-server-constants.ts
-var BRIDGE_CLOSE_DEV_SERVER_GRACE_MS = 0;
+// src/preview-environments/manager/preview-environment-constants.ts
+var BRIDGE_CLOSE_PREVIEW_ENVIRONMENT_GRACE_MS = 0;
 var BRIDGE_SHUTDOWN_GRACE_MS = 8e3;
 
 // src/runtime/cli-process-interrupt.ts
@@ -27859,7 +27859,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join2(moduleDir, "..", sub, filename),
     join2(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path75) => existsSync(path75));
+  const resolved = candidates.find((path76) => existsSync(path76));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -28147,7 +28147,7 @@ async function ensureCodeNavCacheSqliteInitialized() {
 }
 
 // src/connection/close-bridge-connection.ts
-async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
+async function closeBridgeConnection(state, acpManager, previewEnvironmentManager, log2) {
   requestCliImmediateShutdown();
   const say = log2 ?? logImmediate;
   say("Cleaning up connections\u2026");
@@ -28185,9 +28185,9 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
     }
     state.currentWs = null;
   }
-  if (devServerManager) {
-    say("Stopping local dev server processes\u2026");
-    await devServerManager.shutdownAllGraceful({ graceMs: BRIDGE_CLOSE_DEV_SERVER_GRACE_MS });
+  if (previewEnvironmentManager) {
+    say("Stopping local preview environment processes\u2026");
+    await previewEnvironmentManager.shutdownAllGraceful({ graceMs: BRIDGE_CLOSE_PREVIEW_ENVIRONMENT_GRACE_MS });
   }
   try {
     closeAllCliSqliteConnections();
@@ -28888,9 +28888,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path75 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path75) continue;
-    rows.push({ path: path75, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path76 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path76) continue;
+    rows.push({ path: path76, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -35246,8 +35246,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path75) {
-  return path75.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path76) {
+  return path76.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -35534,9 +35534,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path75, summary }) => {
+  const entries = params.rows.map(({ path: path76, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path75, summary: JSON.stringify(enc) };
+    return { path: path76, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -36569,8 +36569,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path75) {
-  return path75 instanceof String && cache.has(path75);
+function isPathSpec(path76) {
+  return path76 instanceof String && cache.has(path76);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -36659,8 +36659,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path75) {
-  return (0, import_file_exists.exists)(path75, import_file_exists.FOLDER);
+function folderExists(path76) {
+  return (0, import_file_exists.exists)(path76, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -37064,8 +37064,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path75) {
-      return /^\.(git)?$/.test(path75.trim());
+    parser(path76) {
+      return /^\.(git)?$/.test(path76.trim());
     }
   };
 }
@@ -37499,11 +37499,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path75, line, preview] = input.split(NULL);
-    paths.add(path75);
-    (results[path75] = results[path75] || []).push({
+    const [path76, line, preview] = input.split(NULL);
+    paths.add(path76);
+    (results[path76] = results[path76] || []).push({
       line: asNumber(line),
-      path: path75,
+      path: path76,
       preview
     });
   });
@@ -38268,14 +38268,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path75, text) {
+function parseInit(bare, path76, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path75, false, result[1]);
+    return new InitSummary(bare, path76, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path75, true, result[1]);
+    return new InitSummary(bare, path76, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -38286,7 +38286,7 @@ function parseInit(bare, path75, text) {
       break;
     }
   }
-  return new InitSummary(bare, path75, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path76, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -38295,9 +38295,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path75, existing, gitDir) {
+      constructor(bare, path76, existing, gitDir) {
         this.bare = bare;
-        this.path = path75;
+        this.path = path76;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -38309,7 +38309,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path75, customArgs) {
+function initTask(bare = false, path76, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -38318,7 +38318,7 @@ function initTask(bare = false, path75, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path75, text);
+      return parseInit(commands.includes("--bare"), path76, text);
     }
   };
 }
@@ -39134,12 +39134,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path75, index, working_dir) {
-        this.path = path75;
+      constructor(path76, index, working_dir) {
+        this.path = path76;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path75) || [null, path75, path75];
+          const detail = fromPathRegex.exec(path76) || [null, path76, path76];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -39170,14 +39170,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path75) {
+  function data(index, workingDir, path76) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path75);
+      handler(result, path76);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path75, index, workingDir));
+      result.files.push(new FileStatusSummary(path76, index, workingDir));
     }
   }
 }
@@ -39486,9 +39486,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path75, write) {
+      hashObject(path76, write) {
         return this._runTask(
-          hashObjectTask(path75, write === true),
+          hashObjectTask(path76, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -39841,8 +39841,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path75 = input.trim().replace(/^["']|["']$/g, "");
-  return path75 && normalize3(path75);
+  const path76 = input.trim().replace(/^["']|["']$/g, "");
+  return path76 && normalize3(path76);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -40156,8 +40156,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path75) {
-  return subModuleTask(["add", repo, path75]);
+function addSubModuleTask(repo, path76) {
+  return subModuleTask(["add", repo, path76]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -40490,8 +40490,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path75, then) {
-      return this._runTask(addSubModuleTask2(repo, path75), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path76, then) {
+      return this._runTask(addSubModuleTask2(repo, path76), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -41227,8 +41227,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path75, entry] of parseNumstatEntries(lines)) {
-    m.set(path75, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path76, entry] of parseNumstatEntries(lines)) {
+    m.set(path76, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -42535,18 +42535,32 @@ import * as fs28 from "node:fs";
 // src/git/worktrees/worktree-remove.ts
 import * as fs27 from "node:fs";
 
+// src/worktrees/is-removable-session-worktree-checkout-path.ts
+import path43 from "node:path";
+function isBridgeRootCheckoutPath(checkoutPath) {
+  return normalizeResolvedPath(checkoutPath) === normalizeResolvedPath(getBridgeRoot());
+}
+function isRemovableSessionWorktreeCheckoutPath(checkoutPath, worktreesRootPath) {
+  if (isBridgeRootCheckoutPath(checkoutPath)) return false;
+  const normalized = normalizeResolvedPath(checkoutPath);
+  const worktreesRoot = normalizeResolvedPath(worktreesRootPath);
+  const rel = path43.relative(worktreesRoot, normalized);
+  if (rel === "" || rel.startsWith("..") || path43.isAbsolute(rel)) return false;
+  return true;
+}
+
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
 import * as fs26 from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path43.join(wt, ".git");
+  const gitDirFile = path44.join(wt, ".git");
   if (!fs26.existsSync(gitDirFile) || !fs26.statSync(gitDirFile).isFile()) return "";
   const first2 = fs26.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path43.resolve(wt, m[1].trim());
-  const gitDir = path43.dirname(path43.dirname(gitWorktreePath));
-  return path43.dirname(gitDir);
+  const gitWorktreePath = path44.resolve(wt, m[1].trim());
+  const gitDir = path44.dirname(path44.dirname(gitWorktreePath));
+  return path44.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -42554,32 +42568,44 @@ async function gitWorktreeRemoveForce(worktreePath) {
   const mainRepo = resolveMainRepoFromWorktreeGitFile(worktreePath);
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
-  } else {
-    fs27.rmSync(worktreePath, { recursive: true, force: true });
+    return true;
   }
+  if (isBridgeRootCheckoutPath(worktreePath)) return false;
+  fs27.rmSync(worktreePath, { recursive: true, force: true });
+  return true;
 }
 
 // src/worktrees/remove-session-worktrees.ts
-async function removeSessionWorktrees(paths, log2) {
+async function removeSessionWorktrees(paths, worktreesRootPath, log2) {
   for (const wt of paths) {
+    if (!isRemovableSessionWorktreeCheckoutPath(wt, worktreesRootPath)) {
+      log2(`[worktrees] Skipping removal of ${wt} (bridge root or outside worktrees root).`);
+      continue;
+    }
     try {
-      await gitWorktreeRemoveForce(wt);
-      log2(`[worktrees] Removed worktree ${wt}`);
+      const removed = await gitWorktreeRemoveForce(wt);
+      if (removed) {
+        log2(`[worktrees] Removed worktree ${wt}`);
+      } else {
+        log2(`[worktrees] Skipping removal of ${wt} (bridge root).`);
+      }
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
-      try {
-        fs28.rmSync(wt, { recursive: true, force: true });
-      } catch {
+      if (isRemovableSessionWorktreeCheckoutPath(wt, worktreesRootPath)) {
+        try {
+          fs28.rmSync(wt, { recursive: true, force: true });
+        } catch {
+        }
       }
     }
   }
 }
 
 // src/worktrees/manager/git/remove-session-worktree-checkouts.ts
-async function removeSessionWorktreeCheckouts(cache2, sessionId, log2) {
+async function removeSessionWorktreeCheckouts(cache2, sessionId, worktreesRootPath, log2) {
   const paths = cache2.clearSession(sessionId);
   if (!paths?.length) return;
-  await removeSessionWorktrees(paths, log2);
+  await removeSessionWorktrees(paths, worktreesRootPath, log2);
 }
 
 // src/git/branches/rename-branch.ts
@@ -42612,11 +42638,11 @@ async function renameSessionWorktreeBranch(cache2, sessionId, newBranch, log2) {
 
 // src/worktrees/discovery/discover-session-worktree-on-disk.ts
 import * as fs32 from "node:fs";
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 
 // src/worktrees/discovery/collect-worktree-paths.ts
 import * as fs30 from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 
 // src/worktrees/discovery/disk-walk-constants.ts
 var DISK_WALK_YIELD_EVERY = 64;
@@ -42645,7 +42671,7 @@ function shouldSkipDiskWalkEntry(name) {
 
 // src/worktrees/discovery/disk-walk-utils.ts
 import * as fs29 from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 async function yieldDuringDiskWalk(state) {
   state.entries++;
   if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
@@ -42655,7 +42681,7 @@ async function yieldDuringDiskWalk(state) {
 }
 async function isGitDir(dirPath) {
   try {
-    await fs29.promises.access(path44.join(dirPath, ".git"));
+    await fs29.promises.access(path45.join(dirPath, ".git"));
     return true;
   } catch {
     return false;
@@ -42669,7 +42695,7 @@ async function collectGitRepoRootsUnderDirectory(rootPath) {
   const walk = async (dir) => {
     if (!await yieldDuringDiskWalk(state)) return;
     if (await isGitDir(dir)) {
-      out.push(path45.resolve(dir));
+      out.push(path46.resolve(dir));
       return;
     }
     let entries;
@@ -42680,12 +42706,12 @@ async function collectGitRepoRootsUnderDirectory(rootPath) {
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path45.join(dir, e.name);
+      const full = path46.join(dir, e.name);
       if (!e.isDirectory()) continue;
       await walk(full);
     }
   };
-  await walk(path45.resolve(rootPath));
+  await walk(path46.resolve(rootPath));
   return { paths: [...new Set(out)], entriesVisited: state.entries };
 }
 async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK_MAX_DEPTH) {
@@ -42702,10 +42728,10 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path45.join(dir, e.name);
+      const full = path46.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (await isGitDir(full)) out.push(path45.resolve(full));
+        if (await isGitDir(full)) out.push(path46.resolve(full));
         continue;
       }
       if (await isGitDir(full)) continue;
@@ -42717,14 +42743,14 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
 }
 
 // src/worktrees/discovery/layout-keys-for-bridge-root.ts
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
-  const bridge = path46.resolve(bridgeRoot);
+  const bridge = path47.resolve(bridgeRoot);
   const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const relevant = layout.launcherCwds.filter((e) => {
-    const entry = path46.resolve(e.absolutePath);
-    return bridge === entry || bridge.startsWith(entry + path46.sep) || entry.startsWith(bridge + path46.sep);
-  }).sort((a, b) => path46.resolve(b.absolutePath).length - path46.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
+    const entry = path47.resolve(e.absolutePath);
+    return bridge === entry || bridge.startsWith(entry + path47.sep) || entry.startsWith(bridge + path47.sep);
+  }).sort((a, b) => path47.resolve(b.absolutePath).length - path47.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
   const ordered = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (k) => {
@@ -42743,7 +42769,7 @@ function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
 
 // src/worktrees/discovery/try-binding-from-session-directory.ts
 import * as fs31 from "node:fs";
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 async function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
@@ -42754,7 +42780,7 @@ async function tryBindingFromSessionDirectory(sessionDir) {
   if (!st.isDirectory()) return null;
   const { paths: worktreePaths } = await collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path47.resolve(sessionDir);
+  const abs = path48.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -42778,7 +42804,7 @@ async function discoverSessionWorktreeOnDisk(options) {
   try {
     for (const name of await fs32.promises.readdir(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path48.join(worktreesRootPath, name);
+      const p = path49.join(worktreesRootPath, name);
       let st;
       try {
         st = await fs32.promises.stat(p);
@@ -42795,7 +42821,7 @@ async function discoverSessionWorktreeOnDisk(options) {
   for (const key of keys) {
     if (isCliImmediateShutdownRequested()) return null;
     await yieldToEventLoop();
-    const layoutRoot = path48.join(worktreesRootPath, key);
+    const layoutRoot = path49.join(worktreesRootPath, key);
     let layoutSt;
     try {
       layoutSt = await fs32.promises.stat(layoutRoot);
@@ -42803,16 +42829,16 @@ async function discoverSessionWorktreeOnDisk(options) {
       continue;
     }
     if (!layoutSt.isDirectory()) continue;
-    const sessionDir = path48.join(layoutRoot, sid);
+    const sessionDir = path49.join(layoutRoot, sid);
     const nested = await tryBindingFromSessionDirectory(sessionDir);
     if (nested) return nested;
     const legacy = await collectWorktreeRootsNamed(layoutRoot, sid);
     if (legacy.paths.length > 0) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path48.resolve(legacy.paths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path49.resolve(legacy.paths[0]);
       return {
-        sessionParentPath: path48.resolve(isolated),
-        workingTreeRelRoot: path48.resolve(layoutRoot),
-        repoCheckoutPaths: legacy.paths.map((p) => path48.resolve(p))
+        sessionParentPath: path49.resolve(isolated),
+        workingTreeRelRoot: path49.resolve(layoutRoot),
+        repoCheckoutPaths: legacy.paths.map((p) => path49.resolve(p))
       };
     }
   }
@@ -42821,29 +42847,29 @@ async function discoverSessionWorktreeOnDisk(options) {
 
 // src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
 import * as fs33 from "node:fs";
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 
 // src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path49.resolve(checkoutPath);
+  const hintR = path50.resolve(checkoutPath);
   let best = null;
-  let cur = path49.dirname(hintR);
+  let cur = path50.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     if (isCliImmediateShutdownRequested()) return best;
     await yieldToEventLoop();
     const paths = await collectWorktreeRootsNamed(cur, sid);
-    if (paths.paths.some((p) => path49.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path49.resolve(paths.paths[0]);
+    if (paths.paths.some((p) => path50.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path50.resolve(paths.paths[0]);
       best = {
-        sessionParentPath: path49.resolve(isolated),
-        workingTreeRelRoot: path49.resolve(cur),
-        repoCheckoutPaths: paths.paths.map((p) => path49.resolve(p))
+        sessionParentPath: path50.resolve(isolated),
+        workingTreeRelRoot: path50.resolve(cur),
+        repoCheckoutPaths: paths.paths.map((p) => path50.resolve(p))
       };
     }
-    const next = path49.dirname(cur);
+    const next = path50.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -42854,12 +42880,12 @@ async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPat
 async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path50.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = await tryBindingFromSessionDirectory(path50.join(hint, sid));
+  const hint = path51.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = await tryBindingFromSessionDirectory(path51.join(hint, sid));
   if (underHint) return underHint;
   const direct = await tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path50.basename(hint) === sid && await isGitDir(hint)) {
+    if (path51.basename(hint) === sid && await isGitDir(hint)) {
       const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -42867,7 +42893,7 @@ async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeR
     }
     return direct;
   }
-  if (path50.basename(hint) === sid && await isGitDir(hint)) {
+  if (path51.basename(hint) === sid && await isGitDir(hint)) {
     const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
@@ -42880,11 +42906,11 @@ async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeR
   if (!st.isDirectory()) return null;
   const legacyPaths = await collectWorktreeRootsNamed(hint, sid);
   if (legacyPaths.paths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path50.resolve(legacyPaths.paths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path51.resolve(legacyPaths.paths[0]);
   return {
-    sessionParentPath: path50.resolve(isolated),
+    sessionParentPath: path51.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.paths.map((p) => path50.resolve(p))
+    repoCheckoutPaths: legacyPaths.paths.map((p) => path51.resolve(p))
   };
 }
 
@@ -42946,11 +42972,11 @@ function parseSessionParent(v) {
 
 // src/worktrees/prepare-new-session-worktrees.ts
 import * as fs35 from "node:fs";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 
 // src/git/discover-repos.ts
 import * as fs34 from "node:fs";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 var GIT_DISCOVER_YIELD_EVERY = 32;
 async function yieldGitDiscoverWork(entryCount) {
   if (entryCount > 0 && entryCount % GIT_DISCOVER_YIELD_EVERY === 0) {
@@ -42959,7 +42985,7 @@ async function yieldGitDiscoverWork(entryCount) {
 }
 async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
-  const cwdResolved = path51.resolve(cwd);
+  const cwdResolved = path52.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
@@ -42974,7 +43000,7 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
     await yieldGitDiscoverWork(i + 1);
     const ent = entries[i];
     if (!ent.isDirectory()) continue;
-    const childPath2 = path51.join(cwdResolved, ent.name);
+    const childPath2 = path52.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath2)) {
       const remoteUrl = await getRemoteOriginUrl(childPath2);
       result.push({ absolutePath: childPath2, remoteUrl });
@@ -42983,12 +43009,12 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootPath) {
-  const root = path51.resolve(rootPath);
+  const root = path52.resolve(rootPath);
   const roots = [];
   let walkEntries = 0;
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path51.resolve(dir));
+      roots.push(path52.resolve(dir));
       return;
     }
     let entries;
@@ -43001,7 +43027,7 @@ async function discoverGitReposUnderRoot(rootPath) {
       await yieldGitDiscoverWork(++walkEntries);
       const ent = entries[i];
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path51.join(dir, ent.name));
+      await walk(path52.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -43036,10 +43062,10 @@ function resolveBaseRefForRepo(relNorm, baseBranches) {
 }
 async function prepareNewSessionWorktrees(options) {
   const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
-  const bridgeResolved = path52.resolve(bridgeRoot);
+  const bridgeResolved = path53.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path52.join(worktreesRootPath, cwdKey);
-  const sessionDir = path52.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path53.join(worktreesRootPath, cwdKey);
+  const sessionDir = path53.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -43049,12 +43075,12 @@ async function prepareNewSessionWorktrees(options) {
   const worktreePaths = [];
   fs35.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path52.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path52.isAbsolute(rel)) continue;
+    let rel = path53.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path53.isAbsolute(rel)) continue;
     const relNorm = normalizeRepoRelPath2(rel === "" ? "." : rel);
-    const wtPath = relNorm === "." ? sessionDir : path52.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path53.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs35.mkdirSync(path52.dirname(wtPath), { recursive: true });
+      fs35.mkdirSync(path53.dirname(wtPath), { recursive: true });
     }
     const baseRef = resolveBaseRefForRepo(relNorm, worktreeBaseBranches);
     try {
@@ -43107,9 +43133,9 @@ async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 }
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 async function resolveExplicitSessionParentPath(params) {
-  const resolved = path53.resolve(params.parentPathRaw);
+  const resolved = path54.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
     return resolved;
   }
@@ -43126,7 +43152,7 @@ async function resolveExplicitSessionParentPath(params) {
     await yieldToEventLoop();
     const tryRoot = await discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
     if (tryRoot) return rememberAndReturn(tryRoot);
-    const next = path53.dirname(cur);
+    const next = path54.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -43236,7 +43262,7 @@ function createSessionWorktreeGitApi(ctx) {
       await renameSessionWorktreeBranch(ctx.cache, sessionId, newBranch, ctx.log);
     },
     async removeSessionWorktrees(sessionId) {
-      await removeSessionWorktreeCheckouts(ctx.cache, sessionId, ctx.log);
+      await removeSessionWorktreeCheckouts(ctx.cache, sessionId, ctx.worktreesRootPath, ctx.log);
     },
     async commitSession(params) {
       return commitSessionWorktree(ctx.cache, params);
@@ -43265,17 +43291,17 @@ var SessionWorktreeManager = class {
 };
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 import os9 from "node:os";
 function defaultWorktreesRootPath() {
-  return path54.join(os9.homedir(), ".buildautomaton", "worktrees");
+  return path55.join(os9.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
-import path59 from "node:path";
+import path60 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path55 from "node:path";
+import path56 from "node:path";
 
 // src/files/index/file-index-sqlite-lock.ts
 var fileIndexChain = Promise.resolve();
@@ -43366,7 +43392,7 @@ function assertNotShutdown2() {
   if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path55.resolve(cwd);
+  const resolved = path56.resolve(cwd);
   await yieldToEventLoop();
   assertNotShutdown2();
   const paths = await collectWorkspacePathsAsync(resolved);
@@ -43379,7 +43405,7 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path56 from "node:path";
+import path57 from "node:path";
 
 // src/files/index/search-file-index.ts
 function escapeLikePattern(fragment) {
@@ -43431,7 +43457,7 @@ async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
 
 // src/files/index/ensure-file-index.ts
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path56.resolve(cwd);
+  const resolved = path57.resolve(cwd);
   if (await bridgeFileIndexIsPopulated(resolved)) {
     return { fromCache: true, pathCount: await bridgeFileIndexPathCount(resolved) };
   }
@@ -43480,10 +43506,10 @@ function createFileIndexFsWatcher(resolved, schedule) {
 
 // src/files/index/file-index-incremental-symbol-updates.ts
 import fs36 from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
   for (const rel of relPaths) {
-    const absPath = path57.join(resolved, rel);
+    const absPath = path58.join(resolved, rel);
     try {
       const stat3 = await fs36.promises.stat(absPath);
       if (stat3.isFile()) {
@@ -43503,9 +43529,9 @@ async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
 }
 
 // src/files/index/file-index-initial-builds.ts
-import path58 from "node:path";
+import path59 from "node:path";
 async function runInitialIndexBuilds(cwd = getBridgeRoot()) {
-  const resolved = path58.resolve(cwd);
+  const resolved = path59.resolve(cwd);
   try {
     await buildFileIndexAsync(resolved);
     await buildSymbolIndexAsync(resolved);
@@ -43523,7 +43549,7 @@ function scheduleInitialIndexBuilds(cwd = getBridgeRoot()) {
 // src/files/watch-file-index.ts
 var MAX_INCREMENTAL_SYMBOL_UPDATES = 512;
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path59.resolve(cwd);
+  const resolved = path60.resolve(cwd);
   let timer = null;
   const pendingSymbolUpdates = /* @__PURE__ */ new Set();
   let needsFullSymbolRebuild = false;
@@ -43585,14 +43611,14 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 
-// src/dev-servers/manager/dev-server-manager.ts
+// src/preview-environments/manager/preview-environment-manager.ts
 import { rm as rm2 } from "node:fs/promises";
 
-// src/dev-servers/process/send-server-status.ts
-function sendDevServerStatus(getWs, serverId, status, options) {
-  const payload = { type: "server_status", serverId, status };
+// src/preview-environments/process/send-preview-environment-status.ts
+function sendPreviewEnvironmentStatus(getWs, environmentId, status, options) {
+  const payload = { type: "preview_environment_status", environmentId, status };
   if (options?.detail) payload.detail = options.detail;
   if (options?.tails) {
     payload.stdoutTail = options.tails.stdout;
@@ -43605,12 +43631,12 @@ function sendDevServerStatus(getWs, serverId, status, options) {
   });
 }
 
-// src/dev-servers/process/terminate-child-process.ts
+// src/preview-environments/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
   const exited = new Promise((resolve34) => {
     proc.once("exit", () => resolve34());
   });
-  log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
+  log2(`[preview-environment] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
@@ -43619,7 +43645,7 @@ async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
-    `[dev-server] ${shortId} did not exit within ${graceMs}ms; sending SIGKILL (pid=${proc.pid ?? "?"}).`
+    `[preview-environment] ${shortId} did not exit within ${graceMs}ms; sending SIGKILL (pid=${proc.pid ?? "?"}).`
   );
   proc.removeAllListeners();
   try {
@@ -43628,10 +43654,10 @@ function forceKillChild(proc, log2, shortId, graceMs) {
   }
 }
 
-// src/dev-servers/process/wire-dev-server-child-process.ts
+// src/preview-environments/process/wire-preview-environment-child-process.ts
 import fs37 from "node:fs";
 
-// src/dev-servers/manager/forward-pipe.ts
+// src/preview-environments/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
   if (!childReadable) return;
   childReadable.on("data", (chunk) => {
@@ -43647,16 +43673,16 @@ function forwardChildPipe(childReadable, terminal, onData) {
   });
 }
 
-// src/dev-servers/process/wire-dev-server-child-process.ts
-function wireDevServerChildProcess(d) {
-  const { proc, serverId, title } = d;
+// src/preview-environments/process/wire-preview-environment-child-process.ts
+function wirePreviewEnvironmentChildProcess(d) {
+  const { proc, environmentId, title } = d;
   forwardChildPipe(proc.stdout, null, (chunk) => {
     d.stdoutTail.push(chunk);
-    d.pushRemoteLogChunk(serverId, "stdout", chunk);
+    d.pushRemoteLogChunk(environmentId, "stdout", chunk);
   });
   forwardChildPipe(proc.stderr, null, (chunk) => {
     d.stderrTail.push(chunk);
-    d.pushRemoteLogChunk(serverId, "stderr", chunk);
+    d.pushRemoteLogChunk(environmentId, "stderr", chunk);
   });
   if (d.mergedLogPath && d.mergedCleanupDir) {
     const pollIv = setInterval(() => {
@@ -43672,7 +43698,7 @@ function wireDevServerChildProcess(d) {
         d.mergedReadPos.value = buf.length;
         if (chunk.length === 0) return;
         d.stdoutTail.push(chunk);
-        d.pushRemoteLogChunk(serverId, "stdout", chunk);
+        d.pushRemoteLogChunk(environmentId, "stdout", chunk);
       });
     }, 100);
     d.setPollInterval(pollIv);
@@ -43690,10 +43716,10 @@ function wireDevServerChildProcess(d) {
         d.rmMergedCleanupDir(cleanupDir);
       }
       if (signal) {
-        d.log(`[dev-server] ${title} stopped (signal: ${String(signal)}).`);
+        d.log(`[preview-environment] ${title} stopped (signal: ${String(signal)}).`);
       } else if (code !== null && code !== 0) {
         const errTail = d.stderrTail.getTail().slice(-3).join("\n");
-        d.log(`[dev-server] ${title} exited with code ${code}${errTail ? `
+        d.log(`[preview-environment] ${title} exited with code ${code}${errTail ? `
 ${errTail}` : ""}`);
       }
       d.detachProcessFromManager();
@@ -43708,7 +43734,7 @@ ${errTail}` : ""}`);
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
             d.stdoutTail.push(chunk);
-            d.pushRemoteLogChunk(serverId, "stdout", chunk);
+            d.pushRemoteLogChunk(environmentId, "stdout", chunk);
           }
         }
         finishExit();
@@ -43732,12 +43758,12 @@ ${errTail}` : ""}`);
     d.clearTailBuffers();
     const msg = err instanceof Error ? err.message : String(err);
     const errno = typeof err === "object" && err && "code" in err ? String(err.code) : "";
-    d.log(`[dev-server] ${title} process error: ${msg}${errno ? ` (${errno})` : ""}`);
+    d.log(`[preview-environment] ${title} process error: ${msg}${errno ? ` (${errno})` : ""}`);
     d.sendStatus("error", msg, tails);
   });
 }
 
-// src/dev-servers/manager/dev-server-env.ts
+// src/preview-environments/manager/preview-environment-env.ts
 function substituteCommand(cmd, env) {
   return cmd.replace(/\$\{([^}]+)\}/g, (_, key) => env[key] != null ? String(env[key]) : "");
 }
@@ -43773,15 +43799,15 @@ function envForSpawn(base, userEnv, ports) {
   return out;
 }
 
-// src/dev-servers/manager/parse-config.ts
-function parseDevServerDefs(servers) {
+// src/preview-environments/manager/parse-config.ts
+function parsePreviewEnvironmentDefs(servers) {
   const out = [];
   if (!Array.isArray(servers)) return out;
   for (const s of servers) {
     if (!s || typeof s !== "object") continue;
     const o = s;
-    const serverId = typeof o.serverId === "string" ? o.serverId : "";
-    if (!serverId) continue;
+    const environmentId = typeof o.environmentId === "string" ? o.environmentId : "";
+    if (!environmentId) continue;
     const envRaw = o.env;
     const env = Array.isArray(envRaw) ? envRaw.map((e) => {
       if (!e || typeof e !== "object") return null;
@@ -43794,7 +43820,7 @@ function parseDevServerDefs(servers) {
     const portsRaw = o.ports;
     const ports = Array.isArray(portsRaw) ? portsRaw.filter((p) => typeof p === "number" && Number.isInteger(p) && p > 0 && p < 65536) : [];
     out.push({
-      serverId,
+      environmentId,
       name: typeof o.name === "string" ? o.name : "",
       command: typeof o.command === "string" ? o.command : "",
       env,
@@ -43804,7 +43830,7 @@ function parseDevServerDefs(servers) {
   return out;
 }
 
-// src/dev-servers/manager/shell-spawn/utils.ts
+// src/preview-environments/manager/shell-spawn/utils.ts
 import fs38 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
@@ -43827,7 +43853,7 @@ function pipedStdoutStderrFor(attemptStdio) {
   return attemptStdio !== "inherit" && Array.isArray(attemptStdio) && attemptStdio[1] === "pipe" && attemptStdio[2] === "pipe";
 }
 
-// src/dev-servers/manager/shell-spawn/try-spawn-piped-via-sh.ts
+// src/preview-environments/manager/shell-spawn/try-spawn-piped-via-sh.ts
 import { spawn as spawn5 } from "node:child_process";
 function trySpawnPipedViaSh(command, env, cwd, signal) {
   const attempts = [
@@ -43870,7 +43896,7 @@ function trySpawnPipedViaSh(command, env, cwd, signal) {
   return { ok: false, lastErr };
 }
 
-// src/dev-servers/manager/shell-spawn/try-spawn-shell-true-piped.ts
+// src/preview-environments/manager/shell-spawn/try-spawn-shell-true-piped.ts
 import { spawn as spawn6 } from "node:child_process";
 function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
   try {
@@ -43891,14 +43917,14 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
   }
 }
 
-// src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
+// src/preview-environments/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn7 } from "node:child_process";
 import fs39 from "node:fs";
 import { tmpdir } from "node:os";
-import path60 from "node:path";
+import path61 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs39.mkdtempSync(path60.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path60.join(tmpRoot, "combined.log");
+  const tmpRoot = fs39.mkdtempSync(path61.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path61.join(tmpRoot, "combined.log");
   let logFd;
   try {
     logFd = fs39.openSync(logPath, "a");
@@ -43938,19 +43964,19 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
   }
 }
 
-// src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
+// src/preview-environments/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn8 } from "node:child_process";
 import fs40 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path61 from "node:path";
+import path62 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs40.mkdtempSync(path61.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path61.join(tmpRoot, "combined.log");
-  const innerPath = path61.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path61.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs40.mkdtempSync(path62.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path62.join(tmpRoot, "combined.log");
+  const innerPath = path62.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path62.join(tmpRoot, "_run.sh");
   try {
     fs40.writeFileSync(innerPath, `#!/bin/sh
 ${command}
@@ -43981,9 +44007,9 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs40.mkdtempSync(path61.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path61.join(tmpRoot, "combined.log");
-  const runnerPath = path61.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs40.mkdtempSync(path62.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path62.join(tmpRoot, "combined.log");
+  const runnerPath = path62.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
@@ -44014,7 +44040,7 @@ ${command} >> ${q(logPath)} 2>&1\r
   }
 }
 
-// src/dev-servers/manager/shell-spawn/try-spawn-inherit.ts
+// src/preview-environments/manager/shell-spawn/try-spawn-inherit.ts
 import { spawn as spawn9 } from "node:child_process";
 function trySpawnInheritStdio(command, env, cwd, signal) {
   const opts = {
@@ -44034,7 +44060,7 @@ function trySpawnInheritStdio(command, env, cwd, signal) {
   return { proc, pipedStdoutStderr: false };
 }
 
-// src/dev-servers/manager/shell-spawn/shell-spawn.ts
+// src/preview-environments/manager/shell-spawn/shell-spawn.ts
 function shellSpawn(command, env, cwd, options) {
   const signal = options?.signal;
   const piped = trySpawnPipedViaSh(command, env, cwd, signal);
@@ -44061,7 +44087,7 @@ function shellSpawn(command, env, cwd, options) {
   }
 }
 
-// src/dev-servers/manager/stream-tail.ts
+// src/preview-environments/manager/stream-tail.ts
 var MAX_TAIL_LINES = 80;
 var MAX_LINE_CHARS = 8192;
 var MAX_PENDING_CHARS = 65536;
@@ -44097,11 +44123,11 @@ var StreamTail = class {
   }
 };
 
-// src/dev-servers/manager/dev-server-firehose-messages.ts
+// src/preview-environments/manager/preview-environment-firehose-messages.ts
 function buildFirehoseSnapshotMessage(params) {
   const payload = {
     type: "log_snapshot",
-    serverId: params.serverId,
+    environmentId: params.environmentId,
     viewerId: params.viewerId,
     stdoutTail: params.tails.stdout,
     stderrTail: params.tails.stderr
@@ -44111,15 +44137,15 @@ function buildFirehoseSnapshotMessage(params) {
 function buildFirehoseLogChunkMessage(params) {
   const payload = {
     type: "log_chunk",
-    serverId: params.serverId,
+    environmentId: params.environmentId,
     stream: params.stream,
     text: params.text
   };
   return params.e2ee ? params.e2ee.encryptFields(payload, ["text"]) : payload;
 }
 
-// src/dev-servers/manager/dev-server-firehose-sink.ts
-var DevServerFirehoseSink = class {
+// src/preview-environments/manager/preview-environment-firehose-sink.ts
+var PreviewEnvironmentFirehoseSink = class {
   constructor(options) {
     this.options = options;
   }
@@ -44132,31 +44158,31 @@ var DevServerFirehoseSink = class {
     this.firehoseSend = null;
     this.logViewerRefCountByServerId.clear();
   }
-  openLogViewer(serverId, viewerId) {
-    const next = (this.logViewerRefCountByServerId.get(serverId) ?? 0) + 1;
-    this.logViewerRefCountByServerId.set(serverId, next);
-    this.sendSnapshot(serverId, viewerId);
+  openLogViewer(environmentId, viewerId) {
+    const next = (this.logViewerRefCountByServerId.get(environmentId) ?? 0) + 1;
+    this.logViewerRefCountByServerId.set(environmentId, next);
+    this.sendSnapshot(environmentId, viewerId);
   }
-  closeLogViewer(serverId) {
-    const n = (this.logViewerRefCountByServerId.get(serverId) ?? 0) - 1;
-    if (n <= 0) this.logViewerRefCountByServerId.delete(serverId);
-    else this.logViewerRefCountByServerId.set(serverId, n);
+  closeLogViewer(environmentId) {
+    const n = (this.logViewerRefCountByServerId.get(environmentId) ?? 0) - 1;
+    if (n <= 0) this.logViewerRefCountByServerId.delete(environmentId);
+    else this.logViewerRefCountByServerId.set(environmentId, n);
   }
-  pushLogChunk(serverId, stream, chunk) {
-    if ((this.logViewerRefCountByServerId.get(serverId) ?? 0) <= 0) return;
-    if (!this.options.isPipedCaptureEnabled(serverId)) return;
+  pushLogChunk(environmentId, stream, chunk) {
+    if ((this.logViewerRefCountByServerId.get(environmentId) ?? 0) <= 0) return;
+    if (!this.options.isPipedCaptureEnabled(environmentId)) return;
     if (!this.firehoseSend) return;
     const text = chunk.toString("utf8");
     setImmediate(() => {
       if (!this.firehoseSend) return;
-      this.firehoseSend(buildFirehoseLogChunkMessage({ serverId, stream, text, e2ee: this.options.e2ee }));
+      this.firehoseSend(buildFirehoseLogChunkMessage({ environmentId, stream, text, e2ee: this.options.e2ee }));
     });
   }
-  sendSnapshot(serverId, viewerId) {
+  sendSnapshot(environmentId, viewerId) {
     const payload = buildFirehoseSnapshotMessage({
-      serverId,
+      environmentId,
       viewerId,
-      tails: this.options.getTails(serverId),
+      tails: this.options.getTails(environmentId),
       e2ee: this.options.e2ee
     });
     setImmediate(() => {
@@ -44167,19 +44193,19 @@ var DevServerFirehoseSink = class {
   }
 };
 
-// src/dev-servers/manager/cleanup-merged-log-dir.ts
+// src/preview-environments/manager/cleanup-merged-log-dir.ts
 import { rm } from "node:fs/promises";
-function cleanupMergedLogDirForServer(map2, serverId) {
-  const mergedDir = map2.get(serverId);
+function cleanupMergedLogDirForServer(map2, environmentId) {
+  const mergedDir = map2.get(environmentId);
   if (!mergedDir) return;
-  map2.delete(serverId);
+  map2.delete(environmentId);
   void rm(mergedDir, { recursive: true, force: true }).catch(() => {
   });
 }
 
-// src/dev-servers/manager/dev-server-manager.ts
+// src/preview-environments/manager/preview-environment-manager.ts
 var emptyTails = () => ({ stdout: [], stderr: [] });
-var DevServerManager = class {
+var PreviewEnvironmentManager = class {
   defsById = /* @__PURE__ */ new Map();
   processes = /* @__PURE__ */ new Map();
   streamTailsByServerId = /* @__PURE__ */ new Map();
@@ -44198,9 +44224,9 @@ var DevServerManager = class {
     this.log = options.log;
     this.getBridgeRoot = options.getBridgeRoot ?? (() => process.cwd());
     this.e2ee = options.e2ee;
-    this.firehoseSink = new DevServerFirehoseSink({
-      getTails: (serverId) => this.snapshotTails(serverId),
-      isPipedCaptureEnabled: (serverId) => this.pipedCaptureByServerId.get(serverId) === true,
+    this.firehoseSink = new PreviewEnvironmentFirehoseSink({
+      getTails: (environmentId) => this.snapshotTails(environmentId),
+      isPipedCaptureEnabled: (environmentId) => this.pipedCaptureByServerId.get(environmentId) === true,
       e2ee: this.e2ee
     });
   }
@@ -44210,89 +44236,89 @@ var DevServerManager = class {
   detachFirehose() {
     this.firehoseSink.detach();
   }
-  handleFirehoseLogViewerOpen(serverId, _viewerId) {
-    this.firehoseSink.openLogViewer(serverId, _viewerId);
+  handleFirehoseLogViewerOpen(environmentId, _viewerId) {
+    this.firehoseSink.openLogViewer(environmentId, _viewerId);
   }
-  handleFirehoseLogViewerClose(serverId, _viewerId) {
-    this.firehoseSink.closeLogViewer(serverId);
+  handleFirehoseLogViewerClose(environmentId, _viewerId) {
+    this.firehoseSink.closeLogViewer(environmentId);
   }
   applyConfig(servers) {
     this.defsById.clear();
-    for (const d of parseDevServerDefs(servers)) {
-      this.defsById.set(d.serverId, d);
+    for (const d of parsePreviewEnvironmentDefs(servers)) {
+      this.defsById.set(d.environmentId, d);
     }
   }
-  snapshotTails(serverId) {
-    const t = this.streamTailsByServerId.get(serverId);
+  snapshotTails(environmentId) {
+    const t = this.streamTailsByServerId.get(environmentId);
     if (!t) return { stdout: [], stderr: [] };
     return { stdout: t.stdout.getTail(), stderr: t.stderr.getTail() };
   }
-  clearTails(serverId) {
-    this.streamTailsByServerId.delete(serverId);
+  clearTails(environmentId) {
+    this.streamTailsByServerId.delete(environmentId);
   }
-  sendStatus(serverId, status, detail, tails) {
-    sendDevServerStatus(this.getWs, serverId, status, { detail, tails });
+  sendStatus(environmentId, status, detail, tails) {
+    sendPreviewEnvironmentStatus(this.getWs, environmentId, status, { detail, tails });
   }
-  bumpGeneration(serverId) {
-    const nextGen = (this.spawnGenerationByServerId.get(serverId) ?? 0) + 1;
-    this.spawnGenerationByServerId.set(serverId, nextGen);
+  bumpGeneration(environmentId) {
+    const nextGen = (this.spawnGenerationByServerId.get(environmentId) ?? 0) + 1;
+    this.spawnGenerationByServerId.set(environmentId, nextGen);
   }
-  clearPoll(serverId) {
-    const poll = this.mergedLogPollByServerId.get(serverId);
+  clearPoll(environmentId) {
+    const poll = this.mergedLogPollByServerId.get(environmentId);
     if (poll) {
       clearInterval(poll);
-      this.mergedLogPollByServerId.delete(serverId);
+      this.mergedLogPollByServerId.delete(environmentId);
     }
   }
-  abortSpawn(serverId) {
-    this.abortControllersByServerId.get(serverId)?.abort();
-    this.abortControllersByServerId.delete(serverId);
+  abortSpawn(environmentId) {
+    this.abortControllersByServerId.get(environmentId)?.abort();
+    this.abortControllersByServerId.delete(environmentId);
   }
-  stop(serverId) {
-    const tails = this.snapshotTails(serverId);
-    if (this.processes.has(serverId)) {
-      this.sendStatus(serverId, "stopping", void 0, tails);
+  stop(environmentId) {
+    const tails = this.snapshotTails(environmentId);
+    if (this.processes.has(environmentId)) {
+      this.sendStatus(environmentId, "stopping", void 0, tails);
     }
-    this.bumpGeneration(serverId);
-    this.abortSpawn(serverId);
-    this.clearPoll(serverId);
-    const proc = this.processes.get(serverId);
+    this.bumpGeneration(environmentId);
+    this.abortSpawn(environmentId);
+    this.clearPoll(environmentId);
+    const proc = this.processes.get(environmentId);
     if (proc) {
       proc.removeAllListeners();
       try {
         proc.kill("SIGTERM");
       } catch {
       }
-      this.processes.delete(serverId);
+      this.processes.delete(environmentId);
     }
-    this.clearTails(serverId);
-    this.pipedCaptureByServerId.delete(serverId);
-    cleanupMergedLogDirForServer(this.mergedLogCleanupDirByServerId, serverId);
-    this.sendStatus(serverId, "stopped", void 0, tails);
+    this.clearTails(environmentId);
+    this.pipedCaptureByServerId.delete(environmentId);
+    cleanupMergedLogDirForServer(this.mergedLogCleanupDirByServerId, environmentId);
+    this.sendStatus(environmentId, "stopped", void 0, tails);
   }
-  start(serverId) {
-    const def = this.defsById.get(serverId);
+  start(environmentId) {
+    const def = this.defsById.get(environmentId);
     if (!def) {
-      this.log(`[dev-server] Unknown server id ${serverId.slice(0, 8)}\u2026`);
-      this.sendStatus(serverId, "error", "Unknown server", emptyTails());
+      this.log(`[preview-environment] Unknown server id ${environmentId.slice(0, 8)}\u2026`);
+      this.sendStatus(environmentId, "error", "Unknown server", emptyTails());
       return;
     }
     if (!def.command.trim()) {
-      this.sendStatus(serverId, "idle", "No command configured", emptyTails());
+      this.sendStatus(environmentId, "idle", "No command configured", emptyTails());
       return;
     }
-    this.stop(serverId);
-    this.sendStatus(serverId, "starting", void 0, emptyTails());
+    this.stop(environmentId);
+    this.sendStatus(environmentId, "starting", void 0, emptyTails());
     const ac = new AbortController();
-    this.abortControllersByServerId.set(serverId, ac);
+    this.abortControllersByServerId.set(environmentId, ac);
     const cwd = this.getBridgeRoot();
     const childEnv = envForSpawn(process.env, def.env, def.ports);
     const cmd = substituteCommand(def.command.trim(), childEnv);
-    const title = def.name.trim() || serverId.slice(0, 8);
-    this.log(`[dev-server] Starting ${title}: ${cmd.slice(0, 120)}${cmd.length > 120 ? "\u2026" : ""}`);
-    const scheduledGen = this.spawnGenerationByServerId.get(serverId) ?? 0;
+    const title = def.name.trim() || environmentId.slice(0, 8);
+    this.log(`[preview-environment] Starting ${title}: ${cmd.slice(0, 120)}${cmd.length > 120 ? "\u2026" : ""}`);
+    const scheduledGen = this.spawnGenerationByServerId.get(environmentId) ?? 0;
     setImmediate(() => {
-      if ((this.spawnGenerationByServerId.get(serverId) ?? 0) !== scheduledGen) {
+      if ((this.spawnGenerationByServerId.get(environmentId) ?? 0) !== scheduledGen) {
         return;
       }
       let proc;
@@ -44309,12 +44335,12 @@ var DevServerManager = class {
         mergedCleanupDir = spawned.mergedLogCleanupDir;
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        this.log(`[dev-server] Failed to start ${title}: ${msg}`);
-        this.abortControllersByServerId.delete(serverId);
-        this.sendStatus(serverId, "error", msg, emptyTails());
+        this.log(`[preview-environment] Failed to start ${title}: ${msg}`);
+        this.abortControllersByServerId.delete(environmentId);
+        this.sendStatus(environmentId, "error", msg, emptyTails());
         return;
       }
-      if ((this.spawnGenerationByServerId.get(serverId) ?? 0) !== scheduledGen) {
+      if ((this.spawnGenerationByServerId.get(environmentId) ?? 0) !== scheduledGen) {
         try {
           proc.removeAllListeners();
           proc.kill("SIGTERM");
@@ -44323,89 +44349,89 @@ var DevServerManager = class {
         return;
       }
       if (!pipedStdoutStderr) {
-        this.log(`[dev-server] ${title} running (inherited stdio; bridge log preview disabled)`);
+        this.log(`[preview-environment] ${title} running (inherited stdio; bridge log preview disabled)`);
       } else if (mergedLogPath && mergedCleanupDir) {
         this.log(
-          `[dev-server] ${title} running (logs captured via temp file; open the browser log viewer for live output)`
+          `[preview-environment] ${title} running (logs captured via temp file; open the browser log viewer for live output)`
         );
       }
-      this.pipedCaptureByServerId.set(serverId, pipedStdoutStderr);
+      this.pipedCaptureByServerId.set(environmentId, pipedStdoutStderr);
       const stdoutTail = new StreamTail();
       const stderrTail = new StreamTail();
-      this.streamTailsByServerId.set(serverId, { stdout: stdoutTail, stderr: stderrTail });
+      this.streamTailsByServerId.set(environmentId, { stdout: stdoutTail, stderr: stderrTail });
       if (mergedLogPath && mergedCleanupDir) {
-        this.mergedLogCleanupDirByServerId.set(serverId, mergedCleanupDir);
+        this.mergedLogCleanupDirByServerId.set(environmentId, mergedCleanupDir);
       }
       const mergedReadPos = { value: 0 };
-      this.processes.set(serverId, proc);
-      wireDevServerChildProcess({
-        serverId,
+      this.processes.set(environmentId, proc);
+      wirePreviewEnvironmentChildProcess({
+        environmentId,
         title,
         proc,
         mergedLogPath,
         mergedCleanupDir,
         mergedReadPos,
         scheduledGen,
-        getSpawnGeneration: () => this.spawnGenerationByServerId.get(serverId) ?? 0,
+        getSpawnGeneration: () => this.spawnGenerationByServerId.get(environmentId) ?? 0,
         log: this.log,
         stdoutTail,
         stderrTail,
         pushRemoteLogChunk: (sid, stream, chunk) => this.firehoseSink.pushLogChunk(sid, stream, chunk),
-        sendStatus: (status, detail, tails) => this.sendStatus(serverId, status, detail, tails),
+        sendStatus: (status, detail, tails) => this.sendStatus(environmentId, status, detail, tails),
         setPollInterval: (iv) => {
-          if (iv) this.mergedLogPollByServerId.set(serverId, iv);
-          else this.mergedLogPollByServerId.delete(serverId);
+          if (iv) this.mergedLogPollByServerId.set(environmentId, iv);
+          else this.mergedLogPollByServerId.delete(environmentId);
         },
-        getPollInterval: () => this.mergedLogPollByServerId.get(serverId),
+        getPollInterval: () => this.mergedLogPollByServerId.get(environmentId),
         detachProcessFromManager: () => {
-          this.processes.delete(serverId);
-          this.pipedCaptureByServerId.delete(serverId);
-          this.abortControllersByServerId.delete(serverId);
-          this.mergedLogCleanupDirByServerId.delete(serverId);
+          this.processes.delete(environmentId);
+          this.pipedCaptureByServerId.delete(environmentId);
+          this.abortControllersByServerId.delete(environmentId);
+          this.mergedLogCleanupDirByServerId.delete(environmentId);
         },
         rmMergedCleanupDir: (dir) => {
           void rm2(dir, { recursive: true, force: true }).catch(() => {
           });
         },
-        clearTailBuffers: () => this.clearTails(serverId)
+        clearTailBuffers: () => this.clearTails(environmentId)
       });
-      this.sendStatus(serverId, "running", `pid=${proc.pid ?? "?"}`, {
+      this.sendStatus(environmentId, "running", `pid=${proc.pid ?? "?"}`, {
         stdout: stdoutTail.getTail(),
         stderr: stderrTail.getTail()
       });
     });
   }
-  handleControl(serverId, action) {
+  handleControl(environmentId, action) {
     if (action === "stop") {
-      this.stop(serverId);
+      this.stop(environmentId);
       return;
     }
-    this.start(serverId);
+    this.start(environmentId);
   }
   async shutdownAllGraceful(opts) {
     const graceMs = opts?.graceMs ?? BRIDGE_SHUTDOWN_GRACE_MS;
     const pairs = [...this.processes.entries()];
     if (pairs.length === 0) return;
     this.log(
-      `[dev-server] Stopping ${pairs.length} local dev server process${pairs.length === 1 ? "" : "es"}\u2026`
+      `[preview-environment] Stopping ${pairs.length} local preview environment process${pairs.length === 1 ? "" : "es"}\u2026`
     );
-    await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc, graceMs)));
+    await Promise.all(pairs.map(([environmentId, proc]) => this.gracefulTerminateOrUnknown(environmentId, proc, graceMs)));
   }
-  async gracefulTerminateOrUnknown(serverId, proc, graceMs) {
-    const shortId = `${serverId.slice(0, 8)}\u2026`;
+  async gracefulTerminateOrUnknown(environmentId, proc, graceMs) {
+    const shortId = `${environmentId.slice(0, 8)}\u2026`;
     await sigtermAndWaitForExit(proc, graceMs, this.log, shortId);
-    if (!this.processes.has(serverId) || this.processes.get(serverId) !== proc) {
+    if (!this.processes.has(environmentId) || this.processes.get(environmentId) !== proc) {
       return;
     }
-    this.bumpGeneration(serverId);
+    this.bumpGeneration(environmentId);
     forceKillChild(proc, this.log, shortId, graceMs);
-    this.processes.delete(serverId);
-    this.clearPoll(serverId);
-    this.pipedCaptureByServerId.delete(serverId);
-    cleanupMergedLogDirForServer(this.mergedLogCleanupDirByServerId, serverId);
-    const tails = this.snapshotTails(serverId);
-    this.clearTails(serverId);
-    this.sendStatus(serverId, "unknown", "Bridge closed before process exited", tails);
+    this.processes.delete(environmentId);
+    this.clearPoll(environmentId);
+    this.pipedCaptureByServerId.delete(environmentId);
+    cleanupMergedLogDirForServer(this.mergedLogCleanupDirByServerId, environmentId);
+    const tails = this.snapshotTails(environmentId);
+    this.clearTails(environmentId);
+    this.sendStatus(environmentId, "unknown", "Bridge closed before process exited", tails);
   }
 };
 
@@ -44631,20 +44657,20 @@ function createFirehoseMessageRouter() {
   };
 }
 
-// src/firehose/routing/handlers/dev-server-logs-viewer-open.ts
-var handleDevServerLogsViewerOpen = (msg, deps) => {
-  const serverId = typeof msg.serverId === "string" ? msg.serverId : "";
+// src/firehose/routing/handlers/preview-environment-logs-viewer-open.ts
+var handlePreviewEnvironmentLogsViewerOpen = (msg, deps) => {
+  const environmentId = typeof msg.environmentId === "string" ? msg.environmentId : "";
   const viewerId = typeof msg.viewerId === "string" ? msg.viewerId : "";
-  if (!serverId || !viewerId) return;
-  deps.devServerManager.handleFirehoseLogViewerOpen(serverId, viewerId);
+  if (!environmentId || !viewerId) return;
+  deps.previewEnvironmentManager.handleFirehoseLogViewerOpen(environmentId, viewerId);
 };
 
-// src/firehose/routing/handlers/dev-server-logs-viewer-close.ts
-var handleDevServerLogsViewerClose = (msg, deps) => {
-  const serverId = typeof msg.serverId === "string" ? msg.serverId : "";
+// src/firehose/routing/handlers/preview-environment-logs-viewer-close.ts
+var handlePreviewEnvironmentLogsViewerClose = (msg, deps) => {
+  const environmentId = typeof msg.environmentId === "string" ? msg.environmentId : "";
   const viewerId = typeof msg.viewerId === "string" ? msg.viewerId : "";
-  if (!serverId || !viewerId) return;
-  deps.devServerManager.handleFirehoseLogViewerClose(serverId, viewerId);
+  if (!environmentId || !viewerId) return;
+  deps.previewEnvironmentManager.handleFirehoseLogViewerClose(environmentId, viewerId);
 };
 
 // src/firehose/routing/handlers/proxy-message.ts
@@ -44693,8 +44719,8 @@ var handleFirehoseIdentified = (_msg, _deps) => {
 // src/firehose/routing/dispatch-firehose-message.ts
 var router = createFirehoseMessageRouter();
 router.register("identified", handleFirehoseIdentified);
-router.register("log_viewer_open", handleDevServerLogsViewerOpen);
-router.register("log_viewer_close", handleDevServerLogsViewerClose);
+router.register("log_viewer_open", handlePreviewEnvironmentLogsViewerOpen);
+router.register("log_viewer_close", handlePreviewEnvironmentLogsViewerClose);
 router.register("proxy", handleProxyMessage);
 function dispatchFirehoseJsonMessage(msg, deps) {
   router.dispatch(msg, deps);
@@ -44724,7 +44750,7 @@ function connectFirehose(options) {
     bridgeName,
     proxyPorts,
     log: log2,
-    devServerManager,
+    previewEnvironmentManager,
     onOpen,
     onClose,
     suppressWebSocketErrors
@@ -44744,7 +44770,7 @@ function connectFirehose(options) {
   const deps = {
     ws,
     log: log2,
-    devServerManager,
+    previewEnvironmentManager,
     pendingProxyBody,
     startStreamingProxy: (pr) => startStreamingProxy(ws, log2, pr)
   };
@@ -44752,7 +44778,7 @@ function connectFirehose(options) {
     disposeClientPing();
     clearClientPing = attachWebSocketClientPing(ws, CLI_WEBSOCKET_CLIENT_PING_MS);
     onOpen?.();
-    devServerManager.attachFirehose(firehoseSend);
+    previewEnvironmentManager.attachFirehose(firehoseSend);
     sendWsMessage(ws, { type: "identify", workspaceId, bridgeName, proxyPorts });
   });
   ws.on("message", (raw) => {
@@ -44769,7 +44795,7 @@ function connectFirehose(options) {
   });
   ws.on("close", (code, reason) => {
     disposeClientPing();
-    devServerManager.detachFirehose();
+    previewEnvironmentManager.detachFirehose();
     const reasonStr = typeof reason === "string" ? reason : reason.toString();
     onClose?.(code, reasonStr);
   });
@@ -44785,7 +44811,7 @@ function connectFirehose(options) {
   return {
     close() {
       disposeClientPing();
-      devServerManager.detachFirehose();
+      previewEnvironmentManager.detachFirehose();
       safeCloseWebSocket(ws);
     },
     isConnected: () => ws.readyState === wrapper_default.OPEN
@@ -44794,7 +44820,7 @@ function connectFirehose(options) {
 
 // src/connection/attach-firehose-after-identified.ts
 function attachFirehoseAfterIdentified(ctx, params) {
-  const { state, devServerManager, logFn } = ctx;
+  const { state, previewEnvironmentManager, logFn } = ctx;
   function clearFirehoseReconnectTimer() {
     if (state.firehoseReconnectTimeout != null) {
       clearTimeout(state.firehoseReconnectTimeout);
@@ -44860,7 +44886,7 @@ function attachFirehoseAfterIdentified(ctx, params) {
     bridgeName: params.bridgeName,
     proxyPorts: params.proxyPorts,
     log: logFn,
-    devServerManager,
+    previewEnvironmentManager,
     suppressWebSocketErrors: () => !state.closedByUser && state.firehoseOutage.startedAt != null,
     onOpen: () => {
       if (myGen !== state.firehoseGeneration) return;
@@ -44903,14 +44929,14 @@ function attachFirehoseAfterIdentified(ctx, params) {
 
 // src/connection/create-bridge-identified-handler.ts
 function createOnBridgeIdentified(opts) {
-  const { devServerManager, firehoseServerUrl, workspaceId, state, logFn } = opts;
-  const firehoseCtx = { state, devServerManager, logFn };
+  const { previewEnvironmentManager, firehoseServerUrl, workspaceId, state, logFn } = opts;
+  const firehoseCtx = { state, previewEnvironmentManager, logFn };
   return (msg) => {
     const bridgeName = msg.bridgeName;
     const proxyPorts = Array.isArray(msg.proxyPorts) ? msg.proxyPorts : [];
-    const devServers = msg.devServers ?? [];
+    const previewEnvironments = msg.previewEnvironments ?? [];
     setImmediate(() => {
-      devServerManager.applyConfig(devServers);
+      previewEnvironmentManager.applyConfig(previewEnvironments);
       if (!firehoseServerUrl || typeof bridgeName !== "string" || !bridgeName) return;
       state.firehoseReconnectAttempt = 0;
       attachFirehoseAfterIdentified(firehoseCtx, {
@@ -44933,15 +44959,15 @@ async function yieldSkillDiscoveryWork(entryCount) {
 
 // src/skills/discovery/discover-local-skills.ts
 import fs41 from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 function collectSkillFromDir(rel, base, name, seenKeys, out) {
-  const dir = path62.join(base, name);
+  const dir = path63.join(base, name);
   try {
     if (!fs41.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  const skillMd = path62.join(dir, "SKILL.md");
+  const skillMd = path63.join(dir, "SKILL.md");
   if (!fs41.existsSync(skillMd)) return;
   const key = `${rel}/${name}`;
   if (seenKeys.has(key)) return;
@@ -44954,7 +44980,7 @@ async function discoverLocalSkillsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path62.join(cwd, rel);
+    const base = path63.join(cwd, rel);
     if (!fs41.existsSync(base) || !fs41.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -44972,15 +44998,15 @@ async function discoverLocalSkillsAsync(cwd) {
 
 // src/skills/discovery/discover-skill-layout-roots.ts
 import fs42 from "node:fs";
-import path63 from "node:path";
+import path64 from "node:path";
 function collectLayoutSkill(rel, base, name, skills2) {
-  const dir = path63.join(base, name);
+  const dir = path64.join(base, name);
   try {
     if (!fs42.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  if (!fs42.existsSync(path63.join(dir, "SKILL.md"))) return;
+  if (!fs42.existsSync(path64.join(dir, "SKILL.md"))) return;
   const relPath = `${rel}/${name}`.replace(/\\/g, "/");
   skills2.push({ name, relPath });
 }
@@ -44989,7 +45015,7 @@ async function discoverSkillLayoutRootsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path63.join(cwd, rel);
+    const base = path64.join(cwd, rel);
     if (!fs42.existsSync(base) || !fs42.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -45086,8 +45112,8 @@ var API_TO_BRIDGE_MESSAGE_TYPES = [
   "auth_token",
   "bridge_identified",
   "ha",
-  "dev_servers_config",
-  "server_control",
+  "preview_environments_config",
+  "preview_environment_control",
   "agent_config",
   "prompt_queue_state",
   "prompt",
@@ -45147,7 +45173,7 @@ var handleBridgeIdentified = (msg, deps) => {
   deps.onBridgeIdentified({
     bridgeName: msg.bridgeName,
     proxyPorts: msg.proxyPorts,
-    devServers: msg.devServers
+    previewEnvironments: msg.previewEnvironments
   });
   setImmediate(() => {
     void (async () => {
@@ -45341,7 +45367,7 @@ import fs44 from "node:fs";
 
 // src/git/snapshot/capture.ts
 import * as fs43 from "node:fs";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 
 // src/git/snapshot/git.ts
 async function gitStashCreate(repoRoot, log2) {
@@ -45381,7 +45407,7 @@ async function gitRun(repoRoot, args, log2, label) {
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path64.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path65.resolve(p)))];
     return uniq;
   }
   try {
@@ -45389,7 +45415,7 @@ async function resolveSnapshotRepoRoots(options) {
     const mapped = repos.map((r) => r.absolutePath);
     const sid = sessionId?.trim();
     if (sid) {
-      const filtered = mapped.filter((root) => path64.basename(root) === sid);
+      const filtered = mapped.filter((root) => path65.basename(root) === sid);
       if (filtered.length > 0) return filtered;
     }
     return mapped;
@@ -45420,7 +45446,7 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path64.join(dir, `${runId}.json`);
+  const filePath = path65.join(dir, `${runId}.json`);
   try {
     fs43.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
@@ -45763,9 +45789,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path75 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path75) continue;
-    const row = { path: path75 };
+    const path76 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path76) continue;
+    const row = { path: path76 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -45976,8 +46002,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path75, body) {
-  const url2 = `http://127.0.0.1:${port}${path75}`;
+async function requestPreviewApi(port, secret, method, path76, body) {
+  const url2 = `http://127.0.0.1:${port}${path76}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -45989,7 +46015,7 @@ async function requestPreviewApi(port, secret, method, path75, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path75}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path76}: ${res.status}`);
   }
   return data;
 }
@@ -46168,11 +46194,11 @@ async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId
 import fs46 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path65 from "node:path";
+import path66 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path65.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path65.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path65.sep) && resolved !== cwd) {
+  const normalized = path66.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path66.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path66.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -46182,11 +46208,11 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path66 from "node:path";
+import path67 from "node:path";
 import fs45 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path66.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path66.join(resolved, d.name);
+  const entryPath = path67.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path67.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
@@ -46236,13 +46262,13 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
 }
 
 // src/files/handle-file-browser-search.ts
-import path67 from "node:path";
+import path68 from "node:path";
 var SEARCH_LIMIT = 100;
 function handleFileBrowserSearch(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const sessionParentPath = path67.resolve(
+    const sessionParentPath = path68.resolve(
       sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -46452,13 +46478,13 @@ function triggerSymbolIndexBuild(parentPath) {
 }
 
 // src/git/tree/resolve-repo-abs-path.ts
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path68.resolve(bridgeRoot);
+  const bridgeResolved = path69.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path68.join(bridgeResolved, rel);
-  const resolved = path68.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path68.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path69.join(bridgeResolved, rel);
+  const resolved = path69.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path69.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -47241,7 +47267,7 @@ function isValidRemoteSkillInstallItem(item) {
 
 // src/skills/install/install-remote-skills-async.ts
 import fs50 from "node:fs";
-import path69 from "node:path";
+import path70 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -47252,8 +47278,8 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path69.join(skillDir, f.path);
-  await fs50.promises.mkdir(path69.dirname(dest), { recursive: true });
+  const dest = path70.join(skillDir, f.path);
+  await fs50.promises.mkdir(path70.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
     await fs50.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
@@ -47269,7 +47295,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path69.join(cwd, targetDir, item.skillName);
+      const skillDir = path70.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -47584,31 +47610,31 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
   })();
 };
 
-// src/routing/handlers/dev-server-control.ts
-var handleDevServerControl = (msg, deps) => {
+// src/routing/handlers/preview-environment-control.ts
+var handlePreviewEnvironmentControl = (msg, deps) => {
   let wire;
   try {
     wire = deps.e2ee ? deps.e2ee.decryptMessage(msg) : msg;
   } catch (e) {
-    deps.log(`[E2EE] Could not decrypt dev server command: ${e instanceof Error ? e.message : String(e)}`);
+    deps.log(`[E2EE] Could not decrypt preview environment command: ${e instanceof Error ? e.message : String(e)}`);
     return;
   }
-  const serverId = typeof wire.serverId === "string" ? wire.serverId : "";
+  const environmentId = typeof wire.environmentId === "string" ? wire.environmentId : "";
   const action = wire.action === "start" || wire.action === "stop" ? wire.action : null;
-  if (!serverId || !action) return;
-  deps.devServerManager?.handleControl(serverId, action);
+  if (!environmentId || !action) return;
+  deps.previewEnvironmentManager?.handleControl(environmentId, action);
 };
 
-// src/routing/handlers/dev-servers-config.ts
-var handleDevServersConfig = (msg, deps) => {
-  const devServers = msg.devServers;
+// src/routing/handlers/preview-environments-config.ts
+var handlePreviewEnvironmentsConfig = (msg, deps) => {
+  const previewEnvironments = msg.previewEnvironments;
   setImmediate(() => {
-    deps.devServerManager?.applyConfig(devServers ?? []);
+    deps.previewEnvironmentManager?.applyConfig(previewEnvironments ?? []);
   });
 };
 
 // src/git/bridge-git-context.ts
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -47658,12 +47684,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path70.basename(path70.resolve(bridgeRoot)) || "repo";
+    return path71.basename(path71.resolve(bridgeRoot)) || "repo";
   }
-  return path70.basename(relPath) || relPath;
+  return path71.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path70.resolve(bridgeRoot);
+  const root = path71.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -47671,19 +47697,19 @@ async function discoverGitReposForBridgeContext(bridgeRoot) {
   const [deep, shallow] = await Promise.all([discoverGitReposUnderRoot(root), discoverGitRepos(root)]);
   const byPath = /* @__PURE__ */ new Map();
   for (const repo of [...deep, ...shallow]) {
-    byPath.set(path70.resolve(repo.absolutePath), repo);
+    byPath.set(path71.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path70.resolve(bridgeRoot);
+  const bridgeResolved = path71.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
   for (let i = 0; i < repos.length; i++) {
     if (i > 0) await yieldToEventLoop();
     const repo = repos[i];
-    let rel = path70.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path70.isAbsolute(rel)) continue;
+    let rel = path71.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path71.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -47698,11 +47724,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path70.resolve(bridgeRoot);
+  const bridgeResolved = path71.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path70.join(bridgeResolved, rel);
-  const resolved = path70.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path70.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path71.join(bridgeResolved, rel);
+  const resolved = path71.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path71.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -47763,11 +47789,11 @@ function dispatchBridgeMessage(msg, deps) {
     case "ha":
       handleBridgeHeartbeatAck(msg, deps);
       break;
-    case "dev_servers_config":
-      handleDevServersConfig(msg, deps);
+    case "preview_environments_config":
+      handlePreviewEnvironmentsConfig(msg, deps);
       break;
-    case "server_control":
-      handleDevServerControl(msg, deps);
+    case "preview_environment_control":
+      handlePreviewEnvironmentControl(msg, deps);
       break;
     case "agent_config":
       handleAgentConfigMessage(msg, deps);
@@ -48579,7 +48605,7 @@ async function createBridgeAccessState(options = {}) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path72 from "node:path";
+import * as path73 from "node:path";
 
 // src/sqlite/hash-json-sha256.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -48646,7 +48672,7 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path71 from "node:path";
+import * as path72 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -48684,7 +48710,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path71.resolve(cwd),
+      cwd: path72.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -48762,7 +48788,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path72.resolve(getBridgeRoot());
+  const cwd = path73.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -48875,7 +48901,7 @@ function createBridgeMessageDeps(params) {
     sendLocalSkillsReport,
     reportAutoDetectedAgents,
     warmupAgentCapabilitiesOnConnect: warmupAgentCapabilitiesOnConnect2,
-    devServerManager,
+    previewEnvironmentManager,
     e2ee,
     cloudApiBaseUrl,
     getCloudAccessToken
@@ -48892,7 +48918,7 @@ function createBridgeMessageDeps(params) {
     sendLocalSkillsReport,
     reportAutoDetectedAgents,
     warmupAgentCapabilitiesOnConnect: warmupAgentCapabilitiesOnConnect2,
-    devServerManager,
+    previewEnvironmentManager,
     e2ee,
     cloudApiBaseUrl,
     getCloudAccessToken
@@ -48962,10 +48988,10 @@ async function createBridgeConnection(options) {
     initialIndexBuildsScheduled = true;
     scheduleInitialIndexBuilds(getBridgeRoot());
   };
-  const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeRoot, e2ee });
+  const previewEnvironmentManager = new PreviewEnvironmentManager({ getWs, log: logFn, getBridgeRoot, e2ee });
   const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: logFn });
   const baseOnBridgeIdentified = createOnBridgeIdentified({
-    devServerManager,
+    previewEnvironmentManager,
     firehoseServerUrl,
     workspaceId,
     state,
@@ -48991,14 +49017,14 @@ async function createBridgeConnection(options) {
       log: logFn,
       getWs
     }),
-    devServerManager,
+    previewEnvironmentManager,
     e2ee,
     cloudApiBaseUrl: apiUrl,
     getCloudAccessToken: () => tokens.accessToken
   });
   const identifyReportedPaths = {
-    bridgeRootPath: path73.resolve(getBridgeRoot()),
-    worktreesRootPath: path73.resolve(worktreesRootPath)
+    bridgeRootPath: path74.resolve(getBridgeRoot()),
+    worktreesRootPath: path74.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -49024,7 +49050,7 @@ async function createBridgeConnection(options) {
       requestCliImmediateShutdown();
       stopFileIndexWatcher();
       bridgeHeartbeat.stop();
-      await closeBridgeConnection(state, acpManager, devServerManager, logFn);
+      await closeBridgeConnection(state, acpManager, previewEnvironmentManager, logFn);
       await bridgeAccess.close();
     }
   };
@@ -49255,7 +49281,7 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path74.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path75.resolve(process.cwd(), bridgeRootOpt);
     try {
       const st = fs52.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
@@ -49277,7 +49303,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path74.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path75.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {