windows-development-sandbox 1.5.0 → 1.7.0

package/dist/runtime/daemon.js

@@ -1363,11 +1363,11 @@ var require_lodash = __commonJS({
             return isFunction(object2[key]);
           });
         }
-        function baseGet(object2, path65) {
-          path65 = castPath(path65, object2);
-          var index = 0, length = path65.length;
+        function baseGet(object2, path68) {
+          path68 = castPath(path68, object2);
+          var index = 0, length = path68.length;
           while (object2 != null && index < length) {
-            object2 = object2[toKey(path65[index++])];
+            object2 = object2[toKey(path68[index++])];
           }
           return index && index == length ? object2 : undefined2;
         }
@@ -1431,10 +1431,10 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function baseInvoke(object2, path65, args) {
-          path65 = castPath(path65, object2);
-          object2 = parent(object2, path65);
-          var func = object2 == null ? object2 : object2[toKey(last(path65))];
+        function baseInvoke(object2, path68, args) {
+          path68 = castPath(path68, object2);
+          object2 = parent(object2, path68);
+          var func = object2 == null ? object2 : object2[toKey(last(path68))];
           return func == null ? undefined2 : apply(func, object2, args);
         }
         function baseIsArguments(value) {
@@ -1590,13 +1590,13 @@ var require_lodash = __commonJS({
             return object2 === source || baseIsMatch(object2, source, matchData);
           };
         }
-        function baseMatchesProperty(path65, srcValue) {
-          if (isKey(path65) && isStrictComparable(srcValue)) {
-            return matchesStrictComparable(toKey(path65), srcValue);
+        function baseMatchesProperty(path68, srcValue) {
+          if (isKey(path68) && isStrictComparable(srcValue)) {
+            return matchesStrictComparable(toKey(path68), srcValue);
           }
           return function(object2) {
-            var objValue = get(object2, path65);
-            return objValue === undefined2 && objValue === srcValue ? hasIn(object2, path65) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+            var objValue = get(object2, path68);
+            return objValue === undefined2 && objValue === srcValue ? hasIn(object2, path68) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
           };
         }
         function baseMerge(object2, source, srcIndex, customizer, stack) {
@@ -1693,23 +1693,23 @@ var require_lodash = __commonJS({
           });
         }
         function basePick(object2, paths) {
-          return basePickBy(object2, paths, function(value, path65) {
-            return hasIn(object2, path65);
+          return basePickBy(object2, paths, function(value, path68) {
+            return hasIn(object2, path68);
           });
         }
         function basePickBy(object2, paths, predicate) {
           var index = -1, length = paths.length, result2 = {};
           while (++index < length) {
-            var path65 = paths[index], value = baseGet(object2, path65);
-            if (predicate(value, path65)) {
-              baseSet(result2, castPath(path65, object2), value);
+            var path68 = paths[index], value = baseGet(object2, path68);
+            if (predicate(value, path68)) {
+              baseSet(result2, castPath(path68, object2), value);
             }
           }
           return result2;
         }
-        function basePropertyDeep(path65) {
+        function basePropertyDeep(path68) {
           return function(object2) {
-            return baseGet(object2, path65);
+            return baseGet(object2, path68);
           };
         }
         function basePullAll(array2, values2, iteratee2, comparator) {
@@ -1783,14 +1783,14 @@ var require_lodash = __commonJS({
           var array2 = values(collection);
           return shuffleSelf(array2, baseClamp(n, 0, array2.length));
         }
-        function baseSet(object2, path65, value, customizer) {
+        function baseSet(object2, path68, value, customizer) {
           if (!isObject2(object2)) {
             return object2;
           }
-          path65 = castPath(path65, object2);
-          var index = -1, length = path65.length, lastIndex = length - 1, nested = object2;
+          path68 = castPath(path68, object2);
+          var index = -1, length = path68.length, lastIndex = length - 1, nested = object2;
           while (nested != null && ++index < length) {
-            var key = toKey(path65[index]), newValue = value;
+            var key = toKey(path68[index]), newValue = value;
             if (key === "__proto__" || key === "constructor" || key === "prototype") {
               return object2;
             }
@@ -1798,7 +1798,7 @@ var require_lodash = __commonJS({
               var objValue = nested[key];
               newValue = customizer ? customizer(objValue, key, nested) : undefined2;
               if (newValue === undefined2) {
-                newValue = isObject2(objValue) ? objValue : isIndex(path65[index + 1]) ? [] : {};
+                newValue = isObject2(objValue) ? objValue : isIndex(path68[index + 1]) ? [] : {};
               }
             }
             assignValue(nested, key, newValue);
@@ -1964,14 +1964,14 @@ var require_lodash = __commonJS({
             }
           return result2;
         }
-        function baseUnset(object2, path65) {
-          path65 = castPath(path65, object2);
-          var index = -1, length = path65.length;
+        function baseUnset(object2, path68) {
+          path68 = castPath(path68, object2);
+          var index = -1, length = path68.length;
           if (!length) {
             return true;
           }
           while (++index < length) {
-            var key = toKey(path65[index]);
+            var key = toKey(path68[index]);
             if (key === "__proto__" && !hasOwnProperty.call(object2, "__proto__")) {
               return false;
             }
@@ -1979,11 +1979,11 @@ var require_lodash = __commonJS({
               return false;
             }
           }
-          var obj = parent(object2, path65);
-          return obj == null || delete obj[toKey(last(path65))];
+          var obj = parent(object2, path68);
+          return obj == null || delete obj[toKey(last(path68))];
         }
-        function baseUpdate(object2, path65, updater, customizer) {
-          return baseSet(object2, path65, updater(baseGet(object2, path65)), customizer);
+        function baseUpdate(object2, path68, updater, customizer) {
+          return baseSet(object2, path68, updater(baseGet(object2, path68)), customizer);
         }
         function baseWhile(array2, predicate, isDrop, fromRight) {
           var length = array2.length, index = fromRight ? length : -1;
@@ -2866,11 +2866,11 @@ var require_lodash = __commonJS({
           var match = source.match(reWrapDetails);
           return match ? match[1].split(reSplitDetails) : [];
         }
-        function hasPath(object2, path65, hasFunc) {
-          path65 = castPath(path65, object2);
-          var index = -1, length = path65.length, result2 = false;
+        function hasPath(object2, path68, hasFunc) {
+          path68 = castPath(path68, object2);
+          var index = -1, length = path68.length, result2 = false;
           while (++index < length) {
-            var key = toKey(path65[index]);
+            var key = toKey(path68[index]);
             if (!(result2 = object2 != null && hasFunc(object2, key))) {
               break;
             }
@@ -3072,8 +3072,8 @@ var require_lodash = __commonJS({
             return apply(func, this, otherArgs);
           };
         }
-        function parent(object2, path65) {
-          return path65.length < 2 ? object2 : baseGet(object2, baseSlice(path65, 0, -1));
+        function parent(object2, path68) {
+          return path68.length < 2 ? object2 : baseGet(object2, baseSlice(path68, 0, -1));
         }
         function reorder(array2, indexes) {
           var arrLength = array2.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array2);
@@ -3708,10 +3708,10 @@ var require_lodash = __commonJS({
           }
           return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
         }
-        var invokeMap = baseRest(function(collection, path65, args) {
-          var index = -1, isFunc = typeof path65 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
+        var invokeMap = baseRest(function(collection, path68, args) {
+          var index = -1, isFunc = typeof path68 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
           baseEach(collection, function(value) {
-            result2[++index] = isFunc ? apply(path65, value, args) : baseInvoke(value, path65, args);
+            result2[++index] = isFunc ? apply(path68, value, args) : baseInvoke(value, path68, args);
           });
           return result2;
         });
@@ -4363,15 +4363,15 @@ var require_lodash = __commonJS({
         function functionsIn(object2) {
           return object2 == null ? [] : baseFunctions(object2, keysIn(object2));
         }
-        function get(object2, path65, defaultValue) {
-          var result2 = object2 == null ? undefined2 : baseGet(object2, path65);
+        function get(object2, path68, defaultValue) {
+          var result2 = object2 == null ? undefined2 : baseGet(object2, path68);
           return result2 === undefined2 ? defaultValue : result2;
         }
-        function has(object2, path65) {
-          return object2 != null && hasPath(object2, path65, baseHas);
+        function has(object2, path68) {
+          return object2 != null && hasPath(object2, path68, baseHas);
         }
-        function hasIn(object2, path65) {
-          return object2 != null && hasPath(object2, path65, baseHasIn);
+        function hasIn(object2, path68) {
+          return object2 != null && hasPath(object2, path68, baseHasIn);
         }
         var invert = createInverter(function(result2, value, key) {
           if (value != null && typeof value.toString != "function") {
@@ -4424,10 +4424,10 @@ var require_lodash = __commonJS({
             return result2;
           }
           var isDeep = false;
-          paths = arrayMap(paths, function(path65) {
-            path65 = castPath(path65, object2);
-            isDeep || (isDeep = path65.length > 1);
-            return path65;
+          paths = arrayMap(paths, function(path68) {
+            path68 = castPath(path68, object2);
+            isDeep || (isDeep = path68.length > 1);
+            return path68;
           });
           copyObject(object2, getAllKeysIn(object2), result2);
           if (isDeep) {
@@ -4453,19 +4453,19 @@ var require_lodash = __commonJS({
             return [prop];
           });
           predicate = getIteratee(predicate);
-          return basePickBy(object2, props, function(value, path65) {
-            return predicate(value, path65[0]);
+          return basePickBy(object2, props, function(value, path68) {
+            return predicate(value, path68[0]);
           });
         }
-        function result(object2, path65, defaultValue) {
-          path65 = castPath(path65, object2);
-          var index = -1, length = path65.length;
+        function result(object2, path68, defaultValue) {
+          path68 = castPath(path68, object2);
+          var index = -1, length = path68.length;
           if (!length) {
             length = 1;
             object2 = undefined2;
           }
           while (++index < length) {
-            var value = object2 == null ? undefined2 : object2[toKey(path65[index])];
+            var value = object2 == null ? undefined2 : object2[toKey(path68[index])];
             if (value === undefined2) {
               index = length;
               value = defaultValue;
@@ -4474,12 +4474,12 @@ var require_lodash = __commonJS({
           }
           return object2;
         }
-        function set2(object2, path65, value) {
-          return object2 == null ? object2 : baseSet(object2, path65, value);
+        function set2(object2, path68, value) {
+          return object2 == null ? object2 : baseSet(object2, path68, value);
         }
-        function setWith(object2, path65, value, customizer) {
+        function setWith(object2, path68, value, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object2 == null ? object2 : baseSet(object2, path65, value, customizer);
+          return object2 == null ? object2 : baseSet(object2, path68, value, customizer);
         }
         var toPairs = createToPairs(keys);
         var toPairsIn = createToPairs(keysIn);
@@ -4501,15 +4501,15 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function unset(object2, path65) {
-          return object2 == null ? true : baseUnset(object2, path65);
+        function unset(object2, path68) {
+          return object2 == null ? true : baseUnset(object2, path68);
         }
-        function update(object2, path65, updater) {
-          return object2 == null ? object2 : baseUpdate(object2, path65, castFunction(updater));
+        function update(object2, path68, updater) {
+          return object2 == null ? object2 : baseUpdate(object2, path68, castFunction(updater));
         }
-        function updateWith(object2, path65, updater, customizer) {
+        function updateWith(object2, path68, updater, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object2 == null ? object2 : baseUpdate(object2, path65, castFunction(updater), customizer);
+          return object2 == null ? object2 : baseUpdate(object2, path68, castFunction(updater), customizer);
         }
         function values(object2) {
           return object2 == null ? [] : baseValues(object2, keys(object2));
@@ -4895,17 +4895,17 @@ var require_lodash = __commonJS({
         function matches(source) {
           return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
         }
-        function matchesProperty(path65, srcValue) {
-          return baseMatchesProperty(path65, baseClone(srcValue, CLONE_DEEP_FLAG));
+        function matchesProperty(path68, srcValue) {
+          return baseMatchesProperty(path68, baseClone(srcValue, CLONE_DEEP_FLAG));
         }
-        var method = baseRest(function(path65, args) {
+        var method = baseRest(function(path68, args) {
           return function(object2) {
-            return baseInvoke(object2, path65, args);
+            return baseInvoke(object2, path68, args);
           };
         });
         var methodOf = baseRest(function(object2, args) {
-          return function(path65) {
-            return baseInvoke(object2, path65, args);
+          return function(path68) {
+            return baseInvoke(object2, path68, args);
           };
         });
         function mixin(object2, source, options) {
@@ -4952,12 +4952,12 @@ var require_lodash = __commonJS({
         var over = createOver(arrayMap);
         var overEvery = createOver(arrayEvery);
         var overSome = createOver(arraySome);
-        function property(path65) {
-          return isKey(path65) ? baseProperty(toKey(path65)) : basePropertyDeep(path65);
+        function property(path68) {
+          return isKey(path68) ? baseProperty(toKey(path68)) : basePropertyDeep(path68);
         }
         function propertyOf(object2) {
-          return function(path65) {
-            return object2 == null ? undefined2 : baseGet(object2, path65);
+          return function(path68) {
+            return object2 == null ? undefined2 : baseGet(object2, path68);
           };
         }
         var range = createRange();
@@ -5410,12 +5410,12 @@ var require_lodash = __commonJS({
         LazyWrapper.prototype.findLast = function(predicate) {
           return this.reverse().find(predicate);
         };
-        LazyWrapper.prototype.invokeMap = baseRest(function(path65, args) {
-          if (typeof path65 == "function") {
+        LazyWrapper.prototype.invokeMap = baseRest(function(path68, args) {
+          if (typeof path68 == "function") {
             return new LazyWrapper(this);
           }
           return this.map(function(value) {
-            return baseInvoke(value, path65, args);
+            return baseInvoke(value, path68, args);
           });
         });
         LazyWrapper.prototype.reject = function(predicate) {
@@ -6366,10 +6366,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path65) {
-  if (!path65)
+function getElementAtPath(obj, path68) {
+  if (!path68)
     return obj;
-  return path65.reduce((acc, key) => acc?.[key], obj);
+  return path68.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6709,11 +6709,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path65, issues) {
+function prefixIssues(path68, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path65);
+    iss.path.unshift(path68);
     return iss;
   });
 }
@@ -6983,8 +6983,8 @@ var _E = "captureStackTrace" in Error ? Error : null;
 function newError(Definition) {
   const E = _E;
   if (E) {
-    const saved = E.stackTraceLimit;
-    if (typeof saved === "number") {
+    const saved2 = E.stackTraceLimit;
+    if (typeof saved2 === "number") {
       try {
         E.stackTraceLimit = 0;
       } catch {
@@ -6994,7 +6994,7 @@ function newError(Definition) {
       try {
         return new Definition();
       } finally {
-        E.stackTraceLimit = saved;
+        E.stackTraceLimit = saved2;
       }
     }
   }
@@ -7163,16 +7163,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path65 = []) => {
+  const processError = (error63, path68 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path65, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path68, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
       } else {
-        const fullpath = [...path65, ...issue2.path];
+        const fullpath = [...path68, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -7211,17 +7211,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path65 = []) => {
+  const processError = (error63, path68 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path65, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path68, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path68, ...issue2.path]);
       } else {
-        const fullpath = [...path65, ...issue2.path];
+        const fullpath = [...path68, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7260,8 +7260,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path65 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path65) {
+  const path68 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path68) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24363,13 +24363,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path65 = ref.slice(1).split("/").filter(Boolean);
-  if (path65.length === 0) {
+  const path68 = ref.slice(1).split("/").filter(Boolean);
+  if (path68.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path65[0] === defsKey) {
-    const key = path65[1] === void 0 ? void 0 : decodeJSONPointerSegment(path65[1]);
+  if (path68[0] === defsKey) {
+    const key = path68[1] === void 0 ? void 0 : decodeJSONPointerSegment(path68[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -25318,6 +25318,9 @@ function enabled(what, markers) {
 function Packages(what, example) {
   return StringsSchema.describe(what + ", installed once and kept (e.g. " + example + ").");
 }
+function secret(schema) {
+  return schema.meta({ secret: true });
+}
 
 // src/core/schema/config.ts
 var import_lodash = __toESM(require_lodash(), 1);
@@ -25386,10 +25389,15 @@ var HarnessSchema = external_exports.strictObject({
   uvPackage: external_exports.string().optional().describe("Python package installed with `uv tool install` inside the sandbox (e.g. aider-chat)."),
   uvBin: external_exports.string().optional().describe("Command the uv package provides."),
   arguments: StringsSchema.describe("Arguments always passed to the agent."),
-  environment: external_exports.record(external_exports.string(), external_exports.string()).describe("Environment variables for the agent."),
+  environment: external_exports.record(external_exports.string(), secret(external_exports.string())).describe(
+    "Environment variables for the agent (API keys go here). Their values are shown as *** and are handed to the sandbox in a one-shot file, never kept in the launch folder. The agent can read its own environment."
+  ),
   home: HarnessHomeSchema.optional().describe(
     "Where its login lives inside the sandbox; leave out when the agent cannot be pointed at a folder (then its login is not kept between sandboxes)."
   ),
+  localState: external_exports.record(external_exports.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), SubfolderSchema).optional().describe(
+    "Environment variable -> folder below the agent's own state folder (state\\<agent>) for SQLite databases. SQLite cannot run in a mapped folder, so the agent runs from a copy on the sandbox's disk (the variable points to it) that is copied from and back to that folder."
+  ),
   resumeArguments: StringsSchema.optional().describe(
     "Arguments used when the agent is restarted in place (e.g. after an account switch) so it resumes the conversation."
   ),
@@ -25441,6 +25449,9 @@ var ClaudeProfileSchema = external_exports.strictObject({
   globalStateFile: external_exports.string().describe('Your .claude.json, or "auto". Empty string = do not copy.'),
   copyCredentials: external_exports.boolean().describe("Copy your Claude LOGIN into the sandbox. Prefer sandbox account instead."),
   overwrite: external_exports.boolean().describe("Refresh these settings from this PC on every launch."),
+  sharePluginsAcrossAccounts: external_exports.boolean().describe(
+    "When you switch Claude accounts, copy your Claude plugins (and which ones are enabled) into a data set that has none yet. Off by default: plugins are code that runs in your sessions."
+  ),
   syncHistory: external_exports.boolean().describe("Bring conversation history in, and sync new history back (path-translated)."),
   historyScope: external_exports.enum(["project", "all"]).describe(
     `Which history comes in: "project" = only the projects in this sandbox (other projects' conversations, file backups and prompts stay on this PC), "all" = everything. Only this sandbox's projects ever sync back.`
@@ -25517,7 +25528,10 @@ var NetworkSchema = external_exports.strictObject({
     "Reach servers in the sandbox from this PC: http://localhost:<pc> here goes to <sandbox> inside, while it runs. Nothing else on your network can use them."
   ),
   dns: external_exports.array(external_exports.string().regex(/^\d{1,3}(\.\d{1,3}){3}$/, "an IPv4 address like 1.1.1.1")).describe("DNS servers for the sandbox instead of your network's, e.g. 1.1.1.1 and 9.9.9.9."),
-  proxy: external_exports.string().regex(/^(https?:\/\/[^\s]+)?$/, "http://host:port").describe(
+  proxy: external_exports.string().regex(/^(https?:\/\/[^\s]+)?$/, "http://host:port").refine(
+    (v) => !/^https?:\/\/[^/?#]*@/i.test(v),
+    "no user name or password in the address (it would be stored in plain text and visible to the agent): use a proxy that needs no login"
+  ).describe(
     "An HTTP proxy the sandbox uses to reach the internet (HTTP_PROXY / HTTPS_PROXY for everything in it), e.g. http://proxy.corp:8080. Empty = none."
   )
 });
@@ -25919,6 +25933,17 @@ var APPS = [
     exe: "lazygit.exe",
     cli: true
   },
+  {
+    id: "jj",
+    name: "Jujutsu (jj)",
+    category: "git",
+    about: "Git-compatible version control; conflicts do not block a rebase. Pilot, untested with worktrees.",
+    size: "10 MB",
+    source: gh("jj-vcs/jj", "^jj-v[\\d.]+-x86_64-pc-windows-msvc\\.zip$"),
+    exe: "jj.exe",
+    cli: true,
+    fullGitOnly: true
+  },
   // ---- utilities
   {
     id: "7zip",
@@ -26447,6 +26472,26 @@ var APPS = [
     source: gh("gitleaks/gitleaks", "^gitleaks_[\\d.]+_windows_x64\\.zip$"),
     exe: "gitleaks.exe",
     cli: true
+  },
+  {
+    id: "ast-grep",
+    name: "ast-grep",
+    category: "cli",
+    about: "Search and rewrite code by its syntax tree (ast-grep, sg); prints only the matches.",
+    size: "15 MB",
+    source: gh("ast-grep/ast-grep", "^app-x86_64-pc-windows-msvc\\.zip$"),
+    exe: "ast-grep.exe",
+    cli: true
+  },
+  {
+    id: "rust-analyzer",
+    name: "rust-analyzer",
+    category: "cli",
+    about: "Rust language server: type errors and go-to-definition without cargo (for editors and the Claude LSP plugin).",
+    size: "18 MB",
+    source: gh("rust-lang/rust-analyzer", "^rust-analyzer-x86_64-pc-windows-msvc\\.zip$"),
+    exe: "rust-analyzer.exe",
+    cli: true
   }
 ];
 function appById(id) {
@@ -26555,6 +26600,33 @@ var ResumeSchema = external_exports.strictObject({
   )
 });
 
+// src/core/schema/web.ts
+var WebSchema = external_exports.strictObject({
+  enabled: external_exports.boolean().describe(
+    "(Beta) Allow the web UI: your sandbox sessions in a browser on this PC. Off by default, and nothing starts it by itself yet: sandbox web start works either way and runs it until sandbox web stop (or a restart of the PC)."
+  ),
+  port: external_exports.number().int().min(1024).max(65535).describe("Port of the web UI on 127.0.0.1 (this PC only). Pick another when it is taken.")
+});
+
+// src/core/schema/vpn.ts
+var VPN_PROVIDERS = ["nordvpn", "openvpn-file"];
+var VpnSchema = external_exports.strictObject({
+  enabled: external_exports.boolean().describe(
+    "Send the sandbox's traffic through a VPN. Only the sandbox: your PC's own connection is untouched. Needs a saved login first (sandbox vpn login). The agent in the sandbox can read that login and can turn the tunnel off (it is the administrator there)."
+  ),
+  provider: external_exports.enum(VPN_PROVIDERS).describe(
+    "nordvpn: a recommended NordVPN server is picked at every launch. openvpn-file: your own .ovpn file (configFile)."
+  ),
+  protocol: external_exports.enum(["udp", "tcp"]).describe("udp is faster; tcp gets through networks that block udp."),
+  country: external_exports.string().regex(/^([A-Za-z][A-Za-z .'-]{0,39})?$/, "a country name or code like uk or Germany").describe("nordvpn: the country of the server, e.g. uk, us or Germany. Empty = the best server anywhere."),
+  configFile: external_exports.string().describe(
+    "openvpn-file: the .ovpn file on this PC (its certificates inside it). Files that run programs (script-security, up, down, plugin ...) are refused. A project's file can never set this."
+  ),
+  killSwitch: external_exports.boolean().describe(
+    "Block all traffic that does not go through the tunnel: when the tunnel cannot start, the sandbox stays offline instead of using your normal connection. A project can only turn this on, never off."
+  )
+});
+
 // src/core/schema/config.ts
 var ConfigSchema = external_exports.strictObject({
   $schema: SchemaRefSchema.optional(),
@@ -26567,7 +26639,9 @@ var ConfigSchema = external_exports.strictObject({
   sandbox: SandboxSchema,
   sharing: SharingSchema,
   storage: external_exports.strictObject({
-    root: external_exports.string().min(1).describe("Where everything is kept on this PC (tools, databases, logins, launches)."),
+    root: external_exports.string().min(1).describe(
+      "Where everything is kept on this PC (tools, databases, logins, launches). The default is a private folder for you under %ProgramData%\\AgentSandbox\\users, which works for installs for one user and for everyone. sandbox storage move <folder> moves it."
+    ),
     persistAgentState: external_exports.boolean().describe("Keep agent logins and history between sandboxes."),
     dataName: NameSchema.describe("Name of the persistent data set (C:\\AgentData) shared by all workspaces."),
     markSandboxFiles: external_exports.boolean().describe(
@@ -26578,6 +26652,7 @@ var ConfigSchema = external_exports.strictObject({
     )
   }),
   network: NetworkSchema,
+  vpn: VpnSchema,
   provisioning: ProvisioningSchema,
   downloads: DownloadsSchema,
   toolchains: ToolchainsSchema,
@@ -26585,6 +26660,7 @@ var ConfigSchema = external_exports.strictObject({
     "Databases running inside the sandbox. Data persists in C:\\AgentData\\databases; each one starts at boot."
   ),
   attach: AttachSchema,
+  web: WebSchema,
   agentCommands: AgentCommandsSchema,
   secrets: SecretsSchema,
   personalization: toggle("Copy your desktop look (theme, accent, taskbar, wallpaper, ...) into the sandbox."),
@@ -26617,6 +26693,8 @@ var LocalOverridesSchema = external_exports.strictObject({
   sandbox: SandboxSchema.omit({ cpuLimit: true, pageFileMb: true }).partial(),
   // A project may block more (the LAN, hosts); it never opens hosts, ports, DNS or a proxy.
   network: NetworkSchema.pick({ blockPrivateRanges: true, blockHosts: true }).partial(),
+  // A project may turn the kill switch on, never off, and never choose a VPN, a server, a file or a login.
+  vpn: VpnSchema.pick({ killSwitch: true }).partial(),
   provisioning: ProvisioningSchema.pick({ copyFromHost: true, fallbackToInstall: true, refresh: true }).extend({ git: GitSchema.partial(), terminal: toggle("Windows Terminal as the sandbox window.").partial() }).partial(),
   downloads: DownloadsSchema.partial(),
   // Every toolchain setting, each one optional (a project usually only switches languages on or pins a version).
@@ -26757,6 +26835,16 @@ var ProjectStatusSchema = external_exports.object({
   databases: external_exports.array(external_exports.object({ database: Text(32), port: external_exports.number().int() })).max(16),
   summary: external_exports.array(Text(512)).max(64)
 });
+var VpnStatusSchema = external_exports.object({
+  state: external_exports.enum(["off", "starting", "up", "failed"]),
+  message: Text(2e3),
+  killSwitch: external_exports.boolean(),
+  /** The server's name, e.g. uk2201.nordvpn.com. */
+  server: Text(128).optional(),
+  /** What the sandbox's traffic looks like from outside, once the tunnel is up. */
+  publicIp: Text(64).optional(),
+  updatedAt: TimeSchema
+});
 
 // src/shared/io/json.ts
 import fs2 from "node:fs";
@@ -26920,20 +27008,25 @@ var scan = (schema, dir) => {
 var RunDir = class {
   root;
   sandboxFile;
+  vpnFile;
   requestsDir;
   responsesDir;
   sessionsDir;
   projectsDir;
   /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
   auditDir;
+  /** One-shot secrets the host hands over (see secrets.ts). Next to run, not in it: shared-use users can change run. */
+  secretsDir;
   constructor(dataDir2) {
     this.root = path6.join(dataDir2, "run");
     this.sandboxFile = path6.join(this.root, "sandbox.json");
+    this.vpnFile = path6.join(this.root, "vpn.json");
     this.requestsDir = path6.join(this.root, "requests");
     this.responsesDir = path6.join(this.root, "responses");
     this.sessionsDir = path6.join(this.root, "sessions");
     this.projectsDir = path6.join(this.root, "projects");
     this.auditDir = path6.join(this.root, "audit");
+    this.secretsDir = path6.join(dataDir2, "secrets");
   }
   requestFile(id) {
     return path6.join(this.requestsDir, safeId(id) + ".json");
@@ -26947,9 +27040,15 @@ var RunDir = class {
   projectFile(name) {
     return path6.join(this.projectsDir, safeId(name) + ".json");
   }
+  secretFile(id) {
+    return path6.join(this.secretsDir, safeId(id) + ".json");
+  }
   readSandboxStatus() {
     return readValid(SandboxStatusSchema, this.sandboxFile);
   }
+  readVpnStatus() {
+    return readValid(VpnStatusSchema, this.vpnFile);
+  }
   readSession(id) {
     return readValid(SessionStatusSchema, this.sessionFile(id));
   }
@@ -27468,16 +27567,94 @@ function safely(what, work) {
   }
 }
 
+// src/guest/runtime/secrets.ts
+import fs12 from "node:fs";
+
+// src/shared/channel/secrets.ts
+var Environment = external_exports.record(external_exports.string().max(256), external_exports.string().max(65536));
+var SecretsFileSchema = external_exports.strictObject({
+  /** The agent the sandbox booted with: its harness environment. */
+  harnessEnvironment: Environment.optional(),
+  /** harnessSpec of a session request (an agent the sandbox did not boot with). */
+  harnessSpecEnvironment: Environment.optional(),
+  /** project.harnesses of a request, by agent name. */
+  projectHarnessEnvironment: external_exports.record(external_exports.string().max(64), Environment).optional(),
+  /** The login of this PC's Claude (claudeProfile.copyCredentials): the text of .credentials.json. */
+  claudeCredentials: external_exports.string().max(1024 * 1024).optional(),
+  /** VPN service credentials (vpn.provider's login), only for the launch's own sandbox. */
+  vpn: external_exports.strictObject({ username: external_exports.string().min(1).max(256), password: external_exports.string().min(1).max(1024) }).optional()
+});
+var withEnvironment = (harness, environment) => environment ? { ...harness, environment: { ...harness.environment, ...environment } } : harness;
+function mergeRequestSecrets(request, secrets) {
+  let merged = request;
+  if (request.harnessSpec && secrets.harnessSpecEnvironment)
+    merged = { ...merged, harnessSpec: withEnvironment(request.harnessSpec, secrets.harnessSpecEnvironment) };
+  if (request.project && secrets.projectHarnessEnvironment) {
+    const given = secrets.projectHarnessEnvironment;
+    merged = {
+      ...merged,
+      project: {
+        ...request.project,
+        harnesses: Object.fromEntries(
+          Object.entries(request.project.harnesses).map(([name, h]) => [name, withEnvironment(h, given[name])])
+        )
+      }
+    };
+  }
+  return merged;
+}
+
+// src/guest/runtime/secrets.ts
+var BOOT_SECRETS_VARIABLE = "SBX_BOOT_SECRETS";
+var MAX_BYTES = 4 * 1024 * 1024;
+function takeSecrets(id) {
+  const file3 = run.secretFile(id);
+  let text;
+  try {
+    if (fs12.statSync(file3).size > MAX_BYTES) throw new Error("too big");
+    text = fs12.readFileSync(file3, "utf8").replace(/^\uFEFF/, "");
+  } catch {
+    return {};
+  } finally {
+    fs12.rmSync(file3, { force: true });
+  }
+  try {
+    const parsed = SecretsFileSchema.safeParse(JSON.parse(text));
+    if (parsed.success) return parsed.data;
+  } catch {
+  }
+  warn("The secrets file for " + id + " was not valid and was ignored.");
+  return {};
+}
+function applyBootEnvironment(environment) {
+  if (session.harness && environment) session.harness.environment = { ...environment };
+}
+function adoptBootSecrets() {
+  const text = process.env[BOOT_SECRETS_VARIABLE];
+  delete process.env[BOOT_SECRETS_VARIABLE];
+  if (!text) return;
+  try {
+    const parsed = SecretsFileSchema.pick({ harnessEnvironment: true }).safeParse(JSON.parse(text));
+    if (parsed.success) applyBootEnvironment(parsed.data.harnessEnvironment);
+  } catch {
+    warn("The boot secrets given to the daemon were not valid.");
+  }
+}
+function withRequestSecrets(req) {
+  if (req.kind !== "session" && req.kind !== "project") return req;
+  return mergeRequestSecrets(req, takeSecrets(req.id));
+}
+
 // src/guest/daemon/daemon.ts
-import fs50 from "node:fs";
+import fs52 from "node:fs";
 
 // src/guest/setup/claude-mem.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import os4 from "node:os";
 import path18 from "node:path";
 
 // src/guest/runtime/process.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import os3 from "node:os";
 import path17 from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -27503,24 +27680,24 @@ function scriptOutput(name, args = [], options = {}) {
   return execOutput(SYSTEM.powershell(), scriptArgs(name, args), options);
 }
 function runScriptWithJson(name, param, data, args = []) {
-  const dir = fs12.mkdtempSync(path17.join(os3.tmpdir(), "sbx-"));
+  const dir = fs13.mkdtempSync(path17.join(os3.tmpdir(), "sbx-"));
   const file3 = path17.join(dir, "input.json");
   try {
-    fs12.writeFileSync(file3, JSON.stringify(data), "utf8");
+    fs13.writeFileSync(file3, JSON.stringify(data), "utf8");
     runScript(name, ["-" + param, file3, ...args]);
   } finally {
-    fs12.rmSync(dir, { recursive: true, force: true });
+    fs13.rmSync(dir, { recursive: true, force: true });
   }
 }
 function robocopy(from, to, files = []) {
   if (!isWin) {
     if (!files.length) {
-      fs12.cpSync(from, to, { recursive: true });
+      fs13.cpSync(from, to, { recursive: true });
       return;
     }
-    fs12.mkdirSync(to, { recursive: true });
-    for (const f of files.filter((f2) => fs12.existsSync(path17.join(from, f2))))
-      fs12.copyFileSync(path17.join(from, f), path17.join(to, f));
+    fs13.mkdirSync(to, { recursive: true });
+    for (const f of files.filter((f2) => fs13.existsSync(path17.join(from, f2))))
+      fs13.copyFileSync(path17.join(from, f), path17.join(to, f));
     return;
   }
   const what = files.length ? files : ["/E", "/MT:16"];
@@ -27552,11 +27729,11 @@ var claudeMemEnabled = () => session.claudeProfile.syncClaudeMem && !dryRun;
 var databaseFingerprint = (dir) => {
   const parts2 = [];
   const walk = (folder) => {
-    for (const entry of fs13.readdirSync(folder, { withFileTypes: true })) {
+    for (const entry of fs14.readdirSync(folder, { withFileTypes: true })) {
       const full = path18.join(folder, entry.name);
       if (entry.isDirectory()) walk(full);
       else if (entry.isFile() && /\.(db|sqlite3?)(-wal)?$/i.test(entry.name)) {
-        const s = fs13.statSync(full);
+        const s = fs14.statSync(full);
         parts2.push(full + ":" + s.size + ":" + s.mtimeMs);
       }
     }
@@ -27568,33 +27745,33 @@ var lastSaved = null;
 var SQLITE_HEADER = "SQLite format 3\0";
 var looksLikeSqlite = (file3) => {
   if (!exists(file3)) return true;
-  const fd = fs13.openSync(file3, "r");
+  const fd = fs14.openSync(file3, "r");
   try {
     const head = Buffer.alloc(16);
-    return fs13.readSync(fd, head, 0, 16, 0) === 16 && head.toString("latin1") === SQLITE_HEADER;
+    return fs14.readSync(fd, head, 0, 16, 0) === 16 && head.toString("latin1") === SQLITE_HEADER;
   } finally {
-    fs13.closeSync(fd);
+    fs14.closeSync(fd);
   }
 };
 var MAX_BACKUPS = 3;
 var BACKUP_EVERY_MS = 6 * 3600 * 1e3;
 var keepBackup = (previous, dir) => {
   if (!exists(previous)) return;
-  const backups = exists(dir) ? fs13.readdirSync(dir).filter((n) => /^\d{13}$/.test(n)).sort() : [];
+  const backups = exists(dir) ? fs14.readdirSync(dir).filter((n) => /^\d{13}$/.test(n)).sort() : [];
   const newest = Number(backups[backups.length - 1] ?? 0);
   if (Date.now() - newest < BACKUP_EVERY_MS) {
-    fs13.rmSync(previous, { recursive: true, force: true });
+    fs14.rmSync(previous, { recursive: true, force: true });
     return;
   }
-  fs13.renameSync(previous, path18.join(mkdirp(dir), String(Date.now())));
+  fs14.renameSync(previous, path18.join(mkdirp(dir), String(Date.now())));
   for (const old of [...backups, String(Date.now())].slice(0, -MAX_BACKUPS))
-    fs13.rmSync(path18.join(dir, old), { recursive: true, force: true });
+    fs14.rmSync(path18.join(dir, old), { recursive: true, force: true });
 };
 function saveClaudeMem() {
   if (!claudeMemEnabled() || !exists(claudeMemPaths.local)) return;
   const { store: store2, local } = claudeMemPaths;
-  const fingerprint = databaseFingerprint(local);
-  if (fingerprint === lastSaved && exists(store2)) return;
+  const fingerprint2 = databaseFingerprint(local);
+  if (fingerprint2 === lastSaved && exists(store2)) return;
   if (!looksLikeSqlite(path18.join(local, "claude-mem.db"))) {
     warn(
       "claude-mem: the local database does not look valid, so it was not saved over the stored copy (" + local + ")."
@@ -27603,30 +27780,287 @@ function saveClaudeMem() {
   }
   const incoming = store2 + ".incoming";
   const previous = store2 + ".previous";
-  fs13.rmSync(incoming, { recursive: true, force: true });
-  fs13.cpSync(local, incoming, { recursive: true, filter: (src) => !/\.(pid|lock)$/i.test(src) });
-  fs13.rmSync(previous, { recursive: true, force: true });
-  if (exists(store2)) fs13.renameSync(store2, previous);
+  fs14.rmSync(incoming, { recursive: true, force: true });
+  fs14.cpSync(local, incoming, { recursive: true, filter: (src) => !/\.(pid|lock)$/i.test(src) });
+  fs14.rmSync(previous, { recursive: true, force: true });
+  if (exists(store2)) fs14.renameSync(store2, previous);
   try {
-    fs13.renameSync(incoming, store2);
+    fs14.renameSync(incoming, store2);
   } catch (e) {
-    if (exists(previous)) fs13.renameSync(previous, store2);
+    if (exists(previous)) fs14.renameSync(previous, store2);
     throw e;
   }
   keepBackup(previous, store2 + ".backups");
-  lastSaved = fingerprint;
+  lastSaved = fingerprint2;
+}
+
+// src/guest/agents/local-state.ts
+import fs15 from "node:fs";
+import path20 from "node:path";
+
+// src/guest/agents/agent-files.ts
+import path19 from "node:path";
+function agentPaths(toolsDir2, name, harness) {
+  const dir = path19.join(toolsDir2, "agents", name);
+  const exe = harness.hostExecutable ?? (harness.uvBin ? harness.uvBin + ".exe" : null);
+  return {
+    dir,
+    exe: exe ? path19.join(dir, exe) : null,
+    cmd: harness.npmBin ? path19.join(dir, harness.npmBin + ".cmd") : null
+  };
+}
+function agentCommand(name, harness) {
+  return harness.npmBin ?? harness.uvBin ?? (harness.hostExecutable ?? name).replace(/\.exe$/i, "");
+}
+function localStateEntries(agents2, stateDir2, localRoot2) {
+  return Object.entries(agents2).flatMap(
+    ([agent, harness]) => Object.entries(harness.localState ?? {}).map(([env, folder]) => ({
+      agent,
+      env,
+      store: path19.join(stateDir2, agent, folder),
+      local: path19.join(localRoot2, agent, folder),
+      processes: [agentCommand(agent, harness) + ".exe"],
+      legacy: path19.join(stateDir2, agent)
+    }))
+  );
+}
+var isDatabaseFile = (name) => /\.(sqlite3?|db)(-wal|-shm)?$/i.test(name);
+var isCopyableDatabaseFile = (name) => isDatabaseFile(name) && !/-shm$/i.test(name);
+
+// src/guest/agents/local-state.ts
+var SQLITE_HEADER2 = "SQLite format 3\0";
+var localRoot = () => path20.join(localDir, "agent-state");
+function agentLocalStates() {
+  return localStateEntries(session.agents ?? {}, stateDir, localRoot());
+}
+function localStateVars() {
+  return Object.fromEntries(agentLocalStates().map((s) => [s.env, s.local]));
+}
+var databaseFiles = (dir, keep) => exists(dir) ? fs15.readdirSync(dir, { withFileTypes: true }).flatMap((e) => e.isFile() && keep(e.name) ? [e.name] : []) : [];
+var looksLikeSqlite2 = (file3) => {
+  const fd = fs15.openSync(file3, "r");
+  try {
+    const head = Buffer.alloc(16);
+    return fs15.readSync(fd, head, 0, 16, 0) === 16 && head.toString("latin1") === SQLITE_HEADER2;
+  } finally {
+    fs15.closeSync(fd);
+  }
+};
+var copyFiles = (from, to, names) => {
+  fs15.rmSync(to, { recursive: true, force: true });
+  mkdirp(to);
+  for (const name of names) fs15.copyFileSync(path20.join(from, name), path20.join(to, name));
+};
+var swapIn = (incoming, store2) => {
+  const previous = store2 + ".previous";
+  fs15.rmSync(previous, { recursive: true, force: true });
+  if (exists(store2)) fs15.renameSync(store2, previous);
+  try {
+    fs15.renameSync(incoming, store2);
+  } catch (e) {
+    if (exists(previous)) fs15.renameSync(previous, store2);
+    throw e;
+  }
+  fs15.rmSync(previous, { recursive: true, force: true });
+};
+function held(s) {
+  if (!isWin) return false;
+  return s.processes.some(
+    (image) => execOutput(SYSTEM.tasklist(), ["/FI", "IMAGENAME eq " + image, "/NH", "/FO", "CSV"]).toLowerCase().includes(image.toLowerCase())
+  );
+}
+var fingerprint = (dir) => databaseFiles(dir, isCopyableDatabaseFile).sort().map((n) => {
+  const st = fs15.statSync(path20.join(dir, n));
+  return n + ":" + st.size + ":" + st.mtimeMs;
+}).join("|");
+var saved = /* @__PURE__ */ new Map();
+var snapshotting = /* @__PURE__ */ new Set();
+var saidNoBackup = false;
+function snapshotWhileRunning(s, print) {
+  if (snapshotting.has(s.local)) return;
+  snapshotting.add(s.local);
+  void (async () => {
+    try {
+      const sqlite = await import("node:sqlite").catch(() => null);
+      if (!sqlite || typeof sqlite.backup !== "function") {
+        if (!saidNoBackup)
+          log(s.agent + ": this Node has no SQLite online backup; its databases are saved when it exits.");
+        saidNoBackup = true;
+        return;
+      }
+      const incoming = s.store + ".incoming";
+      fs15.rmSync(incoming, { recursive: true, force: true });
+      mkdirp(incoming);
+      for (const name of databaseFiles(s.local, (n) => isCopyableDatabaseFile(n) && !/-wal$/i.test(n))) {
+        const db = new sqlite.DatabaseSync(path20.join(s.local, name), { readOnly: true });
+        try {
+          await sqlite.backup(db, path20.join(incoming, name));
+        } finally {
+          db.close();
+        }
+      }
+      swapIn(incoming, s.store);
+      saved.set(s.local, print);
+    } catch (e) {
+      warn(s.agent + ": could not snapshot its running databases: " + errMsg(e));
+    } finally {
+      snapshotting.delete(s.local);
+    }
+  })();
+}
+function saveLocalState() {
+  if (dryRun) return;
+  for (const s of agentLocalStates()) {
+    try {
+      if (!exists(s.local)) continue;
+      const print = fingerprint(s.local);
+      if (!print || saved.get(s.local) === print && exists(s.store)) continue;
+      if (held(s)) {
+        snapshotWhileRunning(s, print);
+        continue;
+      }
+      const names = databaseFiles(s.local, isCopyableDatabaseFile);
+      const bad = names.filter((n) => !/-wal$/i.test(n) && !looksLikeSqlite2(path20.join(s.local, n)));
+      if (bad.length) {
+        warn(s.agent + ": " + bad.join(", ") + " do not look like SQLite databases, so they were not saved.");
+        continue;
+      }
+      const incoming = s.store + ".incoming";
+      copyFiles(s.local, incoming, names);
+      swapIn(incoming, s.store);
+      saved.set(s.local, print);
+    } catch (e) {
+      warn(s.agent + ": could not save its databases: " + errMsg(e));
+    }
+  }
 }
 
 // src/guest/daemon/exec.ts
 import { spawn as spawn5 } from "node:child_process";
 
+// src/guest/setup/environment.ts
+import path22 from "node:path";
+
+// src/guest/setup/path-plan.ts
+import path21 from "node:path";
+function pathKey(folder) {
+  const slashes = folder.trim().replace(/^"|"$/g, "").replace(/\//g, "\\");
+  return (slashes.length > 3 ? slashes.replace(/\\+$/, "") : slashes).toLowerCase();
+}
+function splitPath(value) {
+  return value.split(";").map((part) => part.trim().replace(/^"|"$/g, "")).filter(Boolean);
+}
+function expandVars(value, env) {
+  const lower = new Map(Object.entries(env).map(([k, v]) => [k.toLowerCase(), v]));
+  return value.replace(/%([^%;\\]+)%/g, (whole, name) => lower.get(name.toLowerCase()) ?? whole);
+}
+function planPath(input2) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of input2.entries.flatMap(splitPath)) {
+    const key = pathKey(entry);
+    if (seen.has(key) || input2.drop?.(entry) || !input2.exists(entry)) continue;
+    seen.add(key);
+    result.push(entry);
+  }
+  return result;
+}
+function appendMissing(base, extra, skip = () => false) {
+  const seen = new Set(splitPath(base).map(pathKey));
+  const added = splitPath(extra).filter((folder) => {
+    const key = pathKey(folder);
+    if (seen.has(key) || skip(folder)) return false;
+    seen.add(key);
+    return true;
+  });
+  return [...splitPath(base), ...added].join(";");
+}
+function parseRegPath(output2) {
+  const line = output2.split(/\r?\n/).find((l) => /^\s+Path\s+REG_(EXPAND_)?SZ\s/i.test(l));
+  return line ? line.replace(/^\s+Path\s+REG_(EXPAND_)?SZ\s+/i, "").trim() : "";
+}
+function isPinnedNodeDir(folder, nvmHome2) {
+  const key = pathKey(folder);
+  const home = pathKey(nvmHome2);
+  return key.startsWith(home + "\\") && /^v\d/.test(path21.win32.basename(key));
+}
+
+// src/guest/setup/environment.ts
+var LEGACY_HOMES = { CODEX_HOME: "codex", GEMINI_CLI_HOME: "gemini" };
+var agentHomes = () => Object.fromEntries(
+  Object.entries(session.agentHomes ?? LEGACY_HOMES).filter(([name]) => name !== "CLAUDE_CONFIG_DIR").map(([name, sub]) => [name, path22.join(stateDir, sub)])
+);
+function agentEnv(tools, target = { workspace, project: session.project, base: process.env }) {
+  const homes = agentHomes();
+  const env = {
+    ...target.base,
+    ...tools.vars,
+    CLAUDE_CONFIG_DIR: claudeDir,
+    ...homes,
+    ...localStateVars(),
+    npm_config_cache: path22.join(toolsDir, "npm-cache"),
+    npm_config_update_notifier: "false",
+    AGENT_WORKSPACE: target.workspace,
+    AGENT_DATA: dataDir,
+    AGENT_TOOLS: toolsDir,
+    AGENT_PROJECT: target.project,
+    // For project scripts: "am I in the sandbox, and where is the project?" (stable names; documented).
+    AGENT_SANDBOX: "1",
+    AGENT_SANDBOX_WORKSPACE: target.workspace
+  };
+  const local = Object.keys(localStateVars());
+  for (const dir of [
+    env.CLAUDE_CONFIG_DIR,
+    ...Object.keys(homes).map((n) => env[n]),
+    env.npm_config_cache,
+    ...local.map((n) => env[n])
+  ])
+    mkdirp(dir);
+  const runners = [path22.join(toolsDir, "node"), path22.dirname(process.execPath)].map((d) => d.toLowerCase());
+  const base = (target.base.PATH ?? "").split(path22.delimiter).filter((d) => d && !runners.includes(d.toLowerCase()));
+  env.PATH = [.../* @__PURE__ */ new Set([...tools.prepend, ...base, ...tools.append])].join(path22.delimiter);
+  return env;
+}
+function addMachineEnvironment(vars, dirs, additive = false) {
+  if (!isWin || dryRun || testMode) return;
+  const planned = planPath({ entries: dirs, exists, drop: (dir) => isPinnedNodeDir(dir, nvmHome()) });
+  try {
+    runScriptWithJson("set-machine-environment.ps1", "SettingsFile", { vars, path: null, add: planned, additive });
+  } catch (e) {
+    warn("Could not add to the environment: " + errMsg(e));
+  }
+}
+var nvmHome = () => path22.join(toolsDir, "nvm");
+var MACHINE_ENVIRONMENT_KEY = "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment";
+var USER_ENVIRONMENT_KEY = "HKCU\\Environment";
+var registryPath = (key) => parseRegPath(execOutput(SYSTEM.reg(), ["query", key, "/v", "Path"]));
+function withRegistryPath(env) {
+  if (!isWin || dryRun || testMode) return env;
+  try {
+    const registry2 = expandVars(registryPath(MACHINE_ENVIRONMENT_KEY) + ";" + registryPath(USER_ENVIRONMENT_KEY), env);
+    const runner = pathKey(path22.join(toolsDir, "node"));
+    const pathName = Object.keys(env).find((k) => k.toLowerCase() === "path") ?? "PATH";
+    return {
+      ...env,
+      [pathName]: appendMissing(
+        env[pathName] ?? "",
+        registry2,
+        (dir) => pathKey(dir) === runner || isPinnedNodeDir(dir, nvmHome())
+      )
+    };
+  } catch (e) {
+    warn("Could not read the machine PATH (the session keeps the one it has): " + errMsg(e));
+    return env;
+  }
+}
+
 // src/guest/daemon/project-provisioner.ts
-import fs46 from "node:fs";
-import path59 from "node:path";
+import fs48 from "node:fs";
+import path62 from "node:path";
 
 // src/guest/boot/boot-env.ts
-import fs14 from "node:fs";
-import path19 from "node:path";
+import fs16 from "node:fs";
+import path23 from "node:path";
 
 // src/guest/boot/project-env.ts
 var EnvSchema = external_exports.object({
@@ -27656,22 +28090,22 @@ function baseEnvFor(boot, current = process.env) {
 }
 
 // src/guest/boot/boot-env.ts
-var file2 = () => path19.join(localDir, "boot-env.json");
+var file2 = () => path23.join(localDir, "boot-env.json");
 function readBootEnv() {
   try {
-    return BootEnvSchema.safeParse(JSON.parse(fs14.readFileSync(file2(), "utf8"))).data ?? null;
+    return BootEnvSchema.safeParse(JSON.parse(fs16.readFileSync(file2(), "utf8"))).data ?? null;
   } catch {
     return null;
   }
 }
 
 // src/guest/boot/guide.ts
-import fs15 from "node:fs";
-import path20 from "node:path";
+import fs17 from "node:fs";
+import path24 from "node:path";
 var BEGIN = "<!-- agent-sandbox:begin (generated every boot, do not edit) -->";
 var END = "<!-- agent-sandbox:end -->";
 var mirrorLine = () => {
-  const drives = (session.substDrives ?? []).filter((d) => fs15.existsSync(d.letter + ":\\"));
+  const drives = (session.substDrives ?? []).filter((d) => fs17.existsSync(d.letter + ":\\"));
   if (!drives.length) return [];
   return [
     "- " + drives.map((d) => d.letter + ":").join(", ") + " = mapped folders at their PC paths (subst onto `" + drives.map((d) => d.target).join("`, `") + "`; real-path tools may print that form)."
@@ -27687,8 +28121,8 @@ function sandboxGuide(toolSummary, lan = "blocked", projects = []) {
     ...projects.map(
       (p) => "- RW, persists: `" + p.guest + "` = host folder " + p.host + " (another project in this sandbox; your own is `%AGENT_WORKSPACE%`)"
     ),
-    "- RW, persists: `" + toolsDir + "` (toolchains) \u2014 put portable exes in `" + path20.join(toolsDir, "bin") + "` (on PATH)",
-    "- RW, persists: `" + stateDir + "` (agent config/history; do not edit logins) \xB7 logs: `" + path20.join(dataDir, "logs") + "`",
+    "- RW, persists: `" + toolsDir + "` (toolchains) \u2014 put portable exes in `" + path24.join(toolsDir, "bin") + "` (on PATH)",
+    "- RW, persists: `" + stateDir + "` (agent config/history; do not edit logins) \xB7 logs: `" + path24.join(dataDir, "logs") + "`",
     "- RO: `" + launchDir + "` (this boot's scripts) \xB7 lost on close: everything else, incl. `C:\\nvm` (Node symlink)",
     ...mirrorLine(),
     "- Tools: " + toolSummary.join(" \xB7 "),
@@ -27699,37 +28133,37 @@ function sandboxGuide(toolSummary, lan = "blocked", projects = []) {
   ].join("\n");
 }
 function upsertGuide(file3, guide) {
-  fs15.mkdirSync(path20.dirname(file3), { recursive: true });
-  const current = fs15.existsSync(file3) ? fs15.readFileSync(file3, "utf8") : "";
+  fs17.mkdirSync(path24.dirname(file3), { recursive: true });
+  const current = fs17.existsSync(file3) ? fs17.readFileSync(file3, "utf8") : "";
   const start = current.indexOf(BEGIN);
   const end = current.indexOf(END);
   const without = start >= 0 && end > start ? current.slice(0, start) + current.slice(end + END.length) : current;
-  fs15.writeFileSync(file3, without.trimEnd() + (without.trim() ? "\n\n" : "") + guide + "\n", "utf8");
+  fs17.writeFileSync(file3, without.trimEnd() + (without.trim() ? "\n\n" : "") + guide + "\n", "utf8");
 }
 function managedClaudeMd() {
-  return path20.join(
-    process.env.AGENT_MANAGED_DIR ?? path20.join(process.env.ProgramFiles ?? "C:\\Program Files", "ClaudeCode"),
+  return path24.join(
+    process.env.AGENT_MANAGED_DIR ?? path24.join(process.env.ProgramFiles ?? "C:\\Program Files", "ClaudeCode"),
     "CLAUDE.md"
   );
 }
 function writeGuides(toolSummary, lan, projects = []) {
   const guide = sandboxGuide(toolSummary, lan, projects);
   const managed = managedClaudeMd();
-  fs15.mkdirSync(path20.dirname(managed), { recursive: true });
-  fs15.writeFileSync(managed, guide + "\n", "utf8");
-  fs15.writeFileSync(path20.join(dataDir, "SANDBOX.md"), guide + "\n", "utf8");
-  upsertGuide(path20.join(stateDir, "codex", "AGENTS.md"), guide);
-  upsertGuide(path20.join(stateDir, "gemini", ".gemini", "GEMINI.md"), guide);
-  removeGuide(path20.join(claudeDir, "CLAUDE.md"));
+  fs17.mkdirSync(path24.dirname(managed), { recursive: true });
+  fs17.writeFileSync(managed, guide + "\n", "utf8");
+  fs17.writeFileSync(path24.join(dataDir, "SANDBOX.md"), guide + "\n", "utf8");
+  upsertGuide(path24.join(stateDir, "codex", "AGENTS.md"), guide);
+  upsertGuide(path24.join(stateDir, "gemini", ".gemini", "GEMINI.md"), guide);
+  removeGuide(path24.join(claudeDir, "CLAUDE.md"));
   return managed;
 }
 var removeGuide = (file3) => {
-  if (!fs15.existsSync(file3)) return;
-  const current = fs15.readFileSync(file3, "utf8");
+  if (!fs17.existsSync(file3)) return;
+  const current = fs17.readFileSync(file3, "utf8");
   const start = current.indexOf(BEGIN);
   const end = current.indexOf(END);
   if (start >= 0 && end > start)
-    fs15.writeFileSync(file3, (current.slice(0, start) + current.slice(end + END.length)).trim() + "\n", "utf8");
+    fs17.writeFileSync(file3, (current.slice(0, start) + current.slice(end + END.length)).trim() + "\n", "utf8");
 };
 
 // src/guest/runtime/project-context.ts
@@ -27765,51 +28199,12 @@ function saveProjectStatus(name, workspace2, phase, message, databases, summary)
   }
 }
 
-// src/guest/setup/environment.ts
-import path21 from "node:path";
-var LEGACY_HOMES = { CODEX_HOME: "codex", GEMINI_CLI_HOME: "gemini" };
-var agentHomes = () => Object.fromEntries(
-  Object.entries(session.agentHomes ?? LEGACY_HOMES).filter(([name]) => name !== "CLAUDE_CONFIG_DIR").map(([name, sub]) => [name, path21.join(stateDir, sub)])
-);
-function agentEnv(tools, target = { workspace, project: session.project, base: process.env }) {
-  const homes = agentHomes();
-  const env = {
-    ...target.base,
-    ...tools.vars,
-    CLAUDE_CONFIG_DIR: claudeDir,
-    ...homes,
-    npm_config_cache: path21.join(toolsDir, "npm-cache"),
-    npm_config_update_notifier: "false",
-    AGENT_WORKSPACE: target.workspace,
-    AGENT_DATA: dataDir,
-    AGENT_TOOLS: toolsDir,
-    AGENT_PROJECT: target.project,
-    // For project scripts: "am I in the sandbox, and where is the project?" (stable names; documented).
-    AGENT_SANDBOX: "1",
-    AGENT_SANDBOX_WORKSPACE: target.workspace
-  };
-  for (const dir of [env.CLAUDE_CONFIG_DIR, ...Object.keys(homes).map((n) => env[n]), env.npm_config_cache])
-    mkdirp(dir);
-  const runners = [path21.join(toolsDir, "node"), path21.dirname(process.execPath)].map((d) => d.toLowerCase());
-  const base = (target.base.PATH ?? "").split(path21.delimiter).filter((d) => d && !runners.includes(d.toLowerCase()));
-  env.PATH = [.../* @__PURE__ */ new Set([...tools.prepend, ...base, ...tools.append])].join(path21.delimiter);
-  return env;
-}
-function addMachineEnvironment(vars, dirs, additive = false) {
-  if (!isWin || dryRun || testMode) return;
-  try {
-    runScriptWithJson("set-machine-environment.ps1", "SettingsFile", { vars, path: null, add: dirs, additive });
-  } catch (e) {
-    warn("Could not add to the environment: " + errMsg(e));
-  }
-}
-
 // src/guest/setup/hooks.ts
-import fs16 from "node:fs";
-import path22 from "node:path";
+import fs18 from "node:fs";
+import path25 from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
 var commandFor = (file3) => {
-  const ext = path22.extname(file3).toLowerCase();
+  const ext = path25.extname(file3).toLowerCase();
   if (ext === ".mjs" || ext === ".js") return [process.execPath, [file3]];
   if (!isWin) return null;
   if (ext === ".ps1")
@@ -27817,18 +28212,18 @@ var commandFor = (file3) => {
   if (ext === ".cmd" || ext === ".bat") return [SYSTEM.cmd(), ["/d", "/c", file3]];
   return null;
 };
-var BOOT = { root: path22.join(launchDir, "hooks"), cwd: workspace };
+var BOOT = { root: path25.join(launchDir, "hooks"), cwd: workspace };
 function projectHooks(name, cwd) {
   return {
-    root: path22.join(launchDir, "projects", name, "hooks"),
+    root: path25.join(launchDir, "projects", name, "hooks"),
     cwd
   };
 }
 var hooksOf = (stage, target) => {
-  const dir = path22.join(target.root, stage);
+  const dir = path25.join(target.root, stage);
   if (!exists(dir)) return [];
-  return fs16.readdirSync(dir).sort().flatMap((name) => {
-    const command = commandFor(path22.join(dir, name));
+  return fs18.readdirSync(dir).sort().flatMap((name) => {
+    const command = commandFor(path25.join(dir, name));
     return command ? [{ name, command }] : [];
   });
 };
@@ -27858,25 +28253,25 @@ async function runHooksAsync(stage, env, target) {
 }
 
 // src/guest/toolchains/tool-env.ts
-import path23 from "node:path";
+import path26 from "node:path";
 function emptyEnv() {
   return { vars: {}, prepend: [], append: [], summary: [] };
 }
 var arch = process.arch === "arm64" ? "arm64" : "x64";
 function tool(...parts2) {
-  return path23.join(toolsDir, ...parts2);
+  return path26.join(toolsDir, ...parts2);
 }
 function versionOf(exe, args = ["--version"], options = {}) {
   return /\d+\.\d+\.\d+\S*/.exec(execOutput(exe, args, options))?.[0] ?? "installed";
 }
 
 // src/guest/apps/app-installer.ts
-import fs20 from "node:fs";
-import path28 from "node:path";
+import fs22 from "node:fs";
+import path31 from "node:path";
 
 // src/guest/apps/after-install.ts
-import fs17 from "node:fs";
-import path24 from "node:path";
+import fs19 from "node:fs";
+import path27 from "node:path";
 var SYSINTERNALS_TOOLS = [
   "Process Explorer",
   "Process Monitor",
@@ -27897,16 +28292,16 @@ var SYSINTERNALS_TOOLS = [
   "ZoomIt"
 ];
 async function afterInstall(entry, exe) {
-  const dir = path24.dirname(exe);
+  const dir = path27.dirname(exe);
   if (entry.needs?.includes("mesa")) {
     const mesa = tool("mesa", arch === "arm64" ? "arm64" : "x64");
     for (const dll of ["opengl32.dll", "libgallium_wgl.dll", "dxil.dll"]) {
-      if (exists(path24.join(mesa, dll)) && !exists(path24.join(dir, dll)))
-        fs17.copyFileSync(path24.join(mesa, dll), path24.join(dir, dll));
+      if (exists(path27.join(mesa, dll)) && !exists(path27.join(dir, dll)))
+        fs19.copyFileSync(path27.join(mesa, dll), path27.join(dir, dll));
     }
   }
-  if (entry.id === "godot" && !exists(path24.join(dir, "._sc_"))) fs17.writeFileSync(path24.join(dir, "._sc_"), "");
-  if (entry.id === "sublime") mkdirp(path24.join(dir, "Data"));
+  if (entry.id === "godot" && !exists(path27.join(dir, "._sc_"))) fs19.writeFileSync(path27.join(dir, "._sc_"), "");
+  if (entry.id === "sublime") mkdirp(path27.join(dir, "Data"));
   if (entry.id === "sysinternals") {
     for (const name of SYSINTERNALS_TOOLS) {
       await execAsync(
@@ -27919,14 +28314,14 @@ async function afterInstall(entry, exe) {
 }
 
 // src/guest/apps/find-exe.ts
-import fs18 from "node:fs";
-import path25 from "node:path";
+import fs20 from "node:fs";
+import path28 from "node:path";
 var MAX_DEPTH = 7;
 var MAX_ENTRIES = 5e4;
 var X64_FOLDER = /(^|[\\/])(amd64|x64|x86_64|win64)([\\/]|$)/i;
 function findExe(root, exe) {
   const match = exeMatcher(exe);
-  const best = (hits) => hits.find((h) => X64_FOLDER.test(path25.relative(root, h))) ?? hits[0] ?? null;
+  const best = (hits) => hits.find((h) => X64_FOLDER.test(path28.relative(root, h))) ?? hits[0] ?? null;
   let queue = [root];
   let seen = 0;
   for (let depth = 0; depth < MAX_DEPTH && queue.length; depth++) {
@@ -27935,14 +28330,14 @@ function findExe(root, exe) {
     for (const dir of queue) {
       let entries2;
       try {
-        entries2 = fs18.readdirSync(dir, { withFileTypes: true });
+        entries2 = fs20.readdirSync(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       const hit = entries2.find((e) => e.isFile() && match(e.name));
-      if (hit) hits.push(path25.join(dir, hit.name));
+      if (hit) hits.push(path28.join(dir, hit.name));
       else
-        next.push(...entries2.filter((e) => e.isDirectory() && !e.isSymbolicLink()).map((e) => path25.join(dir, e.name)));
+        next.push(...entries2.filter((e) => e.isDirectory() && !e.isSymbolicLink()).map((e) => path28.join(dir, e.name)));
       if ((seen += entries2.length) > MAX_ENTRIES) return best(hits);
     }
     if (hits.length) return best(hits);
@@ -27953,12 +28348,12 @@ function findExe(root, exe) {
 
 // src/guest/apps/shortcuts.ts
 import os5 from "node:os";
-import path26 from "node:path";
+import path29 from "node:path";
 function shortcuts(apps) {
   if (!apps.length) return;
-  const desktop = path26.join(os5.homedir(), "Desktop");
-  const start = path26.join(
-    process.env.APPDATA ?? path26.join(os5.homedir(), "AppData", "Roaming"),
+  const desktop = path29.join(os5.homedir(), "Desktop");
+  const start = path29.join(
+    process.env.APPDATA ?? path29.join(os5.homedir(), "AppData", "Roaming"),
     "Microsoft",
     "Windows",
     "Start Menu",
@@ -27968,9 +28363,9 @@ function shortcuts(apps) {
   const links = apps.flatMap((app) => {
     const name = app.name.replace(/[\\/:*?"<>|]/g, "");
     return [desktop, start].map((folder) => ({
-      link: path26.join(folder, name + ".lnk"),
+      link: path29.join(folder, name + ".lnk"),
       target: app.exe,
-      workingDirectory: path26.dirname(app.exe)
+      workingDirectory: path29.dirname(app.exe)
     }));
   });
   runScriptWithJson("new-shortcuts.ps1", "ListFile", links);
@@ -28102,12 +28497,12 @@ async function resolve(entry) {
 }
 
 // src/guest/apps/unpack.ts
-import fs19 from "node:fs";
-import path27 from "node:path";
+import fs21 from "node:fs";
+import path30 from "node:path";
 var sevenZip = () => tool("apps", "7zip", "7z.exe");
 async function unpack(entry, file3, out, d) {
   if (entry.id === "7zip") {
-    const sevenZr = path27.join(path27.dirname(file3), "7zr.exe");
+    const sevenZr = path30.join(path30.dirname(file3), "7zr.exe");
     const zr = await githubAsset("ip7z/7zip", /^7zr\.exe$/);
     await downloader.file(zr.url, sevenZr, zr.sha256);
     await execAsync(sevenZr, ["x", "-y", "-o" + out, file3], { stdio: "ignore" });
@@ -28116,17 +28511,17 @@ async function unpack(entry, file3, out, d) {
   switch (entry.unpack ?? "archive") {
     case "file": {
       mkdirp(out);
-      fs19.renameSync(file3, path27.join(out, /^\//.test(entry.exe) ? path27.basename(file3) : entry.exe));
+      fs21.renameSync(file3, path30.join(out, /^\//.test(entry.exe) ? path30.basename(file3) : entry.exe));
       return;
     }
     case "nsis": {
       if (!exists(sevenZip()))
         throw new Error("7-Zip is needed to unpack " + entry.name + " and could not be installed");
-      const raw = path27.join(path27.dirname(out), "raw");
+      const raw = path30.join(path30.dirname(out), "raw");
       await execAsync(sevenZip(), ["x", "-y", "-o" + raw, file3], { stdio: "ignore" });
       const inner = findExe(raw, "/^app-64\\.7z$/");
       if (inner) await execAsync(sevenZip(), ["x", "-y", "-o" + out, inner], { stdio: "ignore" });
-      else fs19.renameSync(raw, out);
+      else fs21.renameSync(raw, out);
       return;
     }
     case "msi": {
@@ -28176,11 +28571,11 @@ var AppInstaller = class {
   async installOne(entry) {
     try {
       const dest = tool("apps", ...entry.id.split("/"));
-      if (!exists(path28.join(dest, MARKER)) || this.options.refresh) await this.download(entry, dest);
+      if (!exists(path31.join(dest, MARKER)) || this.options.refresh) await this.download(entry, dest);
       const exe = findExe(dest, entry.exe);
       if (!exe) throw new Error(entry.exe + " not found in the download");
       await afterInstall(entry, exe);
-      if (entry.cli || entry.id === "sysinternals") this.env.prepend.push(path28.dirname(exe));
+      if (entry.cli || entry.id === "sysinternals") this.env.prepend.push(path31.dirname(exe));
       if (!entry.cli) this.gui.push({ name: entry.name, exe });
       this.installed.push(entry.name);
     } catch (e) {
@@ -28193,10 +28588,10 @@ var AppInstaller = class {
   /** Downloads and unpacks one entry into its folder (replaced in one step: never half there). */
   async download(entry, dest) {
     const work = stagingFolder(dest);
-    const out = path28.join(work, "out");
+    const out = path31.join(work, "out");
     try {
       if ("npm" in entry.source) {
-        const npmCli = path28.join(path28.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+        const npmCli = path31.join(path31.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
         log("Installing " + entry.name + " (npm) ...");
         await execAsync(process.execPath, [
           npmCli,
@@ -28211,14 +28606,14 @@ var AppInstaller = class {
       } else {
         const d = await resolve(entry);
         log("Downloading " + entry.name + " (" + d.fileName + ", ~" + entry.size + " once) ...");
-        const file3 = path28.join(mkdirp(work), d.fileName.replace(/[\\/:*?"<>|]/g, "_"));
+        const file3 = path31.join(mkdirp(work), d.fileName.replace(/[\\/:*?"<>|]/g, "_"));
         await downloader.file(d.url, file3, { sha256: d.sha256 ?? null });
         await unpack(entry, file3, out, d);
       }
-      fs20.writeFileSync(path28.join(out, MARKER), JSON.stringify({ id: entry.id, at: (/* @__PURE__ */ new Date()).toISOString() }));
+      fs22.writeFileSync(path31.join(out, MARKER), JSON.stringify({ id: entry.id, at: (/* @__PURE__ */ new Date()).toISOString() }));
       moveIntoPlace(out, dest);
     } finally {
-      safeRemove(work, path28.dirname(work));
+      safeRemove(work, path31.dirname(work));
     }
   }
 };
@@ -28233,8 +28628,8 @@ async function setupApps(env, apps, o) {
 }
 
 // src/guest/toolchains/detect.ts
-import fs21 from "node:fs";
-import path29 from "node:path";
+import fs23 from "node:fs";
+import path32 from "node:path";
 
 // src/core/detect/versions.ts
 function pickNodeVersion(releases, spec) {
@@ -28366,14 +28761,14 @@ function workspaceEntries() {
   if (known) return known;
   const list = (dir) => {
     try {
-      return fs21.readdirSync(dir, { withFileTypes: true });
+      return fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return [];
     }
   };
   const top = list(workspace2);
   const below = top.filter((d) => d.isDirectory() && !d.name.startsWith(".") && !SKIP_DIRS.has(d.name.toLowerCase())).flatMap(
-    (d) => list(path29.join(workspace2, d.name)).filter((f) => f.isFile()).map((f) => d.name + "/" + f.name)
+    (d) => list(path32.join(workspace2, d.name)).filter((f) => f.isFile()).map((f) => d.name + "/" + f.name)
   );
   const found = [...top.filter((d) => d.isFile()).map((d) => d.name), ...below];
   entries.set(workspace2.toLowerCase(), found);
@@ -28384,9 +28779,9 @@ function wanted(setting, toolchain) {
 }
 function versionFromFiles(files, parse5 = (t) => specFromVersionFile(t)) {
   for (const name of files) {
-    const file3 = path29.join(projectWorkspace(), name);
+    const file3 = path32.join(projectWorkspace(), name);
     if (!exists(file3)) continue;
-    const spec = parse5(fs21.readFileSync(file3, "utf8"), name);
+    const spec = parse5(fs23.readFileSync(file3, "utf8"), name);
     if (spec) return { spec, source: name };
   }
   return null;
@@ -28459,22 +28854,22 @@ var DatabaseServer = class {
 };
 
 // src/guest/databases/dynamodb.ts
-import fs26 from "node:fs";
-import path32 from "node:path";
+import fs28 from "node:fs";
+import path35 from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/guest/toolchains/languages/java.ts
-import fs24 from "node:fs";
-import path30 from "node:path";
+import fs26 from "node:fs";
+import path33 from "node:path";
 
 // src/guest/toolchains/version-cache.ts
-import fs23 from "node:fs";
+import fs25 from "node:fs";
 
 // src/guest/toolchains/state-file.ts
-import fs22 from "node:fs";
+import fs24 from "node:fs";
 function readState(file3, schema, empty) {
   try {
-    return schema.safeParse(JSON.parse(fs22.readFileSync(file3, "utf8").replace(/^\uFEFF/, ""))).data ?? empty;
+    return schema.safeParse(JSON.parse(fs24.readFileSync(file3, "utf8").replace(/^\uFEFF/, ""))).data ?? empty;
   } catch {
     return empty;
   }
@@ -28509,7 +28904,7 @@ var VersionCache = class {
       return cached2.value;
     try {
       const value = await resolve2();
-      fs23.mkdirSync(toolsDir, { recursive: true });
+      fs25.mkdirSync(toolsDir, { recursive: true });
       writeJsonAtomic(this.file(), { ...this.remembered(), [key]: { value, at: Date.now() } });
       return value;
     } catch (e) {
@@ -28562,7 +28957,7 @@ var setupJdk = async (env, config2) => {
   const { major, source } = await javaMajor(config2);
   const release = await resolveCached("java:" + major, async () => (await temurin(major)).release_name);
   const home = tool("java", release.replace(/[^A-Za-z0-9.-]/g, "_"));
-  if (!exists(path30.join(home, "bin", "java.exe"))) {
+  if (!exists(path33.join(home, "bin", "java.exe"))) {
     const asset = await temurin(major);
     log("Downloading Java " + release + " (JDK, ~200 MB once) ...");
     await downloader.archive(asset.binary.package.link, home, {
@@ -28572,13 +28967,13 @@ var setupJdk = async (env, config2) => {
     });
   }
   env.vars.JAVA_HOME = home;
-  env.prepend.push(path30.join(home, "bin"));
+  env.prepend.push(path33.join(home, "bin"));
   env.summary.push("java: " + release + " (Temurin, from " + source + ")");
 };
 async function ensureJdk() {
   const root = tool("java");
-  const installed = exists(root) ? fs24.readdirSync(root).filter((d) => exists(path30.join(root, d, "bin", "java.exe"))).sort((a, b) => b.localeCompare(a, void 0, { numeric: true })) : [];
-  if (installed.length) return path30.join(root, installed[0]);
+  const installed = exists(root) ? fs26.readdirSync(root).filter((d) => exists(path33.join(root, d, "bin", "java.exe"))).sort((a, b) => b.localeCompare(a, void 0, { numeric: true })) : [];
+  if (installed.length) return path33.join(root, installed[0]);
   const scratch = emptyEnv();
   await setupJdk(scratch, { enabled: true, version: "lts", maven: false, gradle: false });
   return scratch.vars.JAVA_HOME;
@@ -28591,7 +28986,7 @@ var setupMaven = async (env) => {
     return pickPackageVersion(versions, "3") ?? Promise.reject(new Error("No Maven 3 release found"));
   });
   const home = tool("maven", version2);
-  if (!exists(path30.join(home, "bin", "mvn.cmd"))) {
+  if (!exists(path33.join(home, "bin", "mvn.cmd"))) {
     const url2 = MAVEN + version2 + "/apache-maven-" + version2 + "-bin.zip";
     log("Downloading Maven " + version2 + " (~10 MB once) ...");
     await downloader.archive(url2, home, {
@@ -28601,7 +28996,7 @@ var setupMaven = async (env) => {
   }
   const repo = tool("maven-repository");
   Object.assign(env.vars, { MAVEN_HOME: home, M2_HOME: home, MAVEN_OPTS: "-Dmaven.repo.local=" + repo });
-  env.prepend.push(path30.join(home, "bin"));
+  env.prepend.push(path33.join(home, "bin"));
   env.summary.push("maven: " + version2);
 };
 var setupGradle = async (env) => {
@@ -28613,7 +29008,7 @@ var setupGradle = async (env) => {
     async () => current?.version ?? Promise.reject(new Error("Gradle version lookup failed"))
   );
   const home = tool("gradle", version2);
-  if (!exists(path30.join(home, "bin", "gradle.bat"))) {
+  if (!exists(path33.join(home, "bin", "gradle.bat"))) {
     if (!current || current.version !== version2)
       throw new Error("Gradle " + version2 + " is not installed and cannot be downloaded right now");
     log("Downloading Gradle " + version2 + " (~130 MB once) ...");
@@ -28624,13 +29019,13 @@ var setupGradle = async (env) => {
     });
   }
   const userHome = tool("gradle-home");
-  fs24.mkdirSync(userHome, { recursive: true });
+  fs26.mkdirSync(userHome, { recursive: true });
   Object.assign(env.vars, {
     GRADLE_HOME: home,
     GRADLE_USER_HOME: userHome,
     GRADLE_OPTS: "-Dorg.gradle.vfs.watch=false"
   });
-  env.prepend.push(path30.join(home, "bin"));
+  env.prepend.push(path33.join(home, "bin"));
   env.summary.push("gradle: " + version2);
 };
 async function setupJava(env, config2) {
@@ -28654,29 +29049,29 @@ async function setupJava(env, config2) {
 }
 
 // src/guest/databases/server.ts
-import fs25 from "node:fs";
-import path31 from "node:path";
+import fs27 from "node:fs";
+import path34 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function dataFor(name) {
-  return path31.join(dataDir, "databases", name);
+  return path34.join(dataDir, "databases", name);
 }
 async function startServer(name, exe, args, port) {
   if (await portOpen(port)) throw new Error("port " + port + " is already in use (change databases." + name + ".port)");
-  const logFile2 = path31.join(logsDir, name + ".log");
-  const out = fs25.openSync(logFile2, "a");
+  const logFile2 = path34.join(logsDir, name + ".log");
+  const out = fs27.openSync(logFile2, "a");
   spawn2(exe, args, { detached: true, stdio: ["ignore", out, out], windowsHide: true }).unref();
-  fs25.closeSync(out);
+  fs27.closeSync(out);
   if (!await waitForPort(port, 60))
     throw new Error(name + " did not start listening on port " + port + "; see " + logFile2);
 }
 async function clearStaleLocks(dir, files, port) {
   if (await portOpen(port)) return;
-  for (const f of files) fs25.rmSync(path31.join(dir, f), { force: true });
+  for (const f of files) fs27.rmSync(path34.join(dir, f), { force: true });
 }
 async function createOnce(data, marker, create) {
-  if (exists(path31.join(data, marker))) return;
+  if (exists(path34.join(data, marker))) return;
   const existed = exists(data);
-  mkdirp(path31.dirname(data));
+  mkdirp(path34.dirname(data));
   try {
     await create();
   } catch (e) {
@@ -28700,9 +29095,9 @@ var DynamoServer = class extends DatabaseServer {
    * local endpoint up from AWS_ENDPOINT_URL_DYNAMODB, with dummy credentials (real ones never reach the sandbox).
    */
   async start(env, plan2) {
-    const java = path32.join(await ensureJdk(), "bin", "java.exe");
+    const java = path35.join(await ensureJdk(), "bin", "java.exe");
     const home = tool("dynamodb-local");
-    if (!exists(path32.join(home, "DynamoDBLocal.jar"))) {
+    if (!exists(path35.join(home, "DynamoDBLocal.jar"))) {
       log("Downloading DynamoDB Local (~60 MB once) ...");
       const sha256 = (await fetchText(DYNAMO_ZIP + ".sha256")).trim().split(/\s+/)[0];
       await downloader.archive(DYNAMO_ZIP, home, {
@@ -28716,9 +29111,9 @@ var DynamoServer = class extends DatabaseServer {
       "dynamodb",
       java,
       [
-        "-Djava.library.path=" + path32.join(home, "DynamoDBLocal_lib"),
+        "-Djava.library.path=" + path35.join(home, "DynamoDBLocal_lib"),
         "-jar",
-        path32.join(home, "DynamoDBLocal.jar"),
+        path35.join(home, "DynamoDBLocal.jar"),
         "-sharedDb",
         "-dbPath",
         data,
@@ -28742,10 +29137,10 @@ var DynamoServer = class extends DatabaseServer {
     );
     if (!plan2.adminPort) return;
     const prefix = tool("dynamodb-admin");
-    const script = path32.join(prefix, "node_modules", "dynamodb-admin", "dist", "dynamodb-admin.js");
+    const script = path35.join(prefix, "node_modules", "dynamodb-admin", "dist", "dynamodb-admin.js");
     if (!exists(script)) {
       log("Installing dynamodb-admin, the DynamoDB web UI (~20 MB once) ...");
-      const npmCli = path32.join(path32.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+      const npmCli = path35.join(path35.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
       await execAsync(
         process.execPath,
         [npmCli, "install", "--global", "--prefix", prefix, "dynamodb-admin", "--no-fund", "--no-audit"],
@@ -28758,15 +29153,15 @@ var DynamoServer = class extends DatabaseServer {
       );
       return;
     }
-    const out = fs26.openSync(path32.join(logsDir, "dynamodb-admin.log"), "a");
+    const out = fs28.openSync(path35.join(logsDir, "dynamodb-admin.log"), "a");
     spawn3(
       process.execPath,
       [script, "--port", String(plan2.adminPort), "--dynamo-endpoint", endpoint, "--skip-default-credentials"],
       { detached: true, stdio: ["ignore", out, out], windowsHide: true, env: { ...process.env, ...aws } }
     ).unref();
-    fs26.closeSync(out);
+    fs28.closeSync(out);
     if (!await waitForPort(plan2.adminPort, 30))
-      throw new Error("dynamodb-admin did not start; see " + path32.join(logsDir, "dynamodb-admin.log"));
+      throw new Error("dynamodb-admin did not start; see " + path35.join(logsDir, "dynamodb-admin.log"));
     env.summary.push(
       "dynamodb-admin: http://localhost:" + plan2.adminPort + " (browse and edit tables in the sandbox's browser)"
     );
@@ -28774,18 +29169,18 @@ var DynamoServer = class extends DatabaseServer {
 };
 
 // src/guest/databases/mongodb.ts
-import path33 from "node:path";
+import path36 from "node:path";
 
 // src/guest/toolchains/install.ts
-import fs27 from "node:fs";
+import fs29 from "node:fs";
 async function downloadFile(url2, file3, sha256 = null) {
   const part = file3 + ".part";
   try {
     await downloader.file(url2, part, sha256);
-    fs27.rmSync(file3, { force: true });
-    fs27.renameSync(part, file3);
+    fs29.rmSync(file3, { force: true });
+    fs29.renameSync(part, file3);
   } finally {
-    fs27.rmSync(part, { force: true });
+    fs29.rmSync(part, { force: true });
   }
 }
 async function installFromGithub(repo, pattern, o) {
@@ -28814,13 +29209,13 @@ var MongoServer = class extends DatabaseServer {
     };
     const version2 = await resolveCached("mongodb:" + plan2.version, async () => (await find()).version);
     const home = tool("mongodb", version2);
-    if (!exists(path33.join(home, "bin", "mongod.exe"))) {
+    if (!exists(path36.join(home, "bin", "mongod.exe"))) {
       const { archive } = await find();
       log("Downloading MongoDB " + version2 + " (~400 MB once) ...");
       await downloader.archive(archive.url, home, { sha256: archive.sha256, locate: "mongod.exe", up: 1 });
     }
     const shell = tool("mongosh");
-    if (!exists(path33.join(shell, "mongosh.exe"))) {
+    if (!exists(path36.join(shell, "mongosh.exe"))) {
       await installFromGithub("mongodb-js/mongosh", /^mongosh-[\d.]+-win32-x64\.zip$/, {
         dest: shell,
         what: "mongosh, the MongoDB shell (~50 MB once)",
@@ -28831,17 +29226,17 @@ var MongoServer = class extends DatabaseServer {
     await clearStaleLocks(data, ["mongod.lock"], plan2.port);
     await startServer(
       "mongodb",
-      path33.join(home, "bin", "mongod.exe"),
+      path36.join(home, "bin", "mongod.exe"),
       ["--dbpath", data, "--bind_ip", "127.0.0.1", "--port", String(plan2.port)],
       plan2.port
     );
-    env.prepend.push(path33.join(home, "bin"), shell);
+    env.prepend.push(path36.join(home, "bin"), shell);
     env.summary.push("mongodb " + version2 + ": mongodb://127.0.0.1:" + plan2.port + " (mongosh on PATH)");
   }
 };
 
 // src/guest/databases/mysql.ts
-import path34 from "node:path";
+import path37 from "node:path";
 var MARIA = "https://downloads.mariadb.org/rest-api/mariadb/";
 var MysqlServer = class extends DatabaseServer {
   id = "mysql";
@@ -28859,8 +29254,8 @@ var MysqlServer = class extends DatabaseServer {
     };
     const version2 = await resolveCached("mariadb-version:" + series, async () => (await latest()).version);
     const home = tool("mariadb", version2);
-    const bin = path34.join(home, "bin");
-    if (!exists(path34.join(bin, "mariadbd.exe"))) {
+    const bin = path37.join(home, "bin");
+    if (!exists(path37.join(bin, "mariadbd.exe"))) {
       const { zip } = await latest();
       log("Downloading MariaDB " + version2 + " (~90 MB once) ...");
       await downloader.archive(zip.file_download_url.replace(/^http:/, "https:"), home, {
@@ -28873,13 +29268,13 @@ var MysqlServer = class extends DatabaseServer {
     const data = dataFor("mariadb");
     await createOnce(data, "mysql", async () => {
       log("Creating the MariaDB database (first start) ...");
-      await execAsync(path34.join(bin, "mariadb-install-db.exe"), ["--datadir=" + data, "--port=" + plan2.port], {
+      await execAsync(path37.join(bin, "mariadb-install-db.exe"), ["--datadir=" + data, "--port=" + plan2.port], {
         stdio: "ignore"
       });
     });
     await startServer(
       "mysql",
-      path34.join(bin, "mariadbd.exe"),
+      path37.join(bin, "mariadbd.exe"),
       ["--datadir=" + data, "--port=" + plan2.port, "--bind-address=127.0.0.1", "--console"],
       plan2.port
     );
@@ -28892,8 +29287,8 @@ var MysqlServer = class extends DatabaseServer {
 };
 
 // src/guest/databases/postgres.ts
-import fs28 from "node:fs";
-import path35 from "node:path";
+import fs30 from "node:fs";
+import path38 from "node:path";
 function postgresData(version2) {
   return dataFor("postgres-" + version2.split(".")[0]);
 }
@@ -28908,8 +29303,8 @@ var PostgresServer = class extends DatabaseServer {
       return hit ? hit.major + "." + hit.latestMinor : Promise.reject(new Error("No supported PostgreSQL " + plan2.version));
     });
     const home = tool("postgres", exact);
-    const bin = path35.join(home, "bin");
-    if (!exists(path35.join(bin, "pg_ctl.exe"))) {
+    const bin = path38.join(home, "bin");
+    if (!exists(path38.join(bin, "pg_ctl.exe"))) {
       log("Downloading PostgreSQL " + exact + " (~330 MB once) ...");
       await downloader.archive(
         "https://get.enterprisedb.com/postgresql/postgresql-" + exact + "-1-windows-x64-binaries.zip",
@@ -28926,7 +29321,7 @@ var PostgresServer = class extends DatabaseServer {
     await createOnce(data, "PG_VERSION", async () => {
       log("Creating the PostgreSQL database (first start) ...");
       await execAsync(
-        path35.join(bin, "initdb.exe"),
+        path38.join(bin, "initdb.exe"),
         ["-D", data, "-U", "postgres", "-A", "trust", "-E", "UTF8", "--locale=C"],
         { stdio: "ignore" }
       );
@@ -28935,7 +29330,7 @@ var PostgresServer = class extends DatabaseServer {
       throw new Error("port " + plan2.port + " is already in use (change databases.postgres.port)");
     await clearStaleLocks(data, ["postmaster.pid"], plan2.port);
     await execAsync(
-      path35.join(bin, "pg_ctl.exe"),
+      path38.join(bin, "pg_ctl.exe"),
       [
         "start",
         "-D",
@@ -28944,7 +29339,7 @@ var PostgresServer = class extends DatabaseServer {
         "-t",
         "60",
         "-l",
-        path35.join(logsDir, "postgres.log"),
+        path38.join(logsDir, "postgres.log"),
         "-o",
         "-p " + plan2.port + " -c listen_addresses=localhost"
       ],
@@ -28959,10 +29354,10 @@ var PostgresServer = class extends DatabaseServer {
   /** Every installed version's cluster shuts down cleanly through pg_ctl first. */
   async stop(plan2) {
     if (exists(tool("postgres"))) {
-      for (const version2 of fs28.readdirSync(tool("postgres"))) {
+      for (const version2 of fs30.readdirSync(tool("postgres"))) {
         const data = postgresData(version2);
-        const pgCtl = path35.join(tool("postgres", version2), "bin", "pg_ctl.exe");
-        if (exists(path35.join(data, "postmaster.pid")) && exists(pgCtl))
+        const pgCtl = path38.join(tool("postgres", version2), "bin", "pg_ctl.exe");
+        if (exists(path38.join(data, "postmaster.pid")) && exists(pgCtl))
           await execAsync(pgCtl, ["stop", "-D", data, "-m", "fast", "-w"], { stdio: "ignore" });
       }
     }
@@ -28971,12 +29366,12 @@ var PostgresServer = class extends DatabaseServer {
 };
 
 // src/guest/databases/redis.ts
-import path36 from "node:path";
+import path39 from "node:path";
 var RedisServer = class extends DatabaseServer {
   id = "redis";
   async start(env, plan2) {
     const home = tool("redis");
-    if (!exists(path36.join(home, "redis-server.exe"))) {
+    if (!exists(path39.join(home, "redis-server.exe"))) {
       await installFromGithub("redis-windows/redis-windows", /^Redis-[\d.]+-Windows-x64-msys2\.zip$/, {
         dest: home,
         what: (a) => "Redis (" + a.name + ", ~10 MB once)",
@@ -28986,7 +29381,7 @@ var RedisServer = class extends DatabaseServer {
     const data = mkdirp(dataFor("redis"));
     await startServer(
       "redis",
-      path36.join(home, "redis-server.exe"),
+      path39.join(home, "redis-server.exe"),
       ["--port", String(plan2.port), "--bind", "127.0.0.1", "--dir", data.replace(/\\/g, "/"), "--appendonly", "yes"],
       plan2.port
     );
@@ -29024,36 +29419,37 @@ async function setupDatabase(env, plan2) {
 }
 
 // src/guest/toolchains/tools/git.ts
-import fs30 from "node:fs";
-import path38 from "node:path";
+import fs32 from "node:fs";
+import path41 from "node:path";
 
 // src/guest/runtime/csc.ts
-import fs29 from "node:fs";
+import fs31 from "node:fs";
 import os6 from "node:os";
-import path37 from "node:path";
+import path40 from "node:path";
 import crypto3 from "node:crypto";
 import { spawnSync as spawnSync5 } from "node:child_process";
-var CSC = path37.join(process.env.WINDIR ?? "C:\\Windows", "Microsoft.NET", "Framework64", "v4.0.30319", "csc.exe");
+var CSC = path40.join(process.env.WINDIR ?? "C:\\Windows", "Microsoft.NET", "Framework64", "v4.0.30319", "csc.exe");
 var SOURCES = {
   ptyhost: "PtyHost.cs",
   gitshim: "GitShim.cs",
   vswhere: "VsWhere.cs",
   openssl: "OpenSsl.cs",
   cargoshim: "CargoShim.cs",
-  linkgate: "LinkGate.cs"
+  linkgate: "LinkGate.cs",
+  pathsync: "PathSync.cs"
 };
 function sourceOf(name) {
-  return path37.join(launchDir, "sandbox", "csharp", SOURCES[name]);
+  return path40.join(launchDir, "sandbox", "csharp", SOURCES[name]);
 }
 function sourceHash(name) {
-  return crypto3.createHash("sha256").update(fs29.readFileSync(sourceOf(name))).digest("hex").slice(0, 12);
+  return crypto3.createHash("sha256").update(fs31.readFileSync(sourceOf(name))).digest("hex").slice(0, 12);
 }
 function ensureCompiled(name) {
-  const exe = path37.join(os6.tmpdir(), "agent-sandbox", name + "-" + sourceHash(name) + ".exe");
+  const exe = path40.join(os6.tmpdir(), "agent-sandbox", name + "-" + sourceHash(name) + ".exe");
   if (exists(exe)) return exe;
   if (!exists(CSC))
     throw new Error("The .NET Framework C# compiler was not found at " + CSC + " (it ships with Windows 10/11).");
-  mkdirp(path37.dirname(exe));
+  mkdirp(path40.dirname(exe));
   const result = spawnSync5(CSC, ["/nologo", "/optimize", "/target:exe", "/out:" + exe, sourceOf(name)], {
     encoding: "utf8",
     windowsHide: true
@@ -29087,23 +29483,23 @@ var installPortableGit = async (root) => {
     await downloader.file(asset.url, sfx, asset.sha256);
     await execAsync(sfx, ["-o" + root, "-y"], { stdio: "ignore" });
   } finally {
-    fs30.rmSync(sfx, { force: true });
+    fs32.rmSync(sfx, { force: true });
   }
 };
 var installGuard = (env, access, realGit) => {
   const dir = mkdirp(tool("gitguard"));
-  const guard = path38.join(launchDir, "runtime", "gitguard.js");
-  if (duringSession() && (exists(path38.join(dir, "git.exe")) || exists(path38.join(dir, "git.cmd")))) {
+  const guard = path41.join(launchDir, "runtime", "gitguard.js");
+  if (duringSession() && (exists(path41.join(dir, "git.exe")) || exists(path41.join(dir, "git.cmd")))) {
   } else
     try {
-      fs30.copyFileSync(ensureCompiled("gitshim"), path38.join(dir, "git.exe"));
-      fs30.rmSync(path38.join(dir, "git.cmd"), { force: true });
+      fs32.copyFileSync(ensureCompiled("gitshim"), path41.join(dir, "git.exe"));
+      fs32.rmSync(path41.join(dir, "git.cmd"), { force: true });
     } catch (e) {
       warn("git guard: falling back to git.cmd (" + errMsg(e) + ")");
-      fs30.writeFileSync(path38.join(dir, "git.cmd"), '@"' + process.execPath + '" "' + guard + '" %*\r\n');
+      fs32.writeFileSync(path41.join(dir, "git.cmd"), '@"' + process.execPath + '" "' + guard + '" %*\r\n');
     }
-  fs30.writeFileSync(
-    path38.join(dir, "bashenv.sh"),
+  fs32.writeFileSync(
+    path41.join(dir, "bashenv.sh"),
     'git() { "' + posix(process.execPath) + '" "' + posix(guard) + '" "$@"; }\nexport -f git\n'
   );
   env.prepend.unshift(dir);
@@ -29112,13 +29508,13 @@ var installGuard = (env, access, realGit) => {
     AGENT_REAL_GIT: access === "readonly" ? realGit : "",
     AGENT_GUARD_NODE: process.execPath,
     AGENT_GUARD_SCRIPT: guard,
-    BASH_ENV: posix(path38.join(dir, "bashenv.sh"))
+    BASH_ENV: posix(path41.join(dir, "bashenv.sh"))
   });
   if (access === "readonly") {
-    const hooks = mkdirp(path38.join(dir, "hooks"));
+    const hooks = mkdirp(path41.join(dir, "hooks"));
     for (const hook of BLOCKED_HOOKS)
-      fs30.writeFileSync(
-        path38.join(hooks, hook),
+      fs32.writeFileSync(
+        path41.join(hooks, hook),
         '#!/bin/sh\necho "git is read-only in this sandbox: ' + hook + ' refused." >&2\nexit 1\n'
       );
     Object.assign(env.vars, {
@@ -29127,22 +29523,22 @@ var installGuard = (env, access, realGit) => {
       GIT_CONFIG_VALUE_0: posix(hooks)
     });
   } else {
-    env.vars.GIT_DIR = path38.join(dataDir, "git-disabled");
+    env.vars.GIT_DIR = path41.join(dataDir, "git-disabled");
   }
 };
 var pointAtOwnCertificates = (root) => {
-  const config2 = path38.join(root, "etc", "gitconfig");
-  const bundle = path38.join(root, "mingw64", "etc", "ssl", "certs", "ca-bundle.crt");
+  const config2 = path41.join(root, "etc", "gitconfig");
+  const bundle = path41.join(root, "mingw64", "etc", "ssl", "certs", "ca-bundle.crt");
   if (!exists(config2) || !exists(bundle)) return;
-  const text = fs30.readFileSync(config2, "utf8");
+  const text = fs32.readFileSync(config2, "utf8");
   const fixed = text.replace(/^(\s*sslCAInfo\s*=\s*).*$/gim, (_m, key) => key + posix(bundle));
-  if (fixed !== text) fs30.writeFileSync(config2, fixed);
+  if (fixed !== text) fs32.writeFileSync(config2, fixed);
 };
 async function setupGit(env, hostCopy, refresh, access) {
   const root = tool("git");
-  const bash = path38.join(root, "bin", "bash.exe");
-  const gitExe = path38.join(root, "cmd", "git.exe");
-  const hostGit = path38.join(hostToolsDir, "git");
+  const bash = path41.join(root, "bin", "bash.exe");
+  const gitExe = path41.join(root, "cmd", "git.exe");
+  const hostGit = path41.join(hostToolsDir, "git");
   if (exists(root) && !exists(bash)) {
     log("Replacing the old MinGit (no bash) with full Git for Windows.");
     safeRemove(root, toolsDir);
@@ -29156,11 +29552,11 @@ async function setupGit(env, hostCopy, refresh, access) {
     }
     const work = stagingFolder(root);
     try {
-      if (hostCopy && exists(path38.join(hostGit, "bin", "bash.exe"))) {
+      if (hostCopy && exists(path41.join(hostGit, "bin", "bash.exe"))) {
         log("Copying Git for Windows from this PC ...");
         robocopy(hostGit, work);
       } else await installPortableGit(work);
-      if (!exists(path38.join(work, "bin", "bash.exe"))) throw new Error("bash.exe missing after installing Git");
+      if (!exists(path41.join(work, "bin", "bash.exe"))) throw new Error("bash.exe missing after installing Git");
       moveIntoPlace(work, root);
     } finally {
       safeRemove(work, toolsDir);
@@ -29169,10 +29565,10 @@ async function setupGit(env, hostCopy, refresh, access) {
   if (!exists(bash)) throw new Error("bash.exe missing after installing Git");
   pointAtOwnCertificates(root);
   env.vars.CLAUDE_CODE_GIT_BASH_PATH = bash;
-  env.append.push(path38.join(root, "usr", "bin"));
+  env.append.push(path41.join(root, "usr", "bin"));
   const version2 = execOutput(gitExe, ["--version"]).replace(/^git version /, "");
   if (access === "full") {
-    env.prepend.push(path38.join(root, "cmd"));
+    env.prepend.push(path41.join(root, "cmd"));
     env.summary.push("git: " + version2);
     return;
   }
@@ -29183,8 +29579,8 @@ async function setupGit(env, hostCopy, refresh, access) {
 }
 
 // src/guest/toolchains/languages/go.ts
-import fs31 from "node:fs";
-import path39 from "node:path";
+import fs33 from "node:fs";
+import path42 from "node:path";
 
 // src/guest/toolchains/package-ledger.ts
 var LedgerSchema = external_exports.record(external_exports.string(), external_exports.string());
@@ -29238,7 +29634,7 @@ async function setupGo(env, config2) {
   }
   const version2 = await resolveCached("go:" + config2.version, async () => (await findRelease(config2.version)).version);
   const root = tool("go", version2);
-  if (!exists(path39.join(root, "bin", "go.exe"))) {
+  if (!exists(path42.join(root, "bin", "go.exe"))) {
     const goArch = arch === "arm64" ? "arm64" : "amd64";
     const file3 = (await findRelease(version2)).files.find(
       (f) => f.os === "windows" && f.arch === goArch && f.kind === "archive"
@@ -29255,16 +29651,16 @@ async function setupGo(env, config2) {
   const vars = {
     GOROOT: root,
     GOPATH,
-    GOBIN: path39.join(GOPATH, "bin"),
-    GOMODCACHE: path39.join(GOPATH, "pkg", "mod"),
+    GOBIN: path42.join(GOPATH, "bin"),
+    GOMODCACHE: path42.join(GOPATH, "pkg", "mod"),
     GOCACHE: tool("go-cache"),
     GOTOOLCHAIN: "auto",
     GOTELEMETRY: "off"
   };
-  fs31.mkdirSync(vars.GOBIN, { recursive: true });
+  fs33.mkdirSync(vars.GOBIN, { recursive: true });
   Object.assign(env.vars, vars);
-  env.prepend.push(path39.join(root, "bin"), vars.GOBIN);
-  const go = path39.join(root, "bin", "go.exe");
+  env.prepend.push(path42.join(root, "bin"), vars.GOBIN);
+  const go = path42.join(root, "bin", "go.exe");
   env.summary.push("go: " + versionOf(go, ["version"]));
   await installOnce(
     env,
@@ -29275,8 +29671,8 @@ async function setupGo(env, config2) {
 }
 
 // src/guest/toolchains/tools/cli.ts
-import fs32 from "node:fs";
-import path41 from "node:path";
+import fs34 from "node:fs";
+import path44 from "node:path";
 
 // src/guest/toolchains/catalogue.ts
 function pwshAsset(arch2) {
@@ -29323,14 +29719,14 @@ function decideCli(settings, ctx) {
 }
 
 // src/guest/toolchains/runtimes.ts
-import path40 from "node:path";
+import path43 from "node:path";
 async function setupSingleExe(env, name, repo, pattern, exeName, dir, options = {}) {
   if (dryRun) {
     log("(dry run) would provision " + name);
     return;
   }
-  const bin = options.subdir ? path40.join(dir, options.subdir) : dir;
-  const exe = path40.join(bin, exeName);
+  const bin = options.subdir ? path43.join(dir, options.subdir) : dir;
+  const exe = path43.join(bin, exeName);
   if (!exists(exe) || options.refresh) {
     const size = options.size ? ", ~" + options.size : "";
     await installFromGithub(repo, pattern, {
@@ -29355,8 +29751,8 @@ async function setupBun(env) {
   );
   Object.assign(env.vars, {
     BUN_INSTALL: tool("bun"),
-    BUN_INSTALL_CACHE_DIR: path40.join(localDir, "bun-cache"),
-    BUN_TMPDIR: path40.join(localDir, "bun-tmp")
+    BUN_INSTALL_CACHE_DIR: path43.join(localDir, "bun-cache"),
+    BUN_TMPDIR: path43.join(localDir, "bun-tmp")
   });
 }
 async function setupDeno(env) {
@@ -29390,12 +29786,12 @@ async function setupUv(env) {
     { size: "20 MB" }
   );
   Object.assign(env.vars, uvVars());
-  env.prepend.push(tool("uv-bin"));
+  env.prepend.push(mkdirp(tool("uv-bin")));
 }
 
 // src/guest/toolchains/tools/cli.ts
 function ghConfigDir() {
-  return path41.join(stateDir, "gh");
+  return path44.join(stateDir, "gh");
 }
 var toolVars = {
   gh: () => ({
@@ -29410,16 +29806,16 @@ var shimOpenssl = (env) => {
     return;
   }
   const shims = mkdirp(tool("shims"));
-  fs32.copyFileSync(ensureCompiled("openssl"), path41.join(shims, "openssl.exe"));
-  fs32.rmSync(path41.join(shims, "openssl.cmd"), { force: true });
+  fs34.copyFileSync(ensureCompiled("openssl"), path44.join(shims, "openssl.exe"));
+  fs34.rmSync(path44.join(shims, "openssl.cmd"), { force: true });
   env.prepend.push(shims);
   env.summary.push("openssl: Git for Windows' copy");
 };
 async function setupCli(env, settings, gitAccess, refresh = false) {
-  const decisions = decideCli(settings, { gitAccess, hasGithubDir: exists(path41.join(projectWorkspace(), ".github")) });
+  const decisions = decideCli(settings, { gitAccess, hasGithubDir: exists(path44.join(projectWorkspace(), ".github")) });
   if (settings.gh && !decisions.gh.on) {
     env.summary.push("gh: off (" + decisions.gh.reason + ")");
-    if (exists(path41.join(ghConfigDir(), "hosts.yml")))
+    if (exists(path44.join(ghConfigDir(), "hosts.yml")))
       warn(
         'gh is off (git access is not "full"), but an earlier gh login is still stored in ' + ghConfigDir() + " and readable by the agent. Run `gh auth logout` in a full-access sandbox, or delete that folder."
       );
@@ -29456,12 +29852,12 @@ async function setupCli(env, settings, gitAccess, refresh = false) {
 }
 
 // src/guest/toolchains/managers.ts
-import fs33 from "node:fs";
-import path42 from "node:path";
+import fs35 from "node:fs";
+import path45 from "node:path";
 function voltaPins() {
   try {
     const pkg = JSON.parse(
-      fs33.readFileSync(path42.join(projectWorkspace(), "package.json"), "utf8").replace(/^\uFEFF/, "")
+      fs35.readFileSync(path45.join(projectWorkspace(), "package.json"), "utf8").replace(/^\uFEFF/, "")
     );
     return Object.fromEntries(
       Object.entries(pkg.volta ?? {}).filter(
@@ -29484,7 +29880,7 @@ async function setupVolta(env) {
     return;
   }
   const dir = tool("volta");
-  if (!exists(path42.join(dir, "volta.exe"))) {
+  if (!exists(path45.join(dir, "volta.exe"))) {
     const pattern = arch === "arm64" ? /^volta-[\d.]+-windows-arm64\.zip$/ : /^volta-[\d.]+-windows\.zip$/;
     await installFromGithub("volta-cli/volta", pattern, {
       dest: dir,
@@ -29493,17 +29889,17 @@ async function setupVolta(env) {
     });
   }
   for (const shim3 of ["node", "npm", "npx", "pnpm", "pnpx", "yarn", "yarnpkg"]) {
-    const target = path42.join(dir, shim3 + ".exe");
-    if (!exists(target)) fs33.copyFileSync(path42.join(dir, "volta-shim.exe"), target);
+    const target = path45.join(dir, shim3 + ".exe");
+    if (!exists(target)) fs35.copyFileSync(path45.join(dir, "volta-shim.exe"), target);
   }
   const home = mkdirp(tool("volta-home"));
-  const shims = mkdirp(path42.join(home, "bin"));
+  const shims = mkdirp(path45.join(home, "bin"));
   const vars = { VOLTA_HOME: home, VOLTA_FEATURE_PNPM: "1" };
   Object.assign(env.vars, vars);
   const pins = voltaPins();
   if (Object.keys(pins).length) env.prepend.push(dir, shims);
   else env.append.push(dir, shims);
-  const volta = path42.join(dir, "volta.exe");
+  const volta = path45.join(dir, "volta.exe");
   for (const [toolName, version2] of Object.entries(pins)) {
     try {
       await execAsync(volta, ["install", toolName + "@" + version2], {
@@ -29525,7 +29921,7 @@ async function setupPyenv(env) {
     return;
   }
   const root = tool("pyenv", "pyenv-win");
-  if (!exists(path42.join(root, "bin", "pyenv.bat"))) {
+  if (!exists(path45.join(root, "bin", "pyenv.bat"))) {
     const tag = await resolveCached("pyenv-win", () => latestGithubTag("pyenv-win/pyenv-win"));
     log("Downloading pyenv-win " + tag + " (~5 MB once) ...");
     await downloader.archive(
@@ -29534,17 +29930,17 @@ async function setupPyenv(env) {
       { locate: "pyenv.bat", up: 1, fileName: "pyenv-win.zip" }
     );
   }
-  const home = root + path42.sep;
+  const home = root + path45.sep;
   Object.assign(env.vars, { PYENV: home, PYENV_ROOT: home, PYENV_HOME: home });
-  env.append.push(path42.join(root, "bin"), path42.join(root, "shims"));
+  env.append.push(path45.join(root, "bin"), path45.join(root, "shims"));
   env.summary.push("pyenv-win: pyenv install <version> / pyenv local <version> (versions persist)");
 }
 
 // src/guest/toolchains/native/cpp.ts
-import path43 from "node:path";
+import path46 from "node:path";
 async function setupCpp(env, config2) {
   const bin = tool("mingw", "mingw64", "bin");
-  const gcc = path43.join(bin, "gcc.exe");
+  const gcc = path46.join(bin, "gcc.exe");
   if (dryRun) {
     log("(dry run) would provision MinGW-w64 GCC");
     return;
@@ -29560,7 +29956,7 @@ async function setupCpp(env, config2) {
   if (!exists(gcc)) throw new Error("gcc.exe missing after installing MinGW");
   env.append.unshift(bin);
   env.vars.CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER = gcc;
-  const cmake = versionOf(path43.join(bin, "cmake.exe"));
+  const cmake = versionOf(path46.join(bin, "cmake.exe"));
   if (cmakeTooOld(cmake))
     warn(
       "The bundled CMake " + cmake + " is older than " + CMAKE_FLOOR + ", which many projects need; set toolchains.cpp.enabled to refresh it, or install a newer CMake into C:\\AgentData\\tools\\bin."
@@ -29570,7 +29966,7 @@ async function setupCpp(env, config2) {
 }
 var setupFlexBison = async (env) => {
   const dir = tool("winflexbison");
-  if (!exists(path43.join(dir, "win_bison.exe"))) {
+  if (!exists(path46.join(dir, "win_bison.exe"))) {
     await installFromGithub("lexxmark/winflexbison", /^win_flex_bison-[\d.]+\.zip$/, {
       dest: dir,
       what: "win_flex / win_bison (~1 MB once)",
@@ -29578,16 +29974,16 @@ var setupFlexBison = async (env) => {
     });
   }
   env.append.push(dir);
-  env.summary.push("win_flex/win_bison: " + versionOf(path43.join(dir, "win_bison.exe")));
+  env.summary.push("win_flex/win_bison: " + versionOf(path46.join(dir, "win_bison.exe")));
 };
 
 // src/guest/toolchains/native/dotnet.ts
-import fs34 from "node:fs";
-import path44 from "node:path";
+import fs36 from "node:fs";
+import path47 from "node:path";
 var DotnetMarkerSchema = external_exports.record(external_exports.string(), external_exports.boolean());
 async function setupDotnet(env, config2, refresh) {
   const root = tool("dotnet");
-  const marker = path44.join(root, ".agent-sandbox-installed.json");
+  const marker = path47.join(root, ".agent-sandbox-installed.json");
   const script = tool("dotnet-install.ps1");
   if (dryRun) {
     log("(dry run) would provision .NET SDK channels " + config2.channels.join(", "));
@@ -29595,11 +29991,11 @@ async function setupDotnet(env, config2, refresh) {
   }
   const recorded = DotnetMarkerSchema.safeParse(exists(marker) && !refresh ? readJsonFile(marker) : {});
   const done = recorded.success ? recorded.data : {};
-  const globalJson = path44.join(projectWorkspace(), "global.json");
+  const globalJson = path47.join(projectWorkspace(), "global.json");
   const installs = [
     ...config2.channels.map((c) => ["channel:" + c, ["-Channel", c]]),
     ...exists(globalJson) ? [
-      ["global.json:" + fs34.readFileSync(globalJson, "utf8").replace(/\s+/g, ""), ["-JSonFile", globalJson]]
+      ["global.json:" + fs36.readFileSync(globalJson, "utf8").replace(/\s+/g, ""), ["-JSonFile", globalJson]]
     ] : []
   ];
   for (const [key, args] of installs.filter(([k]) => !done[k])) {
@@ -29631,12 +30027,12 @@ async function setupDotnet(env, config2, refresh) {
     DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1",
     NUGET_PACKAGES: tool("nuget", "packages")
   });
-  env.prepend.push(root, path44.join(home, ".dotnet", "tools"));
+  env.prepend.push(root, path47.join(home, ".dotnet", "tools"));
   env.summary.push(
-    "dotnet: " + execOutput(path44.join(root, "dotnet.exe"), ["--list-sdks"]).split(/\r?\n/).map((l) => l.split(" ")[0]).filter(Boolean).join(", ")
+    "dotnet: " + execOutput(path47.join(root, "dotnet.exe"), ["--list-sdks"]).split(/\r?\n/).map((l) => l.split(" ")[0]).filter(Boolean).join(", ")
   );
-  const dotnet = path44.join(root, "dotnet.exe");
-  const dotnetEnv = { env: { ...process.env, ...env.vars, PATH: root + path44.delimiter + (process.env.PATH ?? "") } };
+  const dotnet = path47.join(root, "dotnet.exe");
+  const dotnetEnv = { env: { ...process.env, ...env.vars, PATH: root + path47.delimiter + (process.env.PATH ?? "") } };
   await installOnce(
     env,
     "dotnet workload",
@@ -29657,7 +30053,7 @@ var setupFrameworkReferences = async (env, targets) => {
   const root = tool("netfx-references");
   for (const target of targets) {
     const id = "microsoft.netframework.referenceassemblies." + target.toLowerCase();
-    const marker = path44.join(root, ".installed-" + target.toLowerCase());
+    const marker = path47.join(root, ".installed-" + target.toLowerCase());
     if (exists(marker)) continue;
     const staging = tool("netfx-references-" + target.toLowerCase());
     try {
@@ -29672,8 +30068,8 @@ var setupFrameworkReferences = async (env, targets) => {
         staging,
         { fileName: id + ".zip" }
       );
-      fs34.cpSync(path44.join(staging, "build", ".NETFramework"), path44.join(root, ".NETFramework"), { recursive: true });
-      fs34.writeFileSync(marker, version2);
+      fs36.cpSync(path47.join(staging, "build", ".NETFramework"), path47.join(root, ".NETFramework"), { recursive: true });
+      fs36.writeFileSync(marker, version2);
     } catch (e) {
       warn(
         ".NET Framework " + target + " reference assemblies could not be installed (projects targeting it will not build): " + errMsg(e)
@@ -29682,9 +30078,9 @@ var setupFrameworkReferences = async (env, targets) => {
       safeRemove(staging, dataDir);
     }
   }
-  if (!exists(path44.join(root, ".NETFramework"))) return;
-  env.vars.TargetFrameworkRootPath = root + path44.sep;
-  env.summary.push(".NET Framework targeting: " + fs34.readdirSync(path44.join(root, ".NETFramework")).join(", "));
+  if (!exists(path47.join(root, ".NETFramework"))) return;
+  env.vars.TargetFrameworkRootPath = root + path47.sep;
+  env.summary.push(".NET Framework targeting: " + fs36.readdirSync(path47.join(root, ".NETFramework")).join(", "));
 };
 var setupNetFx35 = async (env) => {
   if (execOutput(SYSTEM.reg(), [
@@ -29711,15 +30107,15 @@ var setupNetFx35 = async (env) => {
 };
 
 // src/guest/toolchains/native/mesa.ts
-import path45 from "node:path";
+import path48 from "node:path";
 async function setupMesa(env, config2) {
   if (dryRun) {
     log("(dry run) would provision Mesa 3D");
     return;
   }
   const root = tool("mesa");
-  const dir = path45.join(root, arch === "arm64" ? "arm64" : "x64");
-  if (!exists(path45.join(dir, "opengl32.dll"))) {
+  const dir = path48.join(root, arch === "arm64" ? "arm64" : "x64");
+  if (!exists(path48.join(dir, "opengl32.dll"))) {
     await installFromGithub("pal1000/mesa-dist-win", /^mesa3d-[\d.]+-release-msvc\.7z$/, {
       dest: root,
       what: "Mesa 3D for software OpenGL (~100 MB once)",
@@ -29735,10 +30131,10 @@ async function setupMesa(env, config2) {
 }
 var VULKAN_RUNTIME = "https://sdk.lunarg.com/sdk/download/latest/windows/vulkan-runtime-components.zip";
 var setupLavapipe = async (env, mesaDir) => {
-  const icd = path45.join(mesaDir, arch === "arm64" ? "lvp_icd.aarch64.json" : "lvp_icd.x86_64.json");
-  if (!exists(icd)) throw new Error("this Mesa build has no lavapipe (" + path45.basename(icd) + ")");
+  const icd = path48.join(mesaDir, arch === "arm64" ? "lvp_icd.aarch64.json" : "lvp_icd.x86_64.json");
+  if (!exists(icd)) throw new Error("this Mesa build has no lavapipe (" + path48.basename(icd) + ")");
   const dir = tool("vulkan");
-  if (!exists(path45.join(dir, "vulkan-1.dll"))) {
+  if (!exists(path48.join(dir, "vulkan-1.dll"))) {
     log("Downloading the Vulkan loader (~10 MB once) ...");
     await downloader.archive(VULKAN_RUNTIME, dir, {
       locate: "vulkan-1.dll",
@@ -29752,7 +30148,7 @@ var setupLavapipe = async (env, mesaDir) => {
     { stdio: "ignore" }
   );
   await register(icd);
-  const dozen = path45.join(mesaDir, arch === "arm64" ? "dzn_icd.aarch64.json" : "dzn_icd.x86_64.json");
+  const dozen = path48.join(mesaDir, arch === "arm64" ? "dzn_icd.aarch64.json" : "dzn_icd.x86_64.json");
   const gpu = hasGpu();
   if (gpu && exists(dozen)) await register(dozen);
   env.prepend.push(dir);
@@ -29763,20 +30159,20 @@ var setupLavapipe = async (env, mesaDir) => {
 var hasGpu = () => scriptOutput("get-gpu-names.ps1", [], { timeout: 3e4 }).split(/\r?\n/).map((n) => n.trim()).some((n) => n && !/^Microsoft (Remote Display|Basic (Render|Display))/i.test(n));
 
 // src/guest/toolchains/native/msvc/index.ts
-import fs38 from "node:fs";
-import path49 from "node:path";
+import fs40 from "node:fs";
+import path52 from "node:path";
 
 // src/guest/toolchains/native/msvc/environment.ts
-import fs36 from "node:fs";
-import path47 from "node:path";
+import fs38 from "node:fs";
+import path50 from "node:path";
 
 // src/guest/toolchains/native/msvc/tree.ts
-import fs35 from "node:fs";
-import path46 from "node:path";
+import fs37 from "node:fs";
+import path49 from "node:path";
 var ROOT = tool("msvc");
-var MARKER2 = path46.join(ROOT, ".installed.json");
+var MARKER2 = path49.join(ROOT, ".installed.json");
 function msvcTools(msvc, ...parts2) {
-  return path46.join(ROOT, "VC", "Tools", "MSVC", msvc, ...parts2);
+  return path49.join(ROOT, "VC", "Tools", "MSVC", msvc, ...parts2);
 }
 function hostBin(msvc, ...parts2) {
   return msvcTools(msvc, "bin", "Hostx64", "x64", ...parts2);
@@ -29787,27 +30183,27 @@ function hasCompiler(msvc) {
 var InstalledSchema = external_exports.object({ msvc: external_exports.string().min(1), sdk: external_exports.string().min(1), want: external_exports.string() });
 function readInstalled() {
   try {
-    return InstalledSchema.safeParse(JSON.parse(fs35.readFileSync(MARKER2, "utf8"))).data ?? null;
+    return InstalledSchema.safeParse(JSON.parse(fs37.readFileSync(MARKER2, "utf8"))).data ?? null;
   } catch {
     return null;
   }
 }
 
 // src/guest/toolchains/native/msvc/environment.ts
-var VSWHERE_DIR = path47.join(
+var VSWHERE_DIR = path50.join(
   process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)",
   "Microsoft Visual Studio",
   "Installer"
 );
 function vcvars(root, msvc, sdk) {
-  const vc = path47.join(root, "VC", "Tools", "MSVC", msvc);
-  const kits = path47.join(root, "Windows Kits", "10");
-  const inc = (...p) => path47.join(kits, "Include", sdk, ...p);
-  const lib = (...p) => path47.join(kits, "Lib", sdk, ...p);
+  const vc = path50.join(root, "VC", "Tools", "MSVC", msvc);
+  const kits = path50.join(root, "Windows Kits", "10");
+  const inc = (...p) => path50.join(kits, "Include", sdk, ...p);
+  const lib = (...p) => path50.join(kits, "Lib", sdk, ...p);
   return {
     vars: {
       VSINSTALLDIR: root + "\\",
-      VCINSTALLDIR: path47.join(root, "VC") + "\\",
+      VCINSTALLDIR: path50.join(root, "VC") + "\\",
       VCToolsInstallDir: vc + "\\",
       VCToolsVersion: msvc,
       VisualStudioVersion: "17.0",
@@ -29819,17 +30215,17 @@ function vcvars(root, msvc, sdk) {
       VSCMD_ARG_HOST_ARCH: "x64",
       VSCMD_ARG_TGT_ARCH: "x64",
       Platform: "x64",
-      INCLUDE: [path47.join(vc, "include"), inc("ucrt"), inc("shared"), inc("um"), inc("winrt"), inc("cppwinrt")].join(
+      INCLUDE: [path50.join(vc, "include"), inc("ucrt"), inc("shared"), inc("um"), inc("winrt"), inc("cppwinrt")].join(
         ";"
       ),
-      LIB: [path47.join(vc, "lib", "x64"), lib("ucrt", "x64"), lib("um", "x64")].join(";"),
-      LIBPATH: [path47.join(vc, "lib", "x64"), path47.join(vc, "lib", "x86", "store", "references")].join(";")
+      LIB: [path50.join(vc, "lib", "x64"), lib("ucrt", "x64"), lib("um", "x64")].join(";"),
+      LIBPATH: [path50.join(vc, "lib", "x64"), path50.join(vc, "lib", "x86", "store", "references")].join(";")
     },
-    path: [path47.join(vc, "bin", "Hostx64", "x64"), path47.join(kits, "bin", sdk, "x64")]
+    path: [path50.join(vc, "bin", "Hostx64", "x64"), path50.join(kits, "bin", sdk, "x64")]
   };
 }
 function writeVcvars(env) {
-  const dir = mkdirp(path47.join(ROOT, "VC", "Auxiliary", "Build"));
+  const dir = mkdirp(path50.join(ROOT, "VC", "Auxiliary", "Build"));
   const lines = [
     "@echo off",
     "rem Written by Windows Development Sandbox for its portable MSVC (host x64, target x64).",
@@ -29837,9 +30233,9 @@ function writeVcvars(env) {
     'set "PATH=' + env.path.join(";") + ';%PATH%"',
     "exit /b 0"
   ];
-  fs36.writeFileSync(path47.join(dir, "vcvars64.bat"), lines.join("\r\n") + "\r\n");
-  fs36.writeFileSync(
-    path47.join(dir, "vcvarsall.bat"),
+  fs38.writeFileSync(path50.join(dir, "vcvars64.bat"), lines.join("\r\n") + "\r\n");
+  fs38.writeFileSync(
+    path50.join(dir, "vcvarsall.bat"),
     ["@echo off", "rem Only x64 (amd64) is installed.", 'call "%~dp0vcvars64.bat"', "exit /b %errorlevel%"].join(
       "\r\n"
     ) + "\r\n"
@@ -29847,24 +30243,24 @@ function writeVcvars(env) {
 }
 function installVswhere(msvc) {
   mkdirp(VSWHERE_DIR);
-  fs36.copyFileSync(ensureCompiled("vswhere"), path47.join(VSWHERE_DIR, "vswhere.exe"));
+  fs38.copyFileSync(ensureCompiled("vswhere"), path50.join(VSWHERE_DIR, "vswhere.exe"));
   const [major, minor] = msvc.split(".").slice(2);
-  fs36.writeFileSync(
-    path47.join(VSWHERE_DIR, "vswhere.json"),
+  fs38.writeFileSync(
+    path50.join(VSWHERE_DIR, "vswhere.json"),
     JSON.stringify({ installationPath: ROOT, installationVersion: "17." + (minor ?? "0") + ".0." + (major ?? "0") })
   );
 }
 function removeTelemetry(msvc) {
   try {
-    fs36.rmSync(hostBin(msvc, "vctip.exe"), { force: true });
+    fs38.rmSync(hostBin(msvc, "vctip.exe"), { force: true });
   } catch (e) {
     warn("Could not remove MSVC's telemetry helper (vctip.exe); it may keep tools\\msvc locked: " + errMsg(e));
   }
 }
 
 // src/guest/toolchains/native/msvc/packages.ts
-import fs37 from "node:fs";
-import path48 from "node:path";
+import fs39 from "node:fs";
+import path51 from "node:path";
 var CHANNEL = "https://aka.ms/vs/17/release/channel";
 var MANIFEST_DAY_MS = 24 * 60 * 60 * 1e3;
 var MSVC_PARTS = [
@@ -29890,10 +30286,10 @@ var SDK_MSIS = [
   "Windows SDK Desktop Tools x64-x86_en-us.msi"
 ];
 var manifest = async () => {
-  const cached2 = path48.join(ROOT, ".manifest.json");
-  if (exists(cached2) && Date.now() - fs37.statSync(cached2).mtimeMs < MANIFEST_DAY_MS) {
+  const cached2 = path51.join(ROOT, ".manifest.json");
+  if (exists(cached2) && Date.now() - fs39.statSync(cached2).mtimeMs < MANIFEST_DAY_MS) {
     try {
-      return JSON.parse(fs37.readFileSync(cached2, "utf8"));
+      return JSON.parse(fs39.readFileSync(cached2, "utf8"));
     } catch {
     }
   }
@@ -29902,26 +30298,26 @@ var manifest = async () => {
   if (!item) throw new Error("the Visual Studio channel has no package manifest");
   mkdirp(ROOT);
   await downloader.file(item.url, cached2);
-  return JSON.parse(fs37.readFileSync(cached2, "utf8"));
+  return JSON.parse(fs39.readFileSync(cached2, "utf8"));
 };
 var unpackVsix = async (vsix, work) => {
-  const out = mkdirp(path48.join(work, "vsix-" + path48.basename(vsix)));
+  const out = mkdirp(path51.join(work, "vsix-" + path51.basename(vsix)));
   await extractArchive(vsix, out, ["Contents"]);
   const decode4 = (dir) => {
-    for (const entry of fs37.readdirSync(dir, { withFileTypes: true })) {
-      const from = path48.join(dir, entry.name);
+    for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
+      const from = path51.join(dir, entry.name);
       let name = entry.name;
       try {
         if (name.includes("%")) name = decodeURIComponent(name);
       } catch {
       }
-      const to = path48.join(dir, name);
-      if (to !== from) fs37.renameSync(from, to);
+      const to = path51.join(dir, name);
+      if (to !== from) fs39.renameSync(from, to);
       if (entry.isDirectory()) decode4(to);
     }
   };
   decode4(out);
-  fs37.cpSync(path48.join(out, "Contents"), ROOT, { recursive: true, force: true });
+  fs39.cpSync(path51.join(out, "Contents"), ROOT, { recursive: true, force: true });
   safeRemove(out, work);
 };
 var unpackMsi = async (msi) => {
@@ -29931,9 +30327,9 @@ var unpackMsi = async (msi) => {
       stdio: "ignore"
     });
   } catch (e) {
-    const lines = exists(logFile2) ? fs37.readFileSync(logFile2, "utf16le").split(/\r?\n/).filter((l) => /error|return value 3|failed/i.test(l)).slice(-4).join(" | ") : "";
+    const lines = exists(logFile2) ? fs39.readFileSync(logFile2, "utf16le").split(/\r?\n/).filter((l) => /error|return value 3|failed/i.test(l)).slice(-4).join(" | ") : "";
     throw new Error(
-      path48.basename(msi) + " did not unpack: " + (e instanceof Error ? e.message : String(e)) + (lines ? " (" + lines.slice(0, 600) + ")" : "")
+      path51.basename(msi) + " did not unpack: " + (e instanceof Error ? e.message : String(e)) + (lines ? " (" + lines.slice(0, 600) + ")" : "")
     );
   }
 };
@@ -29946,13 +30342,13 @@ var catalogue = (m) => {
   };
 };
 var payloadFetcher = (work) => async (p) => {
-  const file3 = path48.join(work, path48.basename(p.fileName.replace(/\\/g, "/")));
+  const file3 = path51.join(work, path51.basename(p.fileName.replace(/\\/g, "/")));
   if (!exists(file3)) await downloader.file(p.url, file3, p.sha256);
   return file3;
 };
 var unpackedToolset = () => {
-  const toolsRoot = path48.join(ROOT, "VC", "Tools", "MSVC");
-  return fs37.readdirSync(toolsRoot).filter((d) => exists(hostBin(d, "cl.exe"))).sort((a, b) => a.localeCompare(b, void 0, { numeric: true })).pop();
+  const toolsRoot = path51.join(ROOT, "VC", "Tools", "MSVC");
+  return fs39.readdirSync(toolsRoot).filter((d) => exists(hostBin(d, "cl.exe"))).sort((a, b) => a.localeCompare(b, void 0, { numeric: true })).pop();
 };
 async function installPackages(config2) {
   const { ids, pick: pick2 } = catalogue(await manifest());
@@ -29960,7 +30356,7 @@ async function installPackages(config2) {
   if (!version2) throw new Error("no MSVC " + config2.msvcVersion + " in the Visual Studio manifest");
   const sdk = pickWindowsSdk(ids, config2.sdkVersion);
   if (!sdk) throw new Error("no Windows SDK " + config2.sdkVersion + " in the Visual Studio manifest");
-  const work = mkdirp(path48.join(ROOT, ".download"));
+  const work = mkdirp(path51.join(ROOT, ".download"));
   const fetchPayload = payloadFetcher(work);
   log("Downloading the MSVC " + version2 + " compiler and C/C++ libraries ...");
   for (const part of MSVC_PARTS) {
@@ -29980,17 +30376,17 @@ async function installPackages(config2) {
     if (!p) throw new Error("the Windows SDK package has no " + name);
     const file3 = await fetchPayload(p);
     msis.push(file3);
-    for (const cab of msiCabs(fs37.readFileSync(file3))) {
+    for (const cab of msiCabs(fs39.readFileSync(file3))) {
       const c = payload(cab);
       if (c) await fetchPayload(c);
     }
   }
   log("Unpacking the Windows SDK (a few minutes) ...");
   for (const msi of msis) await unpackMsi(msi);
-  for (const name of fs37.readdirSync(ROOT).filter((n) => n.toLowerCase().endsWith(".msi")))
-    fs37.rmSync(path48.join(ROOT, name), { force: true });
+  for (const name of fs39.readdirSync(ROOT).filter((n) => n.toLowerCase().endsWith(".msi")))
+    fs39.rmSync(path51.join(ROOT, name), { force: true });
   safeRemove(work, ROOT);
-  const sdkVersion = fs37.readdirSync(path48.join(ROOT, "Windows Kits", "10", "Include")).filter((d) => d.startsWith("10.0." + sdk.build)).sort().pop();
+  const sdkVersion = fs39.readdirSync(path51.join(ROOT, "Windows Kits", "10", "Include")).filter((d) => d.startsWith("10.0." + sdk.build)).sort().pop();
   if (!sdkVersion) throw new Error("the Windows SDK did not unpack (no Include\\10.0." + sdk.build + ".*)");
   const toolset = unpackedToolset();
   if (!toolset) throw new Error("MSVC " + version2 + " did not unpack (no cl.exe under VC\\Tools\\MSVC)");
@@ -30004,8 +30400,8 @@ function installedMsvcEnv() {
 }
 var clearTree = () => {
   if (!exists(ROOT)) return;
-  for (const name of fs38.readdirSync(ROOT).filter((n) => n !== ".manifest.json" && n !== ".download"))
-    safeRemove(path49.join(ROOT, name), ROOT);
+  for (const name of fs40.readdirSync(ROOT).filter((n) => n !== ".manifest.json" && n !== ".download"))
+    safeRemove(path52.join(ROOT, name), ROOT);
 };
 async function setupMsvc(env, config2) {
   if (!config2.acceptLicense) {
@@ -30035,24 +30431,24 @@ async function setupMsvc(env, config2) {
 }
 
 // src/guest/toolchains/native/rust.ts
-import path51 from "node:path";
+import path54 from "node:path";
 
 // src/guest/toolchains/native/binstall.ts
-import fs39 from "node:fs";
-import path50 from "node:path";
+import fs41 from "node:fs";
+import path53 from "node:path";
 var ensureBinstall = async (cargoBin) => {
-  const target = path50.join(cargoBin, "cargo-binstall.exe");
+  const target = path53.join(cargoBin, "cargo-binstall.exe");
   if (exists(target)) return true;
   try {
     const dir = tool("cargo-binstall");
-    if (!exists(path50.join(dir, "cargo-binstall.exe"))) {
+    if (!exists(path53.join(dir, "cargo-binstall.exe"))) {
       await installFromGithub("cargo-bins/cargo-binstall", binstallAsset(arch), {
         dest: dir,
         what: "cargo-binstall for prebuilt Rust tools (~10 MB once)",
         locate: "cargo-binstall.exe"
       });
     }
-    fs39.copyFileSync(path50.join(dir, "cargo-binstall.exe"), target);
+    fs41.copyFileSync(path53.join(dir, "cargo-binstall.exe"), target);
     return true;
   } catch (e) {
     warn("cargo-binstall unavailable, compiling crates with cargo install instead: " + errMsg(e));
@@ -30060,14 +30456,14 @@ var ensureBinstall = async (cargoBin) => {
   }
 };
 function crateInstaller(cargoHome, cargoEnv) {
-  const cargo = path50.join(cargoHome, "bin", "cargo.exe");
+  const cargo = path53.join(cargoHome, "bin", "cargo.exe");
   let binstall = null;
   const binstallEnv = {
     ...cargoEnv,
     env: { ...cargoEnv.env ?? process.env, BINSTALL_DISABLE_TELEMETRY: "true" }
   };
   return async (crate) => {
-    binstall ??= ensureBinstall(path50.join(cargoHome, "bin"));
+    binstall ??= ensureBinstall(path53.join(cargoHome, "bin"));
     if (await binstall) {
       try {
         await execAsync(
@@ -30089,7 +30485,7 @@ async function setupRust(env, config2, refresh) {
   const RUSTUP_HOME = tool("rust", "rustup");
   const CARGO_HOME = tool("rust", "cargo");
   const rustEnv = { env: { ...process.env, RUSTUP_HOME, CARGO_HOME } };
-  const rustup = path51.join(CARGO_HOME, "bin", "rustup.exe");
+  const rustup = path54.join(CARGO_HOME, "bin", "rustup.exe");
   if (dryRun) {
     log("(dry run) would provision Rust " + config2.toolchain + " (" + config2.host + ")");
     return;
@@ -30125,9 +30521,9 @@ async function setupRust(env, config2, refresh) {
     if (refresh) await execAsync(rustup, ["update"], rustEnv);
   }
   Object.assign(env.vars, { RUSTUP_HOME, CARGO_HOME });
-  env.prepend.push(path51.join(CARGO_HOME, "bin"));
+  env.prepend.push(path54.join(CARGO_HOME, "bin"));
   env.summary.push(
-    "rust: " + versionOf(path51.join(CARGO_HOME, "bin", "rustc.exe"), ["--version"], rustEnv) + " [" + config2.host + "]"
+    "rust: " + versionOf(path54.join(CARGO_HOME, "bin", "rustc.exe"), ["--version"], rustEnv) + " [" + config2.host + "]"
   );
   const toolchainKey = "rustup@" + config2.toolchain;
   await installOnce(
@@ -30148,36 +30544,36 @@ async function setupRust(env, config2, refresh) {
     env: {
       ...rustEnv.env,
       ...msvc.vars,
-      PATH: [path51.join(CARGO_HOME, "bin"), ...msvc.path, process.env.PATH ?? ""].join(path51.delimiter)
+      PATH: [path54.join(CARGO_HOME, "bin"), ...msvc.path, process.env.PATH ?? ""].join(path54.delimiter)
     }
   } : {
     env: {
       ...rustEnv.env,
-      CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER: path51.join(mingw, "gcc.exe"),
-      PATH: [path51.join(CARGO_HOME, "bin"), mingw, process.env.PATH ?? ""].join(path51.delimiter)
+      CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER: path54.join(mingw, "gcc.exe"),
+      PATH: [path54.join(CARGO_HOME, "bin"), mingw, process.env.PATH ?? ""].join(path54.delimiter)
     }
   };
   await installOnce(env, "cargo", config2.crates, crateInstaller(CARGO_HOME, cargoEnv));
 }
 
 // src/guest/toolchains/languages/node.ts
-import fs40 from "node:fs";
-import path52 from "node:path";
+import fs42 from "node:fs";
+import path55 from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 var NVM_HOME = tool("nvm");
-var NVM_SYMLINK = path52.join(localDir, "nodejs");
-var HOST_NVM = path52.join(hostToolsDir, "nvm");
+var NVM_SYMLINK = path55.join(localDir, "nodejs");
+var HOST_NVM = path55.join(hostToolsDir, "nvm");
 var HOST_VERSIONS_MAX = 3;
-var hostNvmVersions = () => exists(HOST_NVM) ? fs40.readdirSync(HOST_NVM).filter((d) => /^v\d+\.\d+\.\d+$/.test(d) && exists(path52.join(HOST_NVM, d, "node.exe"))).map((d) => d.slice(1)) : [];
+var hostNvmVersions = () => exists(HOST_NVM) ? fs42.readdirSync(HOST_NVM).filter((d) => /^v\d+\.\d+\.\d+$/.test(d) && exists(path55.join(HOST_NVM, d, "node.exe"))).map((d) => d.slice(1)) : [];
 var resolveNode = (spec) => resolveCached("node:" + spec, async () => {
   const exact = spec.replace(/^v/, "");
   if (/^\d+\.\d+\.\d+$/.test(exact)) return exact;
   const releases = await fetchJson("https://nodejs.org/dist/index.json");
   return pickNodeVersion(releases, spec) ?? Promise.reject(new Error('No Node.js release matches "' + spec + '"'));
 });
-var NVM_TEMP = path52.join(NVM_HOME, ".tmp");
+var NVM_TEMP = path55.join(NVM_HOME, ".tmp");
 var nvm = (args) => new Promise((resolve2) => {
-  const child = spawn4(path52.join(NVM_HOME, "nvm.exe"), args, {
+  const child = spawn4(path55.join(NVM_HOME, "nvm.exe"), args, {
     windowsHide: true,
     env: { ...process.env, NVM_HOME, NVM_SYMLINK, TEMP: NVM_TEMP, TMP: NVM_TEMP }
   });
@@ -30192,12 +30588,12 @@ var nvm = (args) => new Promise((resolve2) => {
   child.once("close", () => resolve2(out));
 });
 var ensureNvm = async () => {
-  if (exists(path52.join(NVM_HOME, "nvm.exe"))) return;
-  if (exists(path52.join(HOST_NVM, "nvm.exe"))) {
+  if (exists(path55.join(NVM_HOME, "nvm.exe"))) return;
+  if (exists(path55.join(HOST_NVM, "nvm.exe"))) {
     log("Copying nvm from this PC ...");
     mkdirp(NVM_HOME);
-    const files = fs40.readdirSync(HOST_NVM).filter((f) => /\.(exe|cmd|vbs)$/i.test(f)).sort((a, b) => Number(a.toLowerCase() === "nvm.exe") - Number(b.toLowerCase() === "nvm.exe"));
-    for (const file3 of files) fs40.copyFileSync(path52.join(HOST_NVM, file3), path52.join(NVM_HOME, file3));
+    const files = fs42.readdirSync(HOST_NVM).filter((f) => /\.(exe|cmd|vbs)$/i.test(f)).sort((a, b) => Number(a.toLowerCase() === "nvm.exe") - Number(b.toLowerCase() === "nvm.exe"));
+    for (const file3 of files) fs42.copyFileSync(path55.join(HOST_NVM, file3), path55.join(NVM_HOME, file3));
     return;
   }
   const asset = await githubAsset("coreybutler/nvm-windows", /^nvm-noinstall\.zip$/, true);
@@ -30205,10 +30601,10 @@ var ensureNvm = async () => {
   await downloader.archive(asset.url, NVM_HOME, { sha256: asset.sha256, locate: "nvm.exe", fileName: asset.name });
 };
 var installNodeVersion = async (version2) => {
-  const dir = path52.join(NVM_HOME, "v" + version2);
-  const fromHost = path52.join(HOST_NVM, "v" + version2);
-  if (exists(path52.join(dir, "node.exe"))) return;
-  if (exists(path52.join(fromHost, "node.exe"))) {
+  const dir = path55.join(NVM_HOME, "v" + version2);
+  const fromHost = path55.join(HOST_NVM, "v" + version2);
+  if (exists(path55.join(dir, "node.exe"))) return;
+  if (exists(path55.join(fromHost, "node.exe"))) {
     log("Copying Node " + version2 + " from this PC's nvm (without global packages) ...");
     copyNode(fromHost, dir);
     return;
@@ -30221,14 +30617,14 @@ var installNodeVersion = async (version2) => {
   } finally {
     safeRemove(NVM_TEMP, NVM_HOME);
   }
-  if (!exists(path52.join(dir, "node.exe")))
+  if (!exists(path55.join(dir, "node.exe")))
     throw new Error("nvm install " + version2 + " failed: " + out.trim().split("\n").slice(-2).join(" "));
 };
 var activate = async (version2) => {
   await nvm(["use", version2]);
-  if (exists(path52.join(NVM_SYMLINK, "node.exe"))) return;
-  fs40.rmSync(NVM_SYMLINK, { recursive: true, force: true });
-  fs40.symlinkSync(path52.join(NVM_HOME, "v" + version2), NVM_SYMLINK, "junction");
+  if (exists(path55.join(NVM_SYMLINK, "node.exe"))) return;
+  fs42.rmSync(NVM_SYMLINK, { recursive: true, force: true });
+  fs42.symlinkSync(path55.join(NVM_HOME, "v" + version2), NVM_SYMLINK, "junction");
 };
 async function setupNode(env, versions, config2) {
   if (dryRun) {
@@ -30236,8 +30632,8 @@ async function setupNode(env, versions, config2) {
     return;
   }
   await ensureNvm();
-  fs40.writeFileSync(
-    path52.join(NVM_HOME, "settings.txt"),
+  fs42.writeFileSync(
+    path55.join(NVM_HOME, "settings.txt"),
     [
       "root: " + NVM_HOME,
       "path: " + NVM_SYMLINK,
@@ -30264,7 +30660,7 @@ async function setupNode(env, versions, config2) {
     }
   }
   Object.assign(env.vars, { NVM_HOME, NVM_SYMLINK });
-  if (duringSession()) env.prepend.push(path52.join(NVM_HOME, "v" + main), NVM_HOME, NVM_SYMLINK);
+  if (duringSession()) env.prepend.push(path55.join(NVM_HOME, "v" + main), NVM_HOME, NVM_SYMLINK);
   else {
     await activate(main);
     env.prepend.push(NVM_HOME, NVM_SYMLINK);
@@ -30273,13 +30669,13 @@ async function setupNode(env, versions, config2) {
   await packageManagers(env, config2, main);
 }
 var packageManagers = async (env, config2, version2) => {
-  const dir = path52.join(NVM_HOME, "v" + version2);
-  const nodeEnv = { ...process.env, PATH: dir + path52.delimiter + (process.env.PATH ?? "") };
-  const npm = (args) => execAsync(path52.join(dir, "node.exe"), [path52.join(dir, "node_modules", "npm", "bin", "npm-cli.js"), ...args], {
+  const dir = path55.join(NVM_HOME, "v" + version2);
+  const nodeEnv = { ...process.env, PATH: dir + path55.delimiter + (process.env.PATH ?? "") };
+  const npm = (args) => execAsync(path55.join(dir, "node.exe"), [path55.join(dir, "node_modules", "npm", "bin", "npm-cli.js"), ...args], {
     env: nodeEnv,
     stdio: "ignore"
   });
-  const corepackJs = path52.join(dir, "node_modules", "corepack", "dist", "corepack.js");
+  const corepackJs = path55.join(dir, "node_modules", "corepack", "dist", "corepack.js");
   const extra = config2.corepack && !exists(corepackJs) ? ["corepack"] : [];
   await installOnce(
     env,
@@ -30300,7 +30696,7 @@ var packageManagers = async (env, config2, version2) => {
   }
   try {
     await execAsync(
-      path52.join(dir, "node.exe"),
+      path55.join(dir, "node.exe"),
       [corepackJs, "enable", "--install-directory", mkdirp(tool("bin")), "pnpm", "yarn"],
       { env: nodeEnv, stdio: "ignore" }
     );
@@ -30325,8 +30721,8 @@ async function setupPwsh(env, refresh = false) {
 }
 
 // src/guest/toolchains/languages/python.ts
-import fs41 from "node:fs";
-import path53 from "node:path";
+import fs43 from "node:fs";
+import path56 from "node:path";
 var installPython = async (pkg, spec) => {
   const version2 = await resolveCached(pkg + ":" + spec, async () => {
     const { versions } = await fetchJson(
@@ -30335,7 +30731,7 @@ var installPython = async (pkg, spec) => {
     return pickPackageVersion(versions, spec) ?? Promise.reject(new Error("No " + pkg + ' release matches "' + spec + '"'));
   });
   const dir = tool("python", pkg + "-" + version2);
-  const exe = path53.join(dir, "python.exe");
+  const exe = path56.join(dir, "python.exe");
   if (!exists(exe)) {
     log("Downloading Python " + version2 + (pkg === "python2" ? " (Python 2, " : " (") + "~30 MB once) ...");
     await downloader.archive(
@@ -30344,32 +30740,32 @@ var installPython = async (pkg, spec) => {
       { locate: "python.exe", fileName: pkg + "." + version2 + ".zip" }
     );
   }
-  if (!exists(path53.join(dir, "Scripts", "pip.exe")) && !exists(path53.join(dir, "Scripts", "pip2.exe")))
+  if (!exists(path56.join(dir, "Scripts", "pip.exe")) && !exists(path56.join(dir, "Scripts", "pip2.exe")))
     await execAsync(exe, ["-m", "ensurepip", "--default-pip"], { stdio: "ignore" });
   return dir;
 };
-var shimDir = (dir) => duringSession() ? tool("shims", path53.basename(dir)) : tool("shims");
+var shimDir = (dir) => duringSession() ? tool("shims", path56.basename(dir)) : tool("shims");
 var shim = (folder, name, program, args = []) => {
   const fixed = [program, ...args];
-  fs41.writeFileSync(
-    path53.join(mkdirp(folder), name + ".cmd"),
+  fs43.writeFileSync(
+    path56.join(mkdirp(folder), name + ".cmd"),
     "@echo off\r\n" + fixed.map((a) => '"' + a + '"').join(" ") + " %*\r\n"
   );
   const sh = fixed.map((a) => "'" + a.replace(/\\/g, "/").replace(/'/g, "'\\''") + "'").join(" ");
-  fs41.writeFileSync(path53.join(folder, name), "#!/bin/sh\nexec " + sh + ' "$@"\n');
+  fs43.writeFileSync(path56.join(folder, name), "#!/bin/sh\nexec " + sh + ' "$@"\n');
 };
 var shimPair = (folder, version2, dir) => {
-  const python = path53.join(dir, "python.exe");
+  const python = path56.join(dir, "python.exe");
   shim(folder, "python" + version2, python);
   shim(folder, "pip" + version2, python, ["-m", "pip"]);
 };
 var pyLauncher = (folder, py3, py2) => {
-  const script = path53.join(mkdirp(folder), "py-launcher.py");
-  fs41.writeFileSync(
+  const script = path56.join(mkdirp(folder), "py-launcher.py");
+  fs43.writeFileSync(
     script,
     [
       "import subprocess, sys",
-      "PY3, PY2 = " + JSON.stringify(path53.join(py3, "python.exe")) + ", " + JSON.stringify(py2 ? path53.join(py2, "python.exe") : null),
+      "PY3, PY2 = " + JSON.stringify(path56.join(py3, "python.exe")) + ", " + JSON.stringify(py2 ? path56.join(py2, "python.exe") : null),
       "args = sys.argv[1:]",
       "exe = PY3",
       "if args and args[0].startswith('-2'):",
@@ -30381,7 +30777,7 @@ var pyLauncher = (folder, py3, py2) => {
       ""
     ].join("\n")
   );
-  shim(folder, "py", path53.join(py3, "python.exe"), [script]);
+  shim(folder, "py", path56.join(py3, "python.exe"), [script]);
 };
 async function setupPython(env, config2, versions) {
   if (dryRun) {
@@ -30391,10 +30787,10 @@ async function setupPython(env, config2, versions) {
   const py3 = await installPython("python", versions.python.spec);
   const shims = shimDir(py3);
   shimPair(shims, "3", py3);
-  env.prepend.push(py3, path53.join(py3, "Scripts"), shims);
+  env.prepend.push(py3, mkdirp(path56.join(py3, "Scripts")), shims);
   env.vars.PYTHONIOENCODING = "utf-8";
   env.summary.push(
-    "python: " + path53.basename(py3).replace("python-", "") + " (from " + versions.python.source + "; py works too)"
+    "python: " + path56.basename(py3).replace("python-", "") + " (from " + versions.python.source + "; py works too)"
   );
   if (!config2.python2) {
     pyLauncher(shims, py3, null);
@@ -30403,16 +30799,16 @@ async function setupPython(env, config2, versions) {
   const py2 = await installPython("python2", "2.7");
   shimPair(shims, "2", py2);
   pyLauncher(shims, py3, py2);
-  env.summary.push("python2: " + path53.basename(py2).replace("python2-", ""));
+  env.summary.push("python2: " + path56.basename(py2).replace("python2-", ""));
 }
 
 // src/guest/toolchains/languages/php.ts
-import fs43 from "node:fs";
-import path55 from "node:path";
+import fs45 from "node:fs";
+import path58 from "node:path";
 
 // src/guest/toolchains/native/vcruntime.ts
-import fs42 from "node:fs";
-import path54 from "node:path";
+import fs44 from "node:fs";
+import path57 from "node:path";
 var VC_REDIST = "https://aka.ms/vs/17/release/vc_redist.x64.exe";
 var MICROSOFT_SIGNER = "CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US";
 var OK_EXIT_CODES = [0, 1638, 3010];
@@ -30422,8 +30818,8 @@ async function setupVcRuntime(env, summary = true) {
     log("(dry run) would install the Visual C++ runtime");
     return false;
   }
-  const system322 = path54.join(process.env.WINDIR ?? "C:\\Windows", "System32");
-  const missing = !exists(path54.join(system322, "vcruntime140.dll")) || !exists(path54.join(system322, "msvcp140.dll"));
+  const system322 = path57.join(process.env.WINDIR ?? "C:\\Windows", "System32");
+  const missing = !exists(path57.join(system322, "vcruntime140.dll")) || !exists(path57.join(system322, "msvcp140.dll"));
   if (missing) {
     const installer = tool("vcredist", "vc_redist.x64.exe");
     if (!exists(installer)) {
@@ -30431,12 +30827,12 @@ async function setupVcRuntime(env, summary = true) {
       await downloadFile(VC_REDIST, installer);
     }
     if (signerOf(installer) !== MICROSOFT_SIGNER) {
-      fs42.rmSync(installer, { force: true });
+      fs44.rmSync(installer, { force: true });
       throw new Error("vc_redist.x64.exe is not signed by Microsoft; deleted it (it is downloaded again next boot)");
     }
     log("Installing the Visual C++ runtime ...");
     const code = await spawnAsync(installer, ["/install", "/quiet", "/norestart"]);
-    if (!OK_EXIT_CODES.includes(code ?? -1) || !exists(path54.join(system322, "vcruntime140.dll")))
+    if (!OK_EXIT_CODES.includes(code ?? -1) || !exists(path57.join(system322, "vcruntime140.dll")))
       throw new Error("the Visual C++ runtime installer failed (exit " + code + ")");
   }
   if (summary) env.summary.push("vc++ runtime: installed");
@@ -30474,16 +30870,16 @@ var phpBuild = async (spec) => {
   return { version: release.version, ...build.zip };
 };
 var writePhpIni = (home) => {
-  const ini = path55.join(home, "php.ini");
-  if (exists(ini) || !exists(path55.join(home, "php.ini-development"))) return;
-  let text = fs43.readFileSync(path55.join(home, "php.ini-development"), "utf8").replace(/^;\s*extension_dir\s*=\s*"ext"/m, 'extension_dir = "' + path55.join(home, "ext") + '"');
-  for (const ext of PHP_EXTENSIONS.filter((e) => exists(path55.join(home, "ext", "php_" + e + ".dll"))))
+  const ini = path58.join(home, "php.ini");
+  if (exists(ini) || !exists(path58.join(home, "php.ini-development"))) return;
+  let text = fs45.readFileSync(path58.join(home, "php.ini-development"), "utf8").replace(/^;\s*extension_dir\s*=\s*"ext"/m, 'extension_dir = "' + path58.join(home, "ext") + '"');
+  for (const ext of PHP_EXTENSIONS.filter((e) => exists(path58.join(home, "ext", "php_" + e + ".dll"))))
     text = text.replace(new RegExp("^;(extension=" + ext + ")\\s*$", "m"), "$1");
-  fs43.writeFileSync(ini + ".tmp", text);
-  fs43.renameSync(ini + ".tmp", ini);
+  fs45.writeFileSync(ini + ".tmp", text);
+  fs45.renameSync(ini + ".tmp", ini);
 };
 var shim2 = (env, name, command) => {
-  fs43.writeFileSync(path55.join(mkdirp(tool("shims")), name + ".cmd"), "@echo off\r\n" + command + " %*\r\n");
+  fs45.writeFileSync(path58.join(mkdirp(tool("shims")), name + ".cmd"), "@echo off\r\n" + command + " %*\r\n");
   env.prepend.push(tool("shims"));
 };
 var setupComposer = async (env, php) => {
@@ -30495,7 +30891,7 @@ var setupComposer = async (env, php) => {
   }
   const composerHome = tool("composer-home");
   env.vars.COMPOSER_HOME = composerHome;
-  env.prepend.push(path55.join(composerHome, "vendor", "bin"));
+  env.prepend.push(path58.join(composerHome, "vendor", "bin"));
   shim2(env, "composer", '"' + php + '" "' + phar + '"');
   env.summary.push(
     "composer: " + (/\d+\.\d+\.\d+/.exec(execOutput(php, [phar, "--version", "--no-ansi"]))?.[0] ?? "installed")
@@ -30510,7 +30906,7 @@ async function setupPhp(env, config2) {
   await setupVcRuntime(env, false);
   const version2 = await resolveCached("php:" + wantedSpec.spec, async () => (await phpBuild(wantedSpec.spec)).version);
   const home = tool("php", version2);
-  if (!exists(path55.join(home, "php.exe"))) {
+  if (!exists(path58.join(home, "php.exe"))) {
     const build = await phpBuild(version2);
     log("Downloading PHP " + version2 + " (~30 MB once) ...");
     await downloader.archive("https://windows.php.net/downloads/releases/" + build.path, home, {
@@ -30522,11 +30918,11 @@ async function setupPhp(env, config2) {
   writePhpIni(home);
   env.prepend.push(home);
   env.summary.push("php: " + version2 + " (from " + wantedSpec.source + ")");
-  if (config2.composer) await setupComposer(env, path55.join(home, "php.exe"));
+  if (config2.composer) await setupComposer(env, path58.join(home, "php.exe"));
 }
 
 // src/guest/toolchains/languages/ruby.ts
-import path56 from "node:path";
+import path59 from "node:path";
 var RUBY_ASSET = /^rubyinstaller-(\d+\.\d+\.\d+)-(\d+)-x64\.7z$/;
 var buildNumber = (asset) => Number(RUBY_ASSET.exec(asset.name)?.[2] ?? 0);
 var rubyBuilds = async () => {
@@ -30554,7 +30950,7 @@ async function setupRuby(env, config2) {
     async () => pickPackageVersion([...(await rubyBuilds()).keys()], wantedSpec.spec) ?? Promise.reject(new Error('No RubyInstaller build matches "' + wantedSpec.spec + '"'))
   );
   const home = tool("ruby", version2);
-  if (!exists(path56.join(home, "bin", "ruby.exe"))) {
+  if (!exists(path59.join(home, "bin", "ruby.exe"))) {
     const asset = (await rubyBuilds()).get(version2);
     if (!asset) throw new Error("RubyInstaller " + version2 + " is no longer published");
     log("Downloading Ruby " + version2 + " (~100 MB once) ...");
@@ -30567,11 +30963,11 @@ async function setupRuby(env, config2) {
   }
   const gems = tool("ruby-gems", version2.split(".").slice(0, 2).join("."));
   Object.assign(env.vars, { GEM_HOME: gems, BUNDLE_USER_HOME: tool("bundle-home") });
-  env.prepend.push(path56.join(home, "bin"), path56.join(gems, "bin"));
+  env.prepend.push(path59.join(home, "bin"), path59.join(gems, "bin"));
   env.summary.push(
-    "ruby: " + versionOf(path56.join(home, "bin", "ruby.exe")) + " (from " + wantedSpec.source + "; gems with C extensions need MSYS2, not included)"
+    "ruby: " + versionOf(path59.join(home, "bin", "ruby.exe")) + " (from " + wantedSpec.source + "; gems with C extensions need MSYS2, not included)"
   );
-  const gem = path56.join(home, "bin", "gem.cmd");
+  const gem = path59.join(home, "bin", "gem.cmd");
   await installOnce(
     env,
     "gem@" + version2,
@@ -30583,9 +30979,9 @@ async function setupRuby(env, config2) {
 }
 
 // src/guest/toolchains/tools/vscode.ts
-import fs44 from "node:fs";
+import fs46 from "node:fs";
 import os7 from "node:os";
-import path57 from "node:path";
+import path60 from "node:path";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 var CharacterCodes;
@@ -30765,14 +31161,14 @@ var ParseErrorCode;
 var VERSION_MARKER = ".agent-sandbox-version";
 var desktopShortcut = (exe) => {
   if (!isWin) return;
-  const link = path57.join(os7.homedir(), "Desktop", "Visual Studio Code.lnk");
+  const link = path60.join(os7.homedir(), "Desktop", "Visual Studio Code.lnk");
   runScriptWithJson("new-shortcuts.ps1", "ListFile", [
     { link, target: exe, arguments: '"' + (process.env.AGENT_WORKSPACE ?? "") + '"' }
   ]);
 };
 async function setupVscode(env, refresh) {
   const root = tool("vscode");
-  const exe = path57.join(root, "Code.exe");
+  const exe = path60.join(root, "Code.exe");
   if (dryRun) {
     log("(dry run) would provision VS Code");
     return;
@@ -30782,11 +31178,11 @@ async function setupVscode(env, refresh) {
       "https://update.code.visualstudio.com/api/update/win32-" + (arch === "arm64" ? "arm64" : "x64") + "-archive/stable/latest"
     );
     log("Downloading VS Code " + release.productVersion + " (~150 MB once) ...");
-    const keep = path57.join(root, "data");
+    const keep = path60.join(root, "data");
     const parked = root + "-data";
     if (exists(keep)) {
-      fs44.rmSync(parked, { recursive: true, force: true });
-      fs44.renameSync(keep, parked);
+      fs46.rmSync(parked, { recursive: true, force: true });
+      fs46.renameSync(keep, parked);
     }
     try {
       await downloader.archive(release.url, root, {
@@ -30794,44 +31190,44 @@ async function setupVscode(env, refresh) {
         locate: "Code.exe",
         fileName: "vscode.zip"
       });
-      fs44.writeFileSync(path57.join(root, VERSION_MARKER), release.productVersion);
+      fs46.writeFileSync(path60.join(root, VERSION_MARKER), release.productVersion);
     } finally {
       if (exists(parked)) {
         mkdirp(root);
-        fs44.rmSync(keep, { recursive: true, force: true });
-        fs44.renameSync(parked, keep);
+        fs46.rmSync(keep, { recursive: true, force: true });
+        fs46.renameSync(parked, keep);
       }
     }
   }
-  mkdirp(path57.join(root, "data"));
-  env.prepend.push(path57.join(root, "bin"));
+  mkdirp(path60.join(root, "data"));
+  env.prepend.push(path60.join(root, "bin"));
   desktopShortcut(exe);
-  const version2 = exists(path57.join(root, VERSION_MARKER)) ? fs44.readFileSync(path57.join(root, VERSION_MARKER), "utf8").trim() : "installed";
+  const version2 = exists(path60.join(root, VERSION_MARKER)) ? fs46.readFileSync(path60.join(root, VERSION_MARKER), "utf8").trim() : "installed";
   env.summary.push("vscode: " + version2 + " (portable; run code . or use the desktop shortcut)");
 }
 
 // src/guest/toolchains/native/rust-extras.ts
-import fs45 from "node:fs";
+import fs47 from "node:fs";
 import os8 from "node:os";
-import path58 from "node:path";
+import path61 from "node:path";
 var cargoTarget = (targetDir) => {
   if (targetDir === "shared" || targetDir === "separate") return null;
-  if (targetDir === "local") return path58.join(localDir, "cargo-target");
+  if (targetDir === "local") return path61.join(localDir, "cargo-target");
   return targetDir;
 };
 function cargoShim(env, rust) {
-  const real = path58.join(tool("rust", "cargo", "bin"), "cargo.exe");
+  const real = path61.join(tool("rust", "cargo", "bin"), "cargo.exe");
   if (rust.targetDir !== "separate" || !exists(real)) return;
   const dir = mkdirp(tool("shims", "cargo"));
-  fs45.copyFileSync(ensureCompiled("cargoshim"), path58.join(dir, "cargo.exe"));
+  fs47.copyFileSync(ensureCompiled("cargoshim"), path61.join(dir, "cargo.exe"));
   env.prepend.unshift(dir);
   env.vars.AGENT_REAL_CARGO = real;
 }
 function linkGate(env, rust, host) {
   const gcc = tool("mingw", "mingw64", "bin", "gcc.exe");
   if (!host.endsWith("-pc-windows-gnu") || !exists(gcc)) return;
-  const gate = path58.join(mkdirp(tool("shims")), "linkgate.exe");
-  fs45.copyFileSync(ensureCompiled("linkgate"), gate);
+  const gate = path61.join(mkdirp(tool("shims")), "linkgate.exe");
+  fs47.copyFileSync(ensureCompiled("linkgate"), gate);
   const memoryGb = os8.totalmem() / 1024 ** 3;
   const slots = rust.linkSlots === "auto" ? Math.max(2, Math.min(4, Math.floor(memoryGb / 8))) : rust.linkSlots;
   env.vars.AGENT_LINK_SLOTS = String(slots);
@@ -30839,18 +31235,18 @@ function linkGate(env, rust, host) {
   env.vars.CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER = gate;
   const rustEnv = { ...process.env, RUSTUP_HOME: tool("rust", "rustup"), CARGO_HOME: tool("rust", "cargo") };
   const sysroot = rust.linker === "lld" ? execOutput(tool("rust", "cargo", "bin", "rustc.exe"), ["--print", "sysroot"], { env: rustEnv }) : "";
-  const lld = sysroot ? path58.join(sysroot, "lib", "rustlib", host, "bin", "gcc-ld") : "";
-  if (lld && exists(path58.join(lld, "ld.lld.exe"))) env.vars.AGENT_LLD_DIR = lld;
+  const lld = sysroot ? path61.join(sysroot, "lib", "rustlib", host, "bin", "gcc-ld") : "";
+  if (lld && exists(path61.join(lld, "ld.lld.exe"))) env.vars.AGENT_LLD_DIR = lld;
   env.summary.push(
     "rust linking: " + (env.vars.AGENT_LLD_DIR ? "lld" : "GNU ld") + ", at most " + env.vars.AGENT_LINK_SLOTS + " at once"
   );
 }
 function cargoDefaults(host) {
   const file3 = tool("rust", "cargo", "config.toml");
-  if (exists(file3) || !exists(path58.dirname(file3))) return;
+  if (exists(file3) || !exists(path61.dirname(file3))) return;
   const jobs = Math.max(2, Math.min(4, Math.floor(os8.cpus().length / 4)));
   const gnu = host.endsWith("-gnu");
-  fs45.writeFileSync(
+  fs47.writeFileSync(
     file3,
     [
       "# Written by windows-development-sandbox once; edit freely, it is never overwritten.",
@@ -30865,7 +31261,7 @@ function rustCaches(rust) {
   const target = cargoTarget(rust.targetDir);
   return {
     ...target ? { CARGO_TARGET_DIR: target } : {},
-    ...process.env.SCCACHE_DIR ? {} : { SCCACHE_DIR: path58.join(dataDir, "cache", "sccache") }
+    ...process.env.SCCACHE_DIR ? {} : { SCCACHE_DIR: path61.join(dataDir, "cache", "sccache") }
   };
 }
 function rustHost(config2) {
@@ -31169,21 +31565,21 @@ function cmdSet(env, names) {
   return names.filter((n) => env[n] !== void 0 && !/[\r\n]/.test(String(env[n]))).map((n) => '@set "' + n + "=" + String(env[n]).replace(/%/g, "%%") + '"');
 }
 function writeShell(spec, env, names) {
-  const dir = mkdirp(path59.join(localDir, "projects", spec.name));
-  fs46.writeFileSync(path59.join(dir, "env.cmd"), [...cmdSet(env, [...names, "PATH"]), ""].join("\r\n"));
-  fs46.writeFileSync(
-    path59.join(dir, "shell.cmd"),
-    ['@call "' + path59.join(dir, "env.cmd") + '"', '@cd /d "' + spec.workspace + '"', "@title " + spec.name, ""].join(
+  const dir = mkdirp(path62.join(localDir, "projects", spec.name));
+  fs48.writeFileSync(path62.join(dir, "env.cmd"), [...cmdSet(env, [...names, "PATH"]), ""].join("\r\n"));
+  fs48.writeFileSync(
+    path62.join(dir, "shell.cmd"),
+    ['@call "' + path62.join(dir, "env.cmd") + '"', '@cd /d "' + spec.workspace + '"', "@title " + spec.name, ""].join(
       "\r\n"
     )
   );
-  const bin = mkdirp(path59.join(localDir, "bin"));
-  fs46.writeFileSync(
-    path59.join(bin, "sbx-shell.cmd"),
+  const bin = mkdirp(path62.join(localDir, "bin"));
+  fs48.writeFileSync(
+    path62.join(bin, "sbx-shell.cmd"),
     [
-      '@if "%~1"=="" (echo Usage: sbx-shell ^<project^>   ^(a terminal in that project with its tools^) & dir /b "' + path59.join(localDir, "projects") + '" & exit /b 2)',
-      '@if not exist "' + path59.join(localDir, "projects") + '\\%~1\\shell.cmd" (echo No project %~1 in this sandbox. & exit /b 2)',
-      '@cmd /k ""' + path59.join(localDir, "projects") + '\\%~1\\shell.cmd""',
+      '@if "%~1"=="" (echo Usage: sbx-shell ^<project^>   ^(a terminal in that project with its tools^) & dir /b "' + path62.join(localDir, "projects") + '" & exit /b 2)',
+      '@if not exist "' + path62.join(localDir, "projects") + '\\%~1\\shell.cmd" (echo No project %~1 in this sandbox. & exit /b 2)',
+      '@cmd /k ""' + path62.join(localDir, "projects") + '\\%~1\\shell.cmd""',
       ""
     ].join("\r\n")
   );
@@ -31236,10 +31632,10 @@ async function setUp(spec, say) {
       }
     )
   );
-  tools.prepend.push(path59.join(localDir, "bin"));
+  tools.prepend.push(path62.join(localDir, "bin"));
   const env = agentEnv(tools, { workspace: spec.workspace, project: spec.name, base });
-  const specFile = path59.join(mkdirp(path59.join(localDir, "projects", spec.name)), "project.json");
-  fs46.writeFileSync(specFile, JSON.stringify(spec));
+  const specFile = path62.join(mkdirp(path62.join(localDir, "projects", spec.name)), "project.json");
+  fs48.writeFileSync(specFile, JSON.stringify(spec));
   env.AGENT_PROJECT_FILE = specFile;
   addMachineEnvironment(tools.vars, [...tools.prepend, ...tools.append], true);
   try {
@@ -31326,7 +31722,7 @@ function execCommand(req) {
     respond(req.id, { ok: false, message: "Folder is not inside the sandbox workspace: " + req.cwd });
     return;
   }
-  const env = provisioner.provisionedFor(req.cwd)?.env ?? process.env;
+  const env = withRegistryPath(provisioner.provisionedFor(req.cwd)?.env ?? process.env);
   const child = spawn5(
     SYSTEM.cmd(),
     ["/d", "/s", "/c", '"chcp 65001>nul & ' + req.command.map(quoteForCmd).join(" ") + '"'],
@@ -31356,7 +31752,7 @@ function execCommand(req) {
 }
 
 // src/guest/daemon/sessions.ts
-import path64 from "node:path";
+import path67 from "node:path";
 import crypto4 from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
 
@@ -31429,7 +31825,7 @@ async function sendControl(endpoint, type) {
 }
 
 // src/guest/sessions/cmdline.ts
-import path60 from "node:path";
+import path63 from "node:path";
 var quoted = (arg) => '"' + arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1") + '"';
 function quoteArg(arg) {
   return arg !== "" && !/[\s"]/.test(arg) ? arg : quoted(arg);
@@ -31443,12 +31839,12 @@ function cmdArgs(args) {
   }).join("");
 }
 function commandLine(file3, args) {
-  return path60.win32.basename(file3).toLowerCase() === "cmd.exe" ? [quoteArg(file3), cmdArgs(args)].filter(Boolean).join(" ") : [file3, ...args].map(quoteArg).join(" ");
+  return path63.win32.basename(file3).toLowerCase() === "cmd.exe" ? [quoteArg(file3), cmdArgs(args)].filter(Boolean).join(" ") : [file3, ...args].map(quoteArg).join(" ");
 }
 
 // src/guest/sessions/pty-host.ts
-import fs47 from "node:fs";
-import path61 from "node:path";
+import fs49 from "node:fs";
+import path64 from "node:path";
 import { spawn as spawn6 } from "node:child_process";
 function ensurePtyHost() {
   return ensureCompiled("ptyhost");
@@ -31467,18 +31863,18 @@ async function waitForPtyHost(child, port, timeoutMs) {
   throw new Error("the session host did not start listening on port " + port);
 }
 function ptyHostLog(id) {
-  return path61.join(logsDir, "ptyhost-" + id + ".log");
+  return path64.join(logsDir, "ptyhost-" + id + ".log");
 }
 function ptyHostLogTail(id, lines = 12) {
   try {
-    return fs47.readFileSync(ptyHostLog(id), "utf8").trim().split(/\r?\n/).slice(-lines).join("\n");
+    return fs49.readFileSync(ptyHostLog(id), "utf8").trim().split(/\r?\n/).slice(-lines).join("\n");
   } catch {
     return "";
   }
 }
 var conptyDll = () => {
-  const dll = path61.join(toolsDir, "conpty", "conpty.dll");
-  return session.provisioning.conpty?.enabled !== false && fs47.existsSync(dll) && fs47.existsSync(path61.join(toolsDir, "conpty", "OpenConsole.exe")) ? dll : null;
+  const dll = path64.join(toolsDir, "conpty", "conpty.dll");
+  return session.provisioning.conpty?.enabled !== false && fs49.existsSync(dll) && fs49.existsSync(path64.join(toolsDir, "conpty", "OpenConsole.exe")) ? dll : null;
 };
 function startPtyHost(o) {
   const env = { ...o.env, PTYHOST_BIND: o.remote ? "any" : "loopback" };
@@ -31493,8 +31889,8 @@ function startPtyHost(o) {
 }
 
 // src/guest/agents/agent-installer.ts
-import fs48 from "node:fs";
-import path62 from "node:path";
+import fs50 from "node:fs";
+import path65 from "node:path";
 
 // src/guest/agents/profile-links.ts
 var profileRoot = () => process.env.USERPROFILE ?? "";
@@ -31516,19 +31912,11 @@ function linkHarnessProfile(name, harness) {
 }
 
 // src/guest/agents/agent-installer.ts
-function agentPaths(name, harness) {
-  const dir = path62.join(toolsDir, "agents", name);
-  const exe = harness.hostExecutable ?? (harness.uvBin ? harness.uvBin + ".exe" : null);
-  return {
-    dir,
-    exe: exe ? path62.join(dir, exe) : null,
-    cmd: harness.npmBin ? path62.join(dir, harness.npmBin + ".cmd") : null
-  };
-}
+var agentPaths2 = (name, harness) => agentPaths(toolsDir, name, harness);
 async function installViaNpm(name, harness, dir, env) {
   if (!harness.npmPackage)
     throw new Error("No npmPackage configured for " + name + " and no host executable was available.");
-  const npmCli = path62.join(path62.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+  const npmCli = path65.join(path65.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
   const args = [npmCli, "install", "--global", "--prefix", dir, harness.npmPackage, "--no-fund", "--no-audit"];
   log("Installing " + harness.npmPackage + " (this can take a minute)...");
   if (dryRun) {
@@ -31539,7 +31927,7 @@ async function installViaNpm(name, harness, dir, env) {
   await execAsync(process.execPath, args, { env });
 }
 async function installViaUv(name, harness, dir, env) {
-  const uv = path62.join(toolsDir, "uv", "uv.exe");
+  const uv = path65.join(toolsDir, "uv", "uv.exe");
   log("Installing " + harness.uvPackage + " with uv (this can take a minute)...");
   if (dryRun) {
     log("(dry run) uv tool install " + harness.uvPackage);
@@ -31554,8 +31942,8 @@ async function installViaUv(name, harness, dir, env) {
   });
 }
 function putOnPath(dir, env) {
-  const parts2 = (env.PATH ?? "").split(path62.delimiter);
-  if (!parts2.some((p) => p.toLowerCase() === dir.toLowerCase())) env.PATH = [...parts2, dir].join(path62.delimiter);
+  const parts2 = (env.PATH ?? "").split(path65.delimiter);
+  if (!parts2.some((p) => p.toLowerCase() === dir.toLowerCase())) env.PATH = [...parts2, dir].join(path65.delimiter);
   addMachineEnvironment({}, [dir], true);
 }
 var AgentInstaller = class {
@@ -31569,13 +31957,13 @@ var AgentInstaller = class {
     const current = this.installing.get(name);
     if (current) return current;
     linkHarnessProfile(name, harness);
-    const work = this.install(name, harness, env, refresh).then(() => putOnPath(agentPaths(name, harness).dir, env)).finally(() => this.installing.delete(name));
+    const work = this.install(name, harness, env, refresh).then(() => putOnPath(agentPaths2(name, harness).dir, env)).finally(() => this.installing.delete(name));
     this.installing.set(name, work);
     return work;
   }
   /** Program + arguments that start the agent (an npm .cmd shim has to go through cmd.exe). */
   resolveLaunch(name, harness) {
-    const p = agentPaths(name, harness);
+    const p = agentPaths2(name, harness);
     if (p.exe && exists(p.exe)) return { file: p.exe, args: [] };
     if (p.cmd && exists(p.cmd))
       return isWin ? { file: SYSTEM.cmd(), args: ["/d", "/c", p.cmd] } : { file: p.cmd, args: [] };
@@ -31588,7 +31976,7 @@ var AgentInstaller = class {
     return harness.uvPackage && !harness.npmPackage ? "uv" : "npm";
   }
   async install(name, harness, env, refresh) {
-    const p = agentPaths(name, harness);
+    const p = agentPaths2(name, harness);
     const cached2 = p.exe !== null && exists(p.exe) || p.cmd !== null && exists(p.cmd);
     if (cached2 && !refresh) {
       log(name + " already cached in persistent storage.");
@@ -31596,9 +31984,9 @@ var AgentInstaller = class {
     }
     mkdirp(p.dir);
     if (this.sourceOf(name, harness) === "host") {
-      const source = path62.join(hostToolsDir, "agents", name, harness.hostExecutable);
+      const source = path65.join(hostToolsDir, "agents", name, harness.hostExecutable);
       if (exists(source) && p.exe) {
-        fs48.copyFileSync(source, p.exe);
+        fs50.copyFileSync(source, p.exe);
         log("Copied " + name + " from this PC: " + source);
         return;
       }
@@ -31619,22 +32007,22 @@ function guestAddresses() {
 }
 
 // src/guest/sessions/conversation.ts
-import fs49 from "node:fs";
-import path63 from "node:path";
+import fs51 from "node:fs";
+import path66 from "node:path";
 var MAX_FILES = 2e3;
 function conversationFiles(claudeDir2, cwd) {
   const names = /* @__PURE__ */ new Set([projectFolderName(cwd), projectFolderName(sandboxFolder(cwd))]);
   return [...names].flatMap((name) => {
-    const dir = path63.join(claudeDir2, "projects", name);
+    const dir = path66.join(claudeDir2, "projects", name);
     let entries2;
     try {
-      entries2 = fs49.readdirSync(dir);
+      entries2 = fs51.readdirSync(dir);
     } catch {
       return [];
     }
     return entries2.filter((e) => e.endsWith(".jsonl") && isConversationId(e.slice(0, -".jsonl".length))).slice(0, MAX_FILES).flatMap((e) => {
       try {
-        return [{ id: e.slice(0, -".jsonl".length), createdMs: fs49.statSync(path63.join(dir, e)).birthtimeMs }];
+        return [{ id: e.slice(0, -".jsonl".length), createdMs: fs51.statSync(path66.join(dir, e)).birthtimeMs }];
       } catch {
         return [];
       }
@@ -31662,6 +32050,7 @@ var IdleShutdown = class {
       if (!this.idle()) return;
       log("Headless sandbox has no sessions left; shutting down.");
       safely("claude-mem save", saveClaudeMem);
+      safely("agent databases save", saveLocalState);
       spawnSync6(SYSTEM.shutdown(), ["/s", "/t", "5"], { windowsHide: true });
     }, GRACE_MS);
   }
@@ -31672,8 +32061,8 @@ var IdleShutdown = class {
 
 // src/guest/daemon/sessions.ts
 function terminalTab(id, title, cwd) {
-  const view = [process.execPath, path64.join(path64.dirname(process.argv[1]), "view.js"), id];
-  const wt = path64.join(toolsDir, "terminal", "wt.exe");
+  const view = [process.execPath, path67.join(path67.dirname(process.argv[1]), "view.js"), id];
+  const wt = path67.join(toolsDir, "terminal", "wt.exe");
   if (exists(wt))
     spawn7(wt, ["-w", "0", "nt", "--title", title, "-d", cwd, ...view], { detached: true, stdio: "ignore" }).unref();
   else spawn7(SYSTEM.cmd(), ["/d", "/c", "start", title, ...view], { detached: true, stdio: "ignore", cwd }).unref();
@@ -31702,7 +32091,7 @@ var launchPtyHost = async (req, remote, env, say) => {
     rows: 32,
     id: req.id,
     cwd: req.cwd,
-    env: { ...env, ...harness.environment },
+    env: { ...withRegistryPath(env), ...harness.environment },
     remote,
     command: commandLine(launch.file, [...base, ...req.args]),
     restartCommand: commandLine(launch.file, [...base, ...harness.resumeArguments ?? []])
@@ -31712,7 +32101,7 @@ var launchPtyHost = async (req, remote, env, say) => {
   } catch (e) {
     const tail = ptyHostLogTail(req.id);
     throw new Error(
-      errMsg(e) + (tail ? ". From its log:\n" + tail : "") + "\nLog: " + path64.join(dataDir, "logs", "ptyhost-" + req.id + ".log")
+      errMsg(e) + (tail ? ". From its log:\n" + tail : "") + "\nLog: " + path67.join(dataDir, "logs", "ptyhost-" + req.id + ".log")
     );
   }
   return { child, port, token };
@@ -31770,7 +32159,7 @@ var SessionManager = class {
     };
     this.starting++;
     if (req.id !== session.launchId && process.env.AGENT_NO_TABS !== "1")
-      safely("terminal tab", () => terminalTab(req.id, req.harness + " " + path64.basename(req.cwd), req.cwd));
+      safely("terminal tab", () => terminalTab(req.id, req.harness + " " + path67.basename(req.cwd), req.cwd));
     try {
       const place = await placeFor(req, say);
       const remote = session.networking && session.attach.enabled;
@@ -31877,6 +32266,7 @@ var SessionManager = class {
       );
     else safely("post-agent hooks", () => runHooks("post-agent", process.env));
     safely("claude-mem save", saveClaudeMem);
+    safely("agent databases save", saveLocalState);
     this.idle.check();
   }
 };
@@ -31900,15 +32290,18 @@ var Daemon = class {
   tick() {
     const { valid, invalid } = run.scanRequests();
     for (const file3 of invalid)
-      safely("removing an invalid request", () => fs50.rmSync(file3, { recursive: true, force: true }));
+      safely("removing an invalid request", () => fs52.rmSync(file3, { recursive: true, force: true }));
     for (const req of valid) {
-      safely("claiming a request", () => fs50.rmSync(run.requestFile(req.id), { force: true }));
+      safely("claiming a request", () => fs52.rmSync(run.requestFile(req.id), { force: true }));
       if (run.readSession(req.id)) continue;
-      void Promise.resolve(this.handle(req)).catch((e) => respond(req.id, { ok: false, message: errMsg(e) }));
+      void Promise.resolve(this.handle(withRequestSecrets(req))).catch(
+        (e) => respond(req.id, { ok: false, message: errMsg(e) })
+      );
     }
     if (Date.now() - this.lastMemSave > MEM_SAVE_MS) {
       this.lastMemSave = Date.now();
       safely("claude-mem save", saveClaudeMem);
+      safely("agent databases save", saveLocalState);
     }
   }
   handle(req) {
@@ -31930,6 +32323,7 @@ var Daemon = class {
 // src/guest/entries/daemon.ts
 process.on("uncaughtException", (e) => warn("daemon: unexpected error (continuing): " + (e.stack ?? errMsg(e))));
 process.on("unhandledRejection", (e) => warn("daemon: unexpected error (continuing): " + errMsg(e)));
+adoptBootSecrets();
 log("Session daemon started (pid " + process.pid + ").");
 safely("port forwards", startRelays);
 safely("audit", startProcessCollector);