pi-outpost 0.10.0 → 0.11.0

package/dist/pi-outpost.mjs

@@ -53,8 +53,8 @@ var require_windows = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/isexe/windows.js"(exports, module) {
     module.exports = isexe;
     isexe.sync = sync;
-    var fs14 = __require("fs");
-    function checkPathExt(path16, options) {
+    var fs15 = __require("fs");
+    function checkPathExt(path17, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -65,25 +65,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path16.substr(-p.length).toLowerCase() === p) {
+        if (p && path17.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path16, options) {
+    function checkStat(stat, path17, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path16, options);
+      return checkPathExt(path17, options);
     }
-    function isexe(path16, options, cb) {
-      fs14.stat(path16, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path16, options));
+    function isexe(path17, options, cb) {
+      fs15.stat(path17, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path17, options));
       });
     }
-    function sync(path16, options) {
-      return checkStat(fs14.statSync(path16), path16, options);
+    function sync(path17, options) {
+      return checkStat(fs15.statSync(path17), path17, options);
     }
   }
 });
@@ -93,14 +93,14 @@ var require_mode = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/isexe/mode.js"(exports, module) {
     module.exports = isexe;
     isexe.sync = sync;
-    var fs14 = __require("fs");
-    function isexe(path16, options, cb) {
-      fs14.stat(path16, function(er, stat) {
+    var fs15 = __require("fs");
+    function isexe(path17, options, cb) {
+      fs15.stat(path17, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path16, options) {
-      return checkStat(fs14.statSync(path16), options);
+    function sync(path17, options) {
+      return checkStat(fs15.statSync(path17), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -124,7 +124,7 @@ var require_mode = __commonJS({
 // ../node_modules/@earendil-works/pi-coding-agent/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/isexe/index.js"(exports, module) {
-    var fs14 = __require("fs");
+    var fs15 = __require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -133,7 +133,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path16, options, cb) {
+    function isexe(path17, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -143,7 +143,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve2, reject) {
-          isexe(path16, options || {}, function(er, is) {
+          isexe(path17, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -152,7 +152,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path16, options || {}, function(er, is) {
+      core(path17, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -162,9 +162,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path16, options) {
+    function sync(path17, options) {
       try {
-        return core.sync(path16, options || {});
+        return core.sync(path17, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -180,7 +180,7 @@ var require_isexe = __commonJS({
 var require_which = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/which/which.js"(exports, module) {
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path16 = __require("path");
+    var path17 = __require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -218,7 +218,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path16.join(pathPart, cmd);
+        const pCmd = path17.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve2(subStep(p, i, 0));
       });
@@ -245,7 +245,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path16.join(pathPart, cmd);
+        const pCmd = path17.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j2 = 0; j2 < pathExt.length; j2++) {
           const cur = p + pathExt[j2];
@@ -293,7 +293,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
-    var path16 = __require("path");
+    var path17 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -311,7 +311,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env2[getPathKey({ env: env2 })],
-          pathExt: withoutPathExt ? path16.delimiter : void 0
+          pathExt: withoutPathExt ? path17.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -320,7 +320,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path16.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path17.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -374,8 +374,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path16, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path16.split("/").pop();
+      const [path17, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path17.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -388,16 +388,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
     "use strict";
-    var fs14 = __require("fs");
+    var fs15 = __require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs14.openSync(command, "r");
-        fs14.readSync(fd, buffer, 0, size, 0);
-        fs14.closeSync(fd);
+        fd = fs15.openSync(command, "r");
+        fs15.readSync(fd, buffer, 0, size, 0);
+        fs15.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -410,7 +410,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "../node_modules/@earendil-works/pi-coding-agent/node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
-    var path16 = __require("path");
+    var path17 = __require("path");
     var resolveCommand = require_resolveCommand();
     var escape2 = require_escape();
     var readShebang = require_readShebang();
@@ -435,7 +435,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path16.normalize(parsed.command);
+        parsed.command = path17.normalize(parsed.command);
         parsed.command = escape2.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -525,21 +525,21 @@ var require_cross_spawn = __commonJS({
     var cp = __require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
-    function spawn3(command, args, options) {
+    function spawn4(command, args, options) {
       const parsed = parse(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
-    function spawnSync(command, args, options) {
+    function spawnSync2(command, args, options) {
       const parsed = parse(command, args, options);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module.exports = spawn3;
-    module.exports.spawn = spawn3;
-    module.exports.sync = spawnSync;
+    module.exports = spawn4;
+    module.exports.spawn = spawn4;
+    module.exports.sync = spawnSync2;
     module.exports._parse = parse;
     module.exports._enoent = enoent;
   }
@@ -36024,33 +36024,33 @@ function renderRichText({
   container.append(fragment);
 }
 function makePathFromDrawOPS(data) {
-  const path16 = new Path2D();
+  const path17 = new Path2D();
   if (!data) {
-    return path16;
+    return path17;
   }
   for (let i = 0, ii = data.length; i < ii; ) {
     switch (data[i++]) {
       case DrawOPS.moveTo:
-        path16.moveTo(data[i++], data[i++]);
+        path17.moveTo(data[i++], data[i++]);
         break;
       case DrawOPS.lineTo:
-        path16.lineTo(data[i++], data[i++]);
+        path17.lineTo(data[i++], data[i++]);
         break;
       case DrawOPS.curveTo:
-        path16.bezierCurveTo(data[i++], data[i++], data[i++], data[i++], data[i++], data[i++]);
+        path17.bezierCurveTo(data[i++], data[i++], data[i++], data[i++], data[i++], data[i++]);
         break;
       case DrawOPS.quadraticCurveTo:
-        path16.quadraticCurveTo(data[i++], data[i++], data[i++], data[i++]);
+        path17.quadraticCurveTo(data[i++], data[i++], data[i++], data[i++]);
         break;
       case DrawOPS.closePath:
-        path16.closePath();
+        path17.closePath();
         break;
       default:
         warn(`Unrecognized drawing path operator: ${data[i - 1]}`);
         break;
     }
   }
-  return path16;
+  return path17;
 }
 function bindEvents(obj, element, names3) {
   for (const name of names3) {
@@ -36158,8 +36158,8 @@ function blend(fg, bg, alpha) {
   return Math.round(alpha * fg + (1 - alpha) * bg);
 }
 async function node_utils_fetchData(url) {
-  const fs14 = process.getBuiltinModule("fs/promises");
-  const data = await fs14.readFile(url);
+  const fs15 = process.getBuiltinModule("fs/promises");
+  const data = await fs15.readFile(url);
   return new Uint8Array(data);
 }
 function convertBlackAndWhiteToRGBA({
@@ -36798,11 +36798,11 @@ function network_getArrayBuffer(val) {
   return typeof val !== "string" ? val : stringToBytes(val).buffer;
 }
 function getReadableStream(url, opts = null) {
-  const fs14 = process.getBuiltinModule("fs");
+  const fs15 = process.getBuiltinModule("fs");
   const {
     Readable
   } = process.getBuiltinModule("stream");
-  const readStream = fs14.createReadStream(url, opts);
+  const readStream = fs15.createReadStream(url, opts);
   return Readable.toWeb(readStream);
 }
 function getNetworkStream(url) {
@@ -48461,11 +48461,11 @@ var init_pdf = __esm({
         } catch (ex) {
           warn(`getPathGenerator - ignoring character: "${ex}".`);
         }
-        const path16 = makePathFromDrawOPS(cmds?.path);
+        const path17 = makePathFromDrawOPS(cmds?.path);
         if (!this.fontExtraProperties) {
           objs.delete(objId);
         }
-        return this.compiledGlyphs[character] = path16;
+        return this.compiledGlyphs[character] = path17;
       }
       get black() {
         return this.#fontData.black;
@@ -50361,7 +50361,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         Util.singularValueDecompose2dScale(this.baseTransform, scale);
         return [matrixScaleX * scale[0], matrixScaleY * scale[1]];
       }
-      drawPattern(owner, path16, useEOFill = false, [n, m2], opIdx) {
+      drawPattern(owner, path17, useEOFill = false, [n, m2], opIdx) {
         const [x0, y0, x1, y1] = this.bbox;
         const dependencyTracker = owner.dependencyTracker;
         if (dependencyTracker) {
@@ -50369,9 +50369,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         owner.save();
         if (useEOFill) {
-          owner.ctx.clip(path16, "evenodd");
+          owner.ctx.clip(path17, "evenodd");
         } else {
-          owner.ctx.clip(path16);
+          owner.ctx.clip(path17);
         }
         owner.ctx.setTransform(...this.patternBaseMatrix);
         owner.ctx.translate(n * this.xstep, m2 * this.ystep);
@@ -51462,15 +51462,15 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (hasInnerCutout && maskX0 === layerOffsetX && maskY0 === layerOffsetY && maskX1 === layerOffsetX + layerWidth && maskY1 === layerOffsetY + layerHeight) {
           return;
         }
-        const path16 = new Path2D();
-        path16.rect(layerOffsetX, layerOffsetY, layerWidth, layerHeight);
+        const path17 = new Path2D();
+        path17.rect(layerOffsetX, layerOffsetY, layerWidth, layerHeight);
         if (hasInnerCutout) {
-          path16.rect(maskX0, maskY0, maskX1 - maskX0, maskY1 - maskY0);
+          path17.rect(maskX0, maskY0, maskX1 - maskX0, maskY1 - maskY0);
         }
         layerCtx.save();
         layerCtx.globalAlpha = alpha / 255;
         layerCtx.setTransform(1, 0, 0, 1, 0, 0);
-        layerCtx.clip(path16, "evenodd");
+        layerCtx.clip(path17, "evenodd");
         layerCtx.globalCompositeOperation = "destination-in";
         layerCtx.fillStyle = "#000000";
         layerCtx.fillRect(layerOffsetX, layerOffsetY, layerWidth, layerHeight);
@@ -51528,21 +51528,21 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this._cachedGetSinglePixelWidth = null;
       }
       constructPath(opIdx, op, data, minMax) {
-        let [path16] = data;
+        let [path17] = data;
         if (!minMax) {
-          path16 ||= data[0] = new Path2D();
+          path17 ||= data[0] = new Path2D();
           if (op !== OPS.stroke && op !== OPS.closeStroke) {
             this.current.tilingPatternDims = null;
           }
-          this[op](opIdx, path16);
+          this[op](opIdx, path17);
           return;
         }
         if (this.dependencyTracker !== null) {
           const outerExtraSize = op === OPS.stroke ? this.current.lineWidth / 2 : 0;
           this.dependencyTracker.resetBBox(opIdx).recordBBox(opIdx, this.ctx, minMax[0] - outerExtraSize, minMax[2] + outerExtraSize, minMax[1] - outerExtraSize, minMax[3] + outerExtraSize).recordDependencies(opIdx, ["transform"]);
         }
-        if (!(path16 instanceof Path2D)) {
-          path16 = data[0] = makePathFromDrawOPS(path16);
+        if (!(path17 instanceof Path2D)) {
+          path17 = data[0] = makePathFromDrawOPS(path17);
         }
         Util.axialAlignedBoundingBox(minMax, getCurrentTransform(this.ctx), this.current.minMax);
         const tilingDims = this.current.tilingPatternDims;
@@ -51554,13 +51554,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             this.current.fillColor.updatePatternDims(clippedBBox, tilingDims);
           }
         }
-        this[op](opIdx, path16);
+        this[op](opIdx, path17);
         this._pathStartIdx = opIdx;
       }
       closePath(opIdx) {
         this.ctx.closePath();
       }
-      stroke(opIdx, path16, consumePath = true) {
+      stroke(opIdx, path17, consumePath = true) {
         const started = consumePath && this.#beginKnockoutElement(this.current.strokeAlpha);
         const ctx = this.ctx;
         const strokeColor = this.current.strokeColor;
@@ -51572,26 +51572,26 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             ctx.strokeStyle = strokeColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.STROKE, opIdx);
             if (baseTransform) {
               const newPath = new Path2D();
-              newPath.addPath(path16, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
-              path16 = newPath;
+              newPath.addPath(path17, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
+              path17 = newPath;
             }
-            this.rescaleAndStroke(path16, false);
+            this.rescaleAndStroke(path17, false);
             ctx.restore();
           } else {
-            this.rescaleAndStroke(path16, true);
+            this.rescaleAndStroke(path17, true);
           }
         }
         this.dependencyTracker?.recordDependencies(opIdx, Dependencies.stroke);
         if (consumePath) {
-          this.consumePath(opIdx, path16, this.current.getClippedPathBoundingBox(PathType.STROKE, getCurrentTransform(this.ctx)));
+          this.consumePath(opIdx, path17, this.current.getClippedPathBoundingBox(PathType.STROKE, getCurrentTransform(this.ctx)));
         }
         ctx.globalAlpha = this.current.fillAlpha;
         this.#endKnockoutElement(started);
       }
-      closeStroke(opIdx, path16) {
-        this.stroke(opIdx, path16);
+      closeStroke(opIdx, path17) {
+        this.stroke(opIdx, path17);
       }
-      fill(opIdx, path16, consumePath = true) {
+      fill(opIdx, path17, consumePath = true) {
         const started = consumePath && this.#beginKnockoutElement(this.current.fillAlpha);
         const ctx = this.ctx;
         const fillColor = this.current.fillColor;
@@ -51603,10 +51603,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const dims = this.current.tilingPatternDims;
           const tileIdx = dims && fillColor.canSkipPatternCanvas(dims);
           if (tileIdx) {
-            fillColor.drawPattern(this, path16, this.pendingEOFill, tileIdx, opIdx);
+            fillColor.drawPattern(this, path17, this.pendingEOFill, tileIdx, opIdx);
             this.pendingEOFill = false;
             if (consumePath) {
-              this.consumePath(opIdx, path16, intersect2);
+              this.consumePath(opIdx, path17, intersect2);
             }
             this.current.tilingPatternDims = null;
             this.#endKnockoutElement(started);
@@ -51618,17 +51618,17 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           ctx.fillStyle = fillColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.FILL, opIdx);
           if (baseTransform) {
             const newPath = new Path2D();
-            newPath.addPath(path16, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
-            path16 = newPath;
+            newPath.addPath(path17, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
+            path17 = newPath;
           }
           needRestore = true;
         }
         if (this.contentVisible && intersect2 !== null) {
           if (this.pendingEOFill) {
-            ctx.fill(path16, "evenodd");
+            ctx.fill(path17, "evenodd");
             this.pendingEOFill = false;
           } else {
-            ctx.fill(path16);
+            ctx.fill(path17);
           }
         }
         if (needRestore) {
@@ -51636,38 +51636,38 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           this.dependencyTracker?.restore(opIdx);
         }
         if (consumePath) {
-          this.consumePath(opIdx, path16, intersect2);
+          this.consumePath(opIdx, path17, intersect2);
         }
         this.#endKnockoutElement(started);
       }
-      eoFill(opIdx, path16) {
+      eoFill(opIdx, path17) {
         this.pendingEOFill = true;
-        this.fill(opIdx, path16);
+        this.fill(opIdx, path17);
       }
-      fillStroke(opIdx, path16) {
+      fillStroke(opIdx, path17) {
         const started = this.#beginKnockoutElement(Math.min(this.current.fillAlpha, this.current.strokeAlpha));
-        this.fill(opIdx, path16, false);
-        this.stroke(opIdx, path16, false);
-        this.consumePath(opIdx, path16);
+        this.fill(opIdx, path17, false);
+        this.stroke(opIdx, path17, false);
+        this.consumePath(opIdx, path17);
         this.#endKnockoutElement(started);
       }
-      eoFillStroke(opIdx, path16) {
+      eoFillStroke(opIdx, path17) {
         this.pendingEOFill = true;
-        this.fillStroke(opIdx, path16);
+        this.fillStroke(opIdx, path17);
       }
-      closeFillStroke(opIdx, path16) {
-        this.fillStroke(opIdx, path16);
+      closeFillStroke(opIdx, path17) {
+        this.fillStroke(opIdx, path17);
       }
-      closeEOFillStroke(opIdx, path16) {
+      closeEOFillStroke(opIdx, path17) {
         this.pendingEOFill = true;
-        this.fillStroke(opIdx, path16);
+        this.fillStroke(opIdx, path17);
       }
-      endPath(opIdx, path16) {
-        this.consumePath(opIdx, path16);
+      endPath(opIdx, path17) {
+        this.consumePath(opIdx, path17);
       }
-      rawFillPath(opIdx, path16) {
+      rawFillPath(opIdx, path17) {
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        this.ctx.fill(path16);
+        this.ctx.fill(path17);
         this.dependencyTracker?.recordDependencies(opIdx, Dependencies.rawFillPath).recordOperation(opIdx);
         this.#endKnockoutElement(started);
       }
@@ -51706,12 +51706,12 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             x: x2,
             y: y2,
             fontSize,
-            path: path16
+            path: path17
           } of paths) {
-            if (!path16) {
+            if (!path17) {
               continue;
             }
-            newPath.addPath(path16, new DOMMatrix(transform).preMultiplySelf(invTransf).translate(x2, y2).scale(fontSize, -fontSize));
+            newPath.addPath(path17, new DOMMatrix(transform).preMultiplySelf(invTransf).translate(x2, y2).scale(fontSize, -fontSize));
           }
           ctx.clip(newPath);
         }
@@ -51799,9 +51799,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this.moveText(opIdx, 0, this.current.leading);
         this.dependencyTracker?.recordIncrementalData("moveText", this.dependencyTracker.getSimpleIndex("leading") ?? opIdx);
       }
-      #getScaledPath(path16, currentTransform, transform) {
+      #getScaledPath(path17, currentTransform, transform) {
         const newPath = new Path2D();
-        newPath.addPath(path16, new DOMMatrix(transform).invertSelf().multiplySelf(currentTransform));
+        newPath.addPath(path17, new DOMMatrix(transform).invertSelf().multiplySelf(currentTransform));
         return newPath;
       }
       paintChar(opIdx, character, x2, y2, patternFillTransform, patternStrokeTransform) {
@@ -51814,11 +51814,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const isAddToPathSet = !!(textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG);
         const patternFill = current.patternFill && !font.missingFile;
         const patternStroke = current.patternStroke && !font.missingFile;
-        let path16;
+        let path17;
         if ((font.disableFontFace || isAddToPathSet || patternFill || patternStroke) && !font.missingFile) {
-          path16 = font.getPathGenerator(this.commonObjs, character);
+          path17 = font.getPathGenerator(this.commonObjs, character);
         }
-        if (path16 && (font.disableFontFace || patternFill || patternStroke)) {
+        if (path17 && (font.disableFontFace || patternFill || patternStroke)) {
           ctx.save();
           ctx.translate(x2, y2);
           ctx.scale(fontSize, -fontSize);
@@ -51828,10 +51828,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             if (patternFillTransform) {
               currentTransform = ctx.getTransform();
               ctx.setTransform(...patternFillTransform);
-              const scaledPath = this.#getScaledPath(path16, currentTransform, patternFillTransform);
+              const scaledPath = this.#getScaledPath(path17, currentTransform, patternFillTransform);
               ctx.fill(scaledPath);
             } else {
-              ctx.fill(path16);
+              ctx.fill(path17);
             }
           }
           if (fillStrokeMode === TextRenderingMode.STROKE || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
@@ -51848,10 +51848,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
               const transf = Util.transform([a, b2, c, d2, 0, 0], invPatternTransform);
               Util.singularValueDecompose2dScale(transf, XY);
               ctx.lineWidth *= Math.max(XY[0], XY[1]) / fontSize;
-              ctx.stroke(this.#getScaledPath(path16, currentTransform, patternStrokeTransform));
+              ctx.stroke(this.#getScaledPath(path17, currentTransform, patternStrokeTransform));
             } else {
               ctx.lineWidth /= fontSize;
-              ctx.stroke(path16);
+              ctx.stroke(path17);
             }
           }
           ctx.restore();
@@ -51874,7 +51874,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             x: x2,
             y: y2,
             fontSize,
-            path: path16
+            path: path17
           });
           this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, font, fontSize, x2, y2);
         }
@@ -52264,9 +52264,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             const [x0, y0, x1, y1] = group.bbox;
             clip.rect(x0, y0, x1 - x0, y1 - y0);
             if (group.matrix) {
-              const path16 = new Path2D();
-              path16.addPath(clip, new DOMMatrix(group.matrix));
-              clip = path16;
+              const path17 = new Path2D();
+              path17.addPath(clip, new DOMMatrix(group.matrix));
+              clip = path17;
             }
             currentCtx.clip(clip);
           }
@@ -52325,9 +52325,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const [x0, y0, x1, y1] = group.bbox;
           clip.rect(x0, y0, x1 - x0, y1 - y0);
           if (group.matrix) {
-            const path16 = new Path2D();
-            path16.addPath(clip, new DOMMatrix(group.matrix));
-            clip = path16;
+            const path17 = new Path2D();
+            path17.addPath(clip, new DOMMatrix(group.matrix));
+            clip = path17;
           }
           groupCtx.clip(clip);
         }
@@ -52853,7 +52853,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       endCompat(opIdx) {
       }
-      consumePath(opIdx, path16, clipBox) {
+      consumePath(opIdx, path17, clipBox) {
         const isEmpty = this.current.isEmptyClip();
         if (this.pendingClip) {
           this.current.updateClipFromPath();
@@ -52865,9 +52865,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (this.pendingClip) {
           if (!isEmpty) {
             if (this.pendingClip === EO_CLIP) {
-              ctx.clip(path16, "evenodd");
+              ctx.clip(path17, "evenodd");
             } else {
-              ctx.clip(path16);
+              ctx.clip(path17);
             }
           }
           this.pendingClip = null;
@@ -52940,7 +52940,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         return this._cachedScaleForStroking;
       }
-      rescaleAndStroke(path16, saveRestore) {
+      rescaleAndStroke(path17, saveRestore) {
         const {
           ctx,
           current: {
@@ -52950,7 +52950,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const [scaleX, scaleY] = this.getScaleForStroking();
         if (scaleX === scaleY) {
           ctx.lineWidth = (lineWidth || 1) * scaleX;
-          ctx.stroke(path16);
+          ctx.stroke(path17);
           return;
         }
         const dashes = ctx.getLineDash();
@@ -52961,7 +52961,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         SCALE_MATRIX.a = 1 / scaleX;
         SCALE_MATRIX.d = 1 / scaleY;
         const newPath = new Path2D();
-        newPath.addPath(path16, SCALE_MATRIX);
+        newPath.addPath(path17, SCALE_MATRIX);
         if (dashes.length > 0) {
           const scale = Math.max(scaleX, scaleY);
           ctx.setLineDash(dashes.map((x2) => x2 / scale));
@@ -53688,8 +53688,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           url
         } = stream._source;
         this._isStreamingSupported = !disableStream;
-        const fs14 = process.getBuiltinModule("fs/promises");
-        fs14.lstat(url).then((stat) => {
+        const fs15 = process.getBuiltinModule("fs/promises");
+        fs15.lstat(url).then((stat) => {
           const readableStream = getReadableStream(url);
           this._reader = readableStream.getReader();
           const {
@@ -64104,11 +64104,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
     };
     ContourDrawOutline = class extends InkDrawOutline {
       toSVGPath() {
-        let path16 = super.toSVGPath();
-        if (!path16.endsWith("Z")) {
-          path16 += "Z";
+        let path17 = super.toSVGPath();
+        if (!path17.endsWith("Z")) {
+          path17 += "Z";
         }
-        return path16;
+        return path17;
       }
     };
     es_uint8_array_from_base64 = __webpack_require__(5213);
@@ -66812,7 +66812,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           }
           const drawLayer = textLayerData.drawLayer;
           let div = textLayerData.selectionDiv;
-          let path16 = textLayerData.path;
+          let path17 = textLayerData.path;
           if (!div) {
             const clipPathId = `clip_selection_${_DrawLayer.#selectionId++}`;
             div = document.createElement("div");
@@ -66831,18 +66831,18 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             const clipPath = _DrawLayer._svgFactory.createElement("clipPath");
             clipPath.setAttribute("id", clipPathId);
             clipPath.setAttribute("clipPathUnits", "objectBoundingBox");
-            path16 = _DrawLayer._svgFactory.createElement("path");
-            clipPath.append(path16);
+            path17 = _DrawLayer._svgFactory.createElement("path");
+            clipPath.append(path17);
             svg.append(clipPath);
             div.append(svg);
-            textLayerData.path = path16;
+            textLayerData.path = path17;
             textLayerData.selectionDiv = div;
           }
           if (!div.parentNode && drawLayer.#parent) {
             drawLayer.#parent.append(div);
             this.#selections.add(div);
           }
-          path16.setAttribute("d", boxes.join(" "));
+          path17.setAttribute("d", boxes.join(" "));
         }
       }
       static get _svgFactory() {
@@ -66889,13 +66889,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const root = this.#createSVG();
         const defs = _DrawLayer._svgFactory.createElement("defs");
         root.append(defs);
-        const path16 = _DrawLayer._svgFactory.createElement("path");
-        defs.append(path16);
+        const path17 = _DrawLayer._svgFactory.createElement("path");
+        defs.append(path17);
         const pathId = `path_${id}`;
-        path16.setAttribute("id", pathId);
-        path16.setAttribute("vector-effect", "non-scaling-stroke");
+        path17.setAttribute("id", pathId);
+        path17.setAttribute("vector-effect", "non-scaling-stroke");
         if (isPathUpdatable) {
-          this.#toUpdate.set(id, path16);
+          this.#toUpdate.set(id, path17);
         }
         const clipPathId = hasClip ? this.#createClipPath(defs, pathId) : null;
         const use = _DrawLayer._svgFactory.createElement("use");
@@ -66913,11 +66913,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const root = this.#createSVG();
         const defs = _DrawLayer._svgFactory.createElement("defs");
         root.append(defs);
-        const path16 = _DrawLayer._svgFactory.createElement("path");
-        defs.append(path16);
+        const path17 = _DrawLayer._svgFactory.createElement("path");
+        defs.append(path17);
         const pathId = `path_${id}`;
-        path16.setAttribute("id", pathId);
-        path16.setAttribute("vector-effect", "non-scaling-stroke");
+        path17.setAttribute("id", pathId);
+        path17.setAttribute("vector-effect", "non-scaling-stroke");
         let maskId;
         if (mustRemoveSelfIntersections) {
           const mask = _DrawLayer._svgFactory.createElement("mask");
@@ -66964,7 +66964,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           root,
           bbox,
           rootClass,
-          path: path16
+          path: path17
         } = properties;
         const element = typeof elementOrId === "number" ? this.#mapping.get(elementOrId) : elementOrId;
         if (!element) {
@@ -66984,10 +66984,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             classList.toggle(className, value);
           }
         }
-        if (path16) {
+        if (path17) {
           const defs = element.firstElementChild;
           const pathElement = defs.firstElementChild;
-          this.#updateProperties(pathElement, path16);
+          this.#updateProperties(pathElement, path17);
         }
       }
       updateParent(id, layer) {
@@ -67204,7 +67204,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
 
 // ../server/src/index.ts
 import { createHash, timingSafeEqual } from "node:crypto";
-import fs13 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import fastifyStatic from "@fastify/static";
 import websocket from "@fastify/websocket";
 import Fastify from "fastify";
@@ -82937,8 +82937,8 @@ var CONFIG_DIR_NAME = pkg.piConfig?.configDir || ".pi";
 var VERSION = pkg.version || "0.0.0";
 var ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
 var ENV_SESSION_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_SESSION_DIR`;
-function expandTildePath(path16) {
-  return normalizePath(path16);
+function expandTildePath(path17) {
+  return normalizePath(path17);
 }
 function getAgentDir() {
   const envDir = process.env[ENV_AGENT_DIR];
@@ -83287,8 +83287,8 @@ function parseThemeJson(label, json) {
         }
         continue;
       }
-      const path16 = error.instancePath || "/";
-      otherErrors.push(`  - ${path16}: ${error.message}`);
+      const path17 = error.instancePath || "/";
+      otherErrors.push(`  - ${path17}: ${error.message}`);
     }
     let errorMessage = `Invalid theme "${label}":
 `;
@@ -84876,18 +84876,18 @@ var RpcRuntime = class {
   contextEntries() {
     const leaf = this.leafId;
     if (leaf === null) return [];
-    const path16 = [];
+    const path17 = [];
     const walk = (node) => {
-      path16.push(node.entry);
+      path17.push(node.entry);
       if (node.entry.id === leaf) return true;
       for (const child of node.children) {
         if (walk(child)) return true;
       }
-      path16.pop();
+      path17.pop();
       return false;
     };
     for (const root of this.treeRoots) {
-      if (walk(root)) return path16;
+      if (walk(root)) return path17;
     }
     return [];
   }
@@ -90664,6 +90664,7 @@ function loadConfig(launchDir, flags = {}, env2 = process.env) {
   config2.appendSystemPrompt = optionalStringArray(raw, "appendSystemPrompt") ?? [];
   config2.webContext = optionalBoolean(raw, "webContext", true);
   config2.offline = optionalBoolean(raw, "offline", false);
+  if (raw.openBrowser !== void 0) config2.openBrowser = optionalBoolean(raw, "openBrowser", true);
   if (raw.server !== void 0) {
     const server = asObject(raw.server, "server");
     if (server.port !== void 0) {
@@ -97891,7 +97892,7 @@ function createStructuredExchangeToolDefinition(options = {}) {
 var TOOLS_ENV_VAR = "PI_OUTPOST_TOOLS";
 
 // ../server/src/index.ts
-import path15 from "node:path";
+import path16 from "node:path";
 
 // ../server/src/cli.ts
 import fs11 from "node:fs";
@@ -97927,6 +97928,7 @@ Usage
   pi-outpost config [options]    print the configuration that would be used, and where it came from
   pi-outpost login --provider <name>
                                  store an API key for a provider in <agentDir>/auth.json
+  pi-outpost build-exe [options] build a standalone executable from this installation
 
 Options
   --config <path>    configuration file to use
@@ -97936,6 +97938,8 @@ Options
   --port <n>         port to listen on (default: 3141)
   --host <addr>      address to bind (default: 127.0.0.1)
   --offline          never fetch remote model catalogs (air-gapped hosts)
+  --open             open the interface in your browser once the server is listening
+  --no-open          do not (the default wherever no desktop session exists)
   -h, --help         show this help
   -v, --version      show the version
 
@@ -97946,6 +97950,14 @@ init options
 login options
   --provider <name>  provider to store a key for (e.g. anthropic, openai, mistral)
 
+build-exe options
+  --out <path>       where to write it (default: ./pi-outpost, ./pi-outpost.exe on Windows)
+  --force            replace an existing file at that path
+
+The executable carries the server and the web UI and needs nothing installed to run.
+Released builds are attached to https://github.com/laurentftech/pi-outpost/releases \u2014
+this command is for building one from the version you have.
+
 The key itself has no flag, for the same reason the auth token has none: argv is
 world-readable. It is prompted for on a terminal, or read from stdin when piped:
   echo "$KEY" | pi-outpost login --provider anthropic
@@ -98010,7 +98022,7 @@ Agent runtime
 `;
 var CliError = class extends Error {
 };
-var COMMANDS = ["init", "config", "login"];
+var COMMANDS = ["init", "config", "login", "build-exe"];
 function integerFlag(value, name) {
   if (value === void 0) return void 0;
   const parsed = Number(value);
@@ -98036,6 +98048,9 @@ function parseCli(argv) {
         global: { type: "boolean", default: false },
         force: { type: "boolean", default: false },
         provider: { type: "string" },
+        out: { type: "string" },
+        open: { type: "boolean", default: false },
+        "no-open": { type: "boolean", default: false },
         help: { type: "boolean", short: "h", default: false },
         version: { type: "boolean", short: "v", default: false }
       }
@@ -98051,6 +98066,18 @@ function parseCli(argv) {
     throw new CliError(`unknown command "${positional}" \u2014 see "pi-outpost --help"`);
   }
   const command = positional;
+  if (values.out !== void 0 && command !== "build-exe") {
+    throw new CliError('"--out" belongs to "pi-outpost build-exe" \u2014 see "pi-outpost --help"');
+  }
+  if (values.provider !== void 0 && command !== "login") {
+    throw new CliError('"--provider" belongs to "pi-outpost login" \u2014 see "pi-outpost --help"');
+  }
+  if (values.global && command !== "init") {
+    throw new CliError('"--global" belongs to "pi-outpost init" \u2014 see "pi-outpost --help"');
+  }
+  if (values.open && values["no-open"]) {
+    throw new CliError('"--open" and "--no-open" contradict each other \u2014 see "pi-outpost --help"');
+  }
   const flags = {
     config: values.config,
     profile: values.profile,
@@ -98066,7 +98093,10 @@ function parseCli(argv) {
     command: kind,
     flags,
     init: { global: values.global, force: values.force },
-    login: { provider: values.provider }
+    login: { provider: values.provider },
+    buildExe: { out: values.out, force: values.force },
+    // Left undefined unless asked for, so configuration still has its say.
+    ...values.open ? { open: true } : values["no-open"] ? { open: false } : {}
   };
 }
 async function readSecret(prompt) {
@@ -98117,18 +98147,220 @@ function helpText() {
   return HELP;
 }
 
-// ../server/src/fileBrowser.ts
-import { constants as constants2 } from "node:fs";
-import fs12 from "node:fs/promises";
+// ../server/src/buildExe.ts
+import { spawnSync } from "node:child_process";
+import fs12 from "node:fs";
+import os4 from "node:os";
 import path13 from "node:path";
+function seaConfigFor(main, output) {
+  return { main, output, mainFormat: "module", disableExperimentalSEAWarning: true };
+}
+function seaConfigBytes(config2) {
+  return Buffer.from(JSON.stringify(config2, null, 2), "utf8");
+}
+function executableName(base, platform = process.platform) {
+  return platform === "win32" ? `${base}.exe` : base;
+}
+var MINIMUM_DIRECT_BUILD_MAJOR = 26;
+function majorOf(version2) {
+  return Number(version2.replace(/^v/, "").split(".")[0]);
+}
+function canBuildDirectly(version2 = process.version) {
+  return majorOf(version2) >= MINIMUM_DIRECT_BUILD_MAJOR;
+}
+function findBuildInputs(from) {
+  from = from ?? import.meta.dirname;
+  const roots = [from, path13.resolve(from, "../../cli/dist")];
+  const found = {};
+  for (const root of roots) {
+    const bundle = path13.join(root, "pi-outpost.sea.mjs");
+    const blob = path13.join(root, "sea-prep.blob");
+    if (found.bundle === void 0 && fs12.existsSync(bundle)) found.bundle = bundle;
+    if (found.blob === void 0 && fs12.existsSync(blob)) found.blob = blob;
+  }
+  return found;
+}
+var BuildExeError = class extends Error {
+};
+var FUSE_PARTS = ["NODE", "SEA", "FUSE", "fce680ab2cc467b6", "e072b8b5df1996b2"];
+var SEA_SENTINEL_FUSE = `${FUSE_PARTS.slice(0, 3).join("_")}_${FUSE_PARTS.slice(3).join("")}`;
+function carriesSeaSentinel(binary = process.execPath) {
+  const CHUNK = 1 << 20;
+  const overlap = Buffer.byteLength(SEA_SENTINEL_FUSE);
+  const handle = fs12.openSync(binary, "r");
+  try {
+    const buffer = Buffer.alloc(CHUNK + overlap);
+    let position = 0;
+    let carried = 0;
+    for (; ; ) {
+      const read = fs12.readSync(handle, buffer, carried, CHUNK, position);
+      if (read === 0) return false;
+      if (buffer.subarray(0, carried + read).includes(SEA_SENTINEL_FUSE)) return true;
+      buffer.copy(buffer, 0, carried + read - overlap, carried + read);
+      carried = overlap;
+      position += read;
+    }
+  } finally {
+    fs12.closeSync(handle);
+  }
+}
+function run(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8" });
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  if (result.error !== void 0) {
+    const missing = result.error.code === "ENOENT";
+    return { ok: false, output: result.error.message, missing };
+  }
+  return { ok: result.status === 0, output, missing: false };
+}
+function resignMacho(target) {
+  run("codesign", ["--remove-signature", target]);
+  const signed = run("codesign", ["--sign", "-", target]);
+  if (signed.missing) {
+    throw new BuildExeError(
+      "codesign is required on macOS to make the executable launchable \u2014 install the Xcode command line tools (xcode-select --install)"
+    );
+  }
+  if (!signed.ok) throw new BuildExeError(`could not sign the executable: ${signed.output}`);
+}
+function producedExecutableRuns(target) {
+  const result = spawnSync(target, ["--version"], { encoding: "utf8", timeout: 3e4 });
+  if (result.error !== void 0) return { ok: false, detail: result.error.message };
+  if (result.signal !== null) return { ok: false, detail: `killed by ${result.signal}` };
+  if (result.status !== 0) {
+    return { ok: false, detail: `exited ${result.status}: ${`${result.stdout ?? ""}${result.stderr ?? ""}`.trim()}` };
+  }
+  return { ok: true, detail: (result.stdout ?? "").trim() };
+}
+function buildExecutable(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const cwd = options.cwd ?? process.cwd();
+  const log = options.log ?? ((line) => console.log(line));
+  const version2 = options.nodeVersion ?? process.version;
+  const target = path13.resolve(cwd, options.out ?? executableName("pi-outpost", platform));
+  if (fs12.existsSync(target) && options.force !== true) {
+    throw new BuildExeError(`${target} already exists \u2014 pass --force to replace it`);
+  }
+  const { bundle, blob } = findBuildInputs(options.inputsFrom);
+  if (bundle === void 0 && blob === void 0) {
+    throw new BuildExeError(
+      "no build inputs beside this installation \u2014 build an executable from an installed package (npm i pi-outpost) or a clone, not from an executable"
+    );
+  }
+  if (canBuildDirectly(version2) && bundle !== void 0) {
+    const configPath = path13.join(fs12.mkdtempSync(path13.join(os4.tmpdir(), "pi-outpost-sea-")), "sea-config.json");
+    fs12.writeFileSync(configPath, seaConfigBytes(seaConfigFor(bundle, target)));
+    try {
+      log(`[build-exe] building with node --build-sea (node ${version2})`);
+      const built = run(process.execPath, ["--build-sea", configPath]);
+      if (!built.ok) throw new BuildExeError(`node --build-sea failed: ${built.output}`);
+    } finally {
+      fs12.rmSync(path13.dirname(configPath), { recursive: true, force: true });
+    }
+    if (platform === "darwin") resignMacho(target);
+    const verdict = options.skipSmokeTest === true ? { ok: true, detail: "" } : producedExecutableRuns(target);
+    if (verdict.ok) return { path: target, method: "build-sea" };
+    if (blob === void 0 || !carriesSeaSentinel()) {
+      throw new BuildExeError(
+        `built ${target} with node --build-sea but it does not run \u2014 ${verdict.detail}. This runtime's --build-sea is failing, not your configuration; a one-line hello-world built the same way fails the same way.`
+      );
+    }
+    log(`[build-exe] the direct build does not run here (${verdict.detail}) \u2014 falling back to the blob`);
+    fs12.rmSync(target, { force: true });
+  }
+  if (blob === void 0) {
+    throw new BuildExeError(
+      `node ${version2} cannot build directly (needs ${MINIMUM_DIRECT_BUILD_MAJOR} or newer) and sea-prep.blob is missing from this installation`
+    );
+  }
+  if (!carriesSeaSentinel()) {
+    throw new BuildExeError(
+      `this node (${process.execPath}) was built without single-executable support, so a blob cannot be injected into it \u2014 install Node ${MINIMUM_DIRECT_BUILD_MAJOR} or newer and the executable is built directly, with no injection at all`
+    );
+  }
+  if (!canBuildDirectly(version2)) {
+    log(`[build-exe] node ${version2} is older than ${MINIMUM_DIRECT_BUILD_MAJOR} \u2014 injecting sea-prep.blob instead`);
+  }
+  fs12.copyFileSync(process.execPath, target);
+  fs12.chmodSync(target, 493);
+  const injected = run("npx", [
+    "--yes",
+    "postject",
+    target,
+    "NODE_SEA_BLOB",
+    blob,
+    "--sentinel-fuse",
+    SEA_SENTINEL_FUSE,
+    ...platform === "darwin" ? ["--macho-segment-name", "NODE_SEA"] : [],
+    "--overwrite"
+  ]);
+  if (!injected.ok) {
+    fs12.rmSync(target, { force: true });
+    throw new BuildExeError(`postject failed: ${injected.output}`);
+  }
+  if (platform === "darwin") resignMacho(target);
+  assertItRuns(target, "postject", options);
+  return { path: target, method: "postject" };
+}
+function assertItRuns(target, method, options) {
+  if (options.skipSmokeTest === true) return;
+  const verdict = producedExecutableRuns(target);
+  if (verdict.ok) return;
+  throw new BuildExeError(
+    `built ${target} (${method}) but it does not run \u2014 ${verdict.detail}. The file is left in place. This is the runtime's single-executable support failing, not your configuration: a one-line hello-world built the same way will fail the same way, which is worth checking before looking further.`
+  );
+}
+
+// ../server/src/openBrowser.ts
 import { spawn as spawn2 } from "node:child_process";
+function shouldOpenBrowser({
+  explicit,
+  configured,
+  platform = process.platform,
+  env: env2 = process.env
+} = {}) {
+  if (explicit !== void 0) return explicit;
+  if (configured !== void 0) return configured;
+  if (env2.CI !== void 0 && env2.CI !== "" && env2.CI !== "false") return false;
+  if (platform === "darwin" || platform === "win32") return true;
+  return Boolean(env2.DISPLAY ?? env2.WAYLAND_DISPLAY);
+}
+function browsableUrl(address) {
+  const host = address.address === "0.0.0.0" || address.address === "::" || address.address === "" ? "127.0.0.1" : address.address;
+  const authority = host.includes(":") ? `[${host}]` : host;
+  return `http://${authority}:${address.port}/`;
+}
+function openerFor(platform, url) {
+  if (platform === "darwin") return { command: "open", args: [url] };
+  if (platform === "win32") return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}
+function openBrowser(url, platform = process.platform) {
+  const { command, args } = openerFor(platform, url);
+  return new Promise((resolve2) => {
+    try {
+      const child = spawn2(command, args, { detached: true, stdio: "ignore" });
+      child.on("error", () => resolve2(false));
+      child.unref();
+      resolve2(true);
+    } catch {
+      resolve2(false);
+    }
+  });
+}
+
+// ../server/src/fileBrowser.ts
+import { constants as constants2 } from "node:fs";
+import fs13 from "node:fs/promises";
+import path14 from "node:path";
+import { spawn as spawn3 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 var MAX_PREVIEW_BYTES = 1048576;
 var MAX_UPLOAD_BYTES = 26214400;
 var MAX_UPLOAD_BASE64_LENGTH = Math.ceil(MAX_UPLOAD_BYTES / 3) * 4;
 var UPLOADS_DIRECTORY = "uploads";
 function isPdfPath(relPath) {
-  return path13.extname(relPath).toLowerCase() === ".pdf";
+  return path14.extname(relPath).toLowerCase() === ".pdf";
 }
 var FileBrowserError = class extends Error {
   constructor(reason, message) {
@@ -98138,16 +98370,16 @@ var FileBrowserError = class extends Error {
   reason;
 };
 async function resolveBrowserRoot(config2) {
-  return fs12.realpath(config2.sandbox?.root ?? config2.cwd);
+  return fs13.realpath(config2.sandbox?.root ?? config2.cwd);
 }
 async function resolveWritableRoot(config2, browserRoot) {
   if (!config2.sandbox) return void 0;
   if (!config2.sandbox.allowWrite) return null;
-  const target = config2.sandbox.writableRoot ? await fs12.realpath(config2.sandbox.writableRoot) : browserRoot;
-  return path13.relative(browserRoot, target).split(path13.sep).join("/");
+  const target = config2.sandbox.writableRoot ? await fs13.realpath(config2.sandbox.writableRoot) : browserRoot;
+  return path14.relative(browserRoot, target).split(path14.sep).join("/");
 }
 async function resolveConfined(root, relPath) {
-  const target = path13.resolve(root, relPath);
+  const target = path14.resolve(root, relPath);
   const resolved = await realResolve(target);
   if (!isWithin(root, resolved)) {
     throw new FileBrowserError("outside-root", `"${relPath}" is outside the browser root`);
@@ -98165,7 +98397,7 @@ async function listDirectory(root, relPath) {
   const resolved = await resolveConfined(root, relPath);
   let dirents;
   try {
-    dirents = await fs12.readdir(resolved, { withFileTypes: true });
+    dirents = await fs13.readdir(resolved, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new FileBrowserError("not-found", `"${relPath}" does not exist`);
@@ -98178,7 +98410,7 @@ async function listDirectory(root, relPath) {
         return { name: dirent.name, type: dirent.isDirectory() ? "directory" : dirent.isFile() ? "file" : "other" };
       }
       try {
-        const stat = await fs12.stat(path13.join(resolved, dirent.name));
+        const stat = await fs13.stat(path14.join(resolved, dirent.name));
         return { name: dirent.name, type: classify(dirent, stat.isDirectory() ? "directory" : stat.isFile() ? "file" : "other") };
       } catch {
         return { name: dirent.name, type: "other" };
@@ -98200,7 +98432,7 @@ async function readFileForPreview(root, relPath) {
   const resolved = await resolveConfined(root, relPath);
   let stat;
   try {
-    stat = await fs12.stat(resolved);
+    stat = await fs13.stat(resolved);
   } catch {
     throw new FileBrowserError("not-found", `"${relPath}" does not exist`);
   }
@@ -98211,7 +98443,7 @@ async function readFileForPreview(root, relPath) {
     const mb = (stat.size / (1024 * 1024)).toFixed(1);
     throw new FileBrowserError("too-large", `File is ${mb} MB, larger than the 1 MB preview limit`);
   }
-  const buffer = await fs12.readFile(resolved);
+  const buffer = await fs13.readFile(resolved);
   if (looksBinary(buffer)) {
     throw new FileBrowserError("binary", "Binary file \u2014 preview not supported");
   }
@@ -98221,7 +98453,7 @@ async function readFileRaw(root, relPath, pdfMaxBytes = MAX_PREVIEW_BYTES) {
   const resolved = await resolveConfined(root, relPath);
   let stat;
   try {
-    stat = await fs12.stat(resolved);
+    stat = await fs13.stat(resolved);
   } catch {
     throw new FileBrowserError("not-found", `"${relPath}" does not exist`);
   }
@@ -98233,7 +98465,7 @@ async function readFileRaw(root, relPath, pdfMaxBytes = MAX_PREVIEW_BYTES) {
     const mb = (limit / (1024 * 1024)).toFixed(0);
     throw new FileBrowserError("too-large", `File is larger than the ${mb} MB limit`);
   }
-  return fs12.readFile(resolved);
+  return fs13.readFile(resolved);
 }
 function assertCreatableName(relPath) {
   const name = relPath.split("/").pop() ?? "";
@@ -98255,7 +98487,7 @@ async function resolveForCreation(root, writableRel, relPath) {
     throw new FileBrowserError("denied", "The sandbox is read-only");
   }
   assertCreatableName(relPath);
-  const writableRoot = writableRel === void 0 ? root : path13.resolve(root, writableRel);
+  const writableRoot = writableRel === void 0 ? root : path14.resolve(root, writableRel);
   const resolved = await resolveConfined(root, relPath);
   if (!isWithin(writableRoot, resolved)) {
     throw new FileBrowserError("denied", `"${relPath}" is outside the writable zone`);
@@ -98273,17 +98505,17 @@ function creationError(error, relPath) {
 async function createFileFromBrowser(root, writableRel, relPath) {
   const resolved = await resolveForCreation(root, writableRel, relPath);
   try {
-    await fs12.writeFile(resolved, "", { flag: "wx" });
+    await fs13.writeFile(resolved, "", { flag: "wx" });
   } catch (error) {
     throw creationError(error, relPath);
   }
-  const stat = await fs12.stat(resolved);
+  const stat = await fs13.stat(resolved);
   return { size: stat.size, mtimeMs: stat.mtimeMs };
 }
 async function createDirectoryFromBrowser(root, writableRel, relPath) {
   const resolved = await resolveForCreation(root, writableRel, relPath);
   try {
-    await fs12.mkdir(resolved);
+    await fs13.mkdir(resolved);
   } catch (error) {
     throw creationError(error, relPath);
   }
@@ -98323,7 +98555,7 @@ function assertBase64(content) {
 }
 function suffixed(name, attempt) {
   if (attempt === 0) return name;
-  const ext = path13.extname(name);
+  const ext = path14.extname(name);
   return `${name.slice(0, name.length - ext.length)}-${attempt}${ext}`;
 }
 var MAX_UPLOAD_NAME_ATTEMPTS = 1e3;
@@ -98332,12 +98564,12 @@ async function uploadFileFromBrowser(root, writableRel, destinationDirectory, na
     throw new FileBrowserError("denied", "The sandbox is read-only");
   }
   assertUploadName(name);
-  const writableRoot = writableRel === void 0 ? root : path13.resolve(root, writableRel);
+  const writableRoot = writableRel === void 0 ? root : path14.resolve(root, writableRel);
   const destination = await resolveConfined(root, destinationDirectory);
   if (!isWithin(writableRoot, destination)) {
     throw new FileBrowserError("denied", `"${destinationDirectory}" is outside the writable zone`);
   }
-  if (path13.resolve(root, destinationDirectory) !== path13.resolve(writableRoot, UPLOADS_DIRECTORY)) {
+  if (path14.resolve(root, destinationDirectory) !== path14.resolve(writableRoot, UPLOADS_DIRECTORY)) {
     throw new FileBrowserError("denied", `Uploads may only be written to "${UPLOADS_DIRECTORY}"`);
   }
   if (contentBase64.length > MAX_UPLOAD_BASE64_LENGTH) {
@@ -98349,7 +98581,7 @@ async function uploadFileFromBrowser(root, writableRel, destinationDirectory, na
     throw new FileBrowserError("too-large", `Uploads are limited to ${MAX_UPLOAD_BYTES / (1024 * 1024)} MB`);
   }
   try {
-    await fs12.mkdir(destination, { recursive: true });
+    await fs13.mkdir(destination, { recursive: true });
   } catch (error) {
     throw creationError(error, destinationDirectory);
   }
@@ -98357,32 +98589,32 @@ async function uploadFileFromBrowser(root, writableRel, destinationDirectory, na
   if (!isWithin(root, confirmed) || !isWithin(writableRoot, confirmed)) {
     throw new FileBrowserError("outside-root", `"${destinationDirectory}" is outside the browser root`);
   }
-  const tmp = path13.join(confirmed, `.pi-outpost-upload-${randomBytes(12).toString("hex")}.tmp`);
+  const tmp = path14.join(confirmed, `.pi-outpost-upload-${randomBytes(12).toString("hex")}.tmp`);
   try {
     try {
-      await fs12.writeFile(tmp, buffer, { flag: "wx" });
+      await fs13.writeFile(tmp, buffer, { flag: "wx" });
     } catch (error) {
       throw creationError(error, name);
     }
     for (let attempt = 0; attempt < MAX_UPLOAD_NAME_ATTEMPTS; attempt++) {
       const candidate = suffixed(name, attempt);
-      const target = path13.join(confirmed, candidate);
+      const target = path14.join(confirmed, candidate);
       try {
-        await fs12.link(tmp, target);
-        return path13.relative(root, target).split(path13.sep).join("/");
+        await fs13.link(tmp, target);
+        return path14.relative(root, target).split(path14.sep).join("/");
       } catch (error) {
         if (error.code !== "EEXIST") throw creationError(error, candidate);
       }
     }
     throw new FileBrowserError("conflict", `Too many files named "${name}" already`);
   } finally {
-    await fs12.rm(tmp, { force: true }).catch(() => {
+    await fs13.rm(tmp, { force: true }).catch(() => {
     });
   }
 }
 async function launchNative(command, args) {
   await new Promise((resolve2, reject) => {
-    const child = spawn2(command, args, { shell: false, stdio: "ignore", windowsHide: true });
+    const child = spawn3(command, args, { shell: false, stdio: "ignore", windowsHide: true });
     let settled = false;
     child.once("error", (error) => {
       if (settled) return;
@@ -98401,7 +98633,7 @@ async function openFileNative(root, relPath, launcher = launchNative, platform =
   const resolved = await resolveConfined(root, relPath);
   let stat;
   try {
-    stat = await fs12.stat(resolved);
+    stat = await fs13.stat(resolved);
   } catch {
     throw new FileBrowserError("not-found", `"${relPath}" does not exist`);
   }
@@ -98416,7 +98648,7 @@ async function openFileNative(root, relPath, launcher = launchNative, platform =
 async function resolveRegularFile(root, relPath) {
   const resolved = await resolveConfined(root, relPath);
   try {
-    if (!(await fs12.lstat(path13.resolve(root, relPath))).isFile()) {
+    if (!(await fs13.lstat(path14.resolve(root, relPath))).isFile()) {
       throw new FileBrowserError("not-found", `"${relPath}" is not a regular file`);
     }
   } catch (error) {
@@ -98428,7 +98660,7 @@ async function resolveRegularFile(root, relPath) {
 async function resolveWritableFile(root, writableRel, relPath) {
   if (writableRel === null) throw new FileBrowserError("denied", "The sandbox is read-only");
   const resolved = await resolveRegularFile(root, relPath);
-  const writableRoot = writableRel === void 0 ? root : path13.resolve(root, writableRel);
+  const writableRoot = writableRel === void 0 ? root : path14.resolve(root, writableRel);
   if (!isWithin(writableRoot, resolved)) {
     throw new FileBrowserError("denied", `"${relPath}" is outside the writable zone`);
   }
@@ -98437,12 +98669,12 @@ async function resolveWritableFile(root, writableRel, relPath) {
 async function resolveWritableDirectory(root, writableRel, relPath) {
   if (writableRel === null) throw new FileBrowserError("denied", "The sandbox is read-only");
   const resolved = await resolveConfined(root, relPath);
-  const writableRoot = writableRel === void 0 ? root : path13.resolve(root, writableRel);
+  const writableRoot = writableRel === void 0 ? root : path14.resolve(root, writableRel);
   if (!isWithin(writableRoot, resolved)) {
     throw new FileBrowserError("denied", `"${relPath}" is outside the writable zone`);
   }
   try {
-    if (!(await fs12.stat(resolved)).isDirectory()) {
+    if (!(await fs13.stat(resolved)).isDirectory()) {
       throw new FileBrowserError("not-found", `"${relPath}" is not a directory`);
     }
   } catch (error) {
@@ -98462,14 +98694,14 @@ function lifecycleError(error, relPath, verb) {
 }
 async function linkThenUnlink(source, destination, destinationRel, verb) {
   try {
-    await fs12.link(source, destination);
+    await fs13.link(source, destination);
   } catch (error) {
     throw lifecycleError(error, destinationRel, verb);
   }
   try {
-    await fs12.unlink(source);
+    await fs13.unlink(source);
   } catch (error) {
-    await fs12.unlink(destination).catch(() => {
+    await fs13.unlink(destination).catch(() => {
     });
     throw lifecycleError(error, destinationRel, verb);
   }
@@ -98488,7 +98720,7 @@ async function renameFileFromBrowser(root, writableRel, relPath, name) {
 async function deleteFileFromBrowser(root, writableRel, relPath) {
   const source = await resolveWritableFile(root, writableRel, relPath);
   try {
-    await fs12.unlink(source);
+    await fs13.unlink(source);
   } catch (error) {
     throw lifecycleError(error, relPath, "delete");
   }
@@ -98498,7 +98730,7 @@ async function moveFileFromBrowser(root, writableRel, relPath, destinationDirect
   const destinationDir = await resolveWritableDirectory(root, writableRel, destinationDirectory);
   const name = relPath.split("/").pop() ?? "";
   const destinationRel = destinationDirectory ? `${destinationDirectory}/${name}` : name;
-  const destination = path13.join(destinationDir, name);
+  const destination = path14.join(destinationDir, name);
   await resolveConfined(root, destinationRel);
   await linkThenUnlink(source, destination, destinationRel, "move");
   return destinationRel;
@@ -98508,10 +98740,10 @@ async function copyFileFromBrowser(root, writableRel, relPath, destinationDirect
   const destinationDir = await resolveWritableDirectory(root, writableRel, destinationDirectory);
   const name = relPath.split("/").pop() ?? "";
   const destinationRel = destinationDirectory ? `${destinationDirectory}/${name}` : name;
-  const destination = path13.join(destinationDir, name);
+  const destination = path14.join(destinationDir, name);
   await resolveConfined(root, destinationRel);
   try {
-    await fs12.copyFile(source, destination, constants2.COPYFILE_EXCL);
+    await fs13.copyFile(source, destination, constants2.COPYFILE_EXCL);
   } catch (error) {
     throw lifecycleError(error, destinationRel, "copy");
   }
@@ -98521,7 +98753,7 @@ async function writeFileFromBrowser(root, writableRel, relPath, content, expecte
   if (writableRel === null) {
     throw new FileBrowserError("denied", "The sandbox is read-only");
   }
-  const writableRoot = writableRel === void 0 ? root : path13.resolve(root, writableRel);
+  const writableRoot = writableRel === void 0 ? root : path14.resolve(root, writableRel);
   const resolved = await resolveConfined(root, relPath);
   if (!isWithin(writableRoot, resolved)) {
     throw new FileBrowserError("denied", `"${relPath}" is outside the writable zone`);
@@ -98539,7 +98771,7 @@ async function writeFileFromBrowser(root, writableRel, relPath, content, expecte
   }
   let stat;
   try {
-    stat = await fs12.stat(resolved);
+    stat = await fs13.stat(resolved);
   } catch {
     throw new FileBrowserError("conflict", `"${relPath}" no longer exists`);
   }
@@ -98551,14 +98783,14 @@ async function writeFileFromBrowser(root, writableRel, relPath, content, expecte
   }
   const tmp = `${resolved}.pi-outpost-${randomBytes(12).toString("hex")}.tmp`;
   try {
-    await fs12.writeFile(tmp, buffer, { mode: stat.mode, flag: "wx" });
-    await fs12.rename(tmp, resolved);
+    await fs13.writeFile(tmp, buffer, { mode: stat.mode, flag: "wx" });
+    await fs13.rename(tmp, resolved);
   } catch (error) {
-    await fs12.rm(tmp, { force: true }).catch(() => {
+    await fs13.rm(tmp, { force: true }).catch(() => {
     });
     throw error;
   }
-  const written = await fs12.stat(resolved);
+  const written = await fs13.stat(resolved);
   return { size: written.size, mtimeMs: written.mtimeMs };
 }
 var SEARCH_IGNORED_NAMES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".git", ".next", ".turbo", "__pycache__"]);
@@ -98572,7 +98804,7 @@ async function searchFiles(root, query, limit = 20) {
     if (results.length >= limit || visited3 >= SEARCH_MAX_VISITED) return;
     let dirents;
     try {
-      dirents = await fs12.readdir(dir, { withFileTypes: true });
+      dirents = await fs13.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -98586,7 +98818,7 @@ async function searchFiles(root, query, limit = 20) {
         results.push({ path: relPath, type: isDirectory ? "directory" : dirent.isFile() ? "file" : "other" });
       }
       if (isDirectory) {
-        await walk(path13.join(dir, dirent.name), relPath);
+        await walk(path14.join(dir, dirent.name), relPath);
       }
     }
   }
@@ -98597,7 +98829,7 @@ async function searchFiles(root, query, limit = 20) {
 
 // ../server/src/git.ts
 import { execFile } from "node:child_process";
-import path14 from "node:path";
+import path15 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var GIT_TIMEOUT_MS = 1e4;
@@ -98688,13 +98920,13 @@ async function gitStatus(root) {
   return result;
 }
 function toToplevelRelative(root, toplevel, relPath) {
-  const prefix = path14.relative(toplevel, root).split(path14.sep).join("/");
+  const prefix = path15.relative(toplevel, root).split(path15.sep).join("/");
   return prefix === "" ? relPath : `${prefix}/${relPath}`;
 }
 function toRootRelative(root, toplevel, toplevelRel) {
-  const prefix = path14.relative(toplevel, root).split(path14.sep).join("/");
+  const prefix = path15.relative(toplevel, root).split(path15.sep).join("/");
   if (prefix === "") return toplevelRel;
-  return path14.posix.relative(prefix, toplevelRel);
+  return path15.posix.relative(prefix, toplevelRel);
 }
 async function gitHeadContent(root, toplevel, relPath) {
   const toplevelRel = toToplevelRelative(root, toplevel, relPath);
@@ -99039,7 +99271,7 @@ var EMBEDDED_WEB = {
 };
 
 // ../server/src/index.ts
-var VERSION2 = true ? "0.10.0" : "dev";
+var VERSION2 = true ? "0.11.0" : "dev";
 var PI_SDK_VERSION = true ? "0.84.1" : "dev";
 var LAUNCH_DIR = process.env.INIT_CWD ?? process.cwd();
 function complain(error) {
@@ -99073,6 +99305,21 @@ if (cli.command === "init") {
     process.exit(1);
   }
 }
+if (cli.command === "build-exe") {
+  try {
+    const built = buildExecutable({ out: cli.buildExe.out, force: cli.buildExe.force, cwd: LAUNCH_DIR });
+    console.log(`[pi] wrote ${built.path} (${built.method})
+[pi] run it: ${built.path}`);
+    process.exit(0);
+  } catch (error) {
+    if (error instanceof BuildExeError) {
+      console.error(`[pi] ${error.message}`);
+      process.exit(1);
+    }
+    complain(error);
+    process.exit(1);
+  }
+}
 var config = (() => {
   try {
     return loadConfig(LAUNCH_DIR, cli.flags);
@@ -99103,7 +99350,7 @@ var PORT = config.port;
 var HOST = config.host;
 var AGENT_CWD = config.cwd;
 var AGENT_DIR = config.agentDir ?? getAgentDir2();
-var SESSION_DIR = config.agentDir ? path15.join(config.agentDir, "sessions") : void 0;
+var SESSION_DIR = config.agentDir ? path16.join(config.agentDir, "sessions") : void 0;
 if (cli.command === "login") {
   try {
     if (!validProviderId(cli.login.provider)) {
@@ -99260,7 +99507,7 @@ app.get("/files/raw", async (req, reply) => {
     const bytes = await readFileRaw(BROWSER_ROOT, relPath, config.pdf.maxBytes);
     reply.header("X-Content-Type-Options", "nosniff");
     reply.header("Cache-Control", "no-store");
-    const contentType = IMAGE_CONTENT_TYPES[path15.extname(relPath).toLowerCase()];
+    const contentType = IMAGE_CONTENT_TYPES[path16.extname(relPath).toLowerCase()];
     if (contentType !== void 0) {
       if (contentType === "image/svg+xml") {
         reply.header("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'");
@@ -99279,27 +99526,27 @@ app.get("/files/raw", async (req, reply) => {
     throw error;
   }
 });
-var hasIndexHtml = (candidate) => fs13.stat(path15.join(candidate, "index.html")).then((s) => s.isFile()).catch(() => false);
-var skillRoots = [path15.resolve(import.meta.dirname, "./skills"), path15.resolve(import.meta.dirname, "../../skills")];
+var hasIndexHtml = (candidate) => fs14.stat(path16.join(candidate, "index.html")).then((s) => s.isFile()).catch(() => false);
+var skillRoots = [path16.resolve(import.meta.dirname, "./skills"), path16.resolve(import.meta.dirname, "../../skills")];
 var BUNDLED_SKILLS = [];
 for (const root of skillRoots) {
-  const entries = await fs13.readdir(root, { withFileTypes: true }).catch(() => []);
+  const entries = await fs14.readdir(root, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skill = path15.join(root, entry.name);
-    if (await fs13.stat(path15.join(skill, "SKILL.md")).then((file) => file.isFile()).catch(() => false)) {
+    const skill = path16.join(root, entry.name);
+    if (await fs14.stat(path16.join(skill, "SKILL.md")).then((file) => file.isFile()).catch(() => false)) {
       BUNDLED_SKILLS.push(skill);
     }
   }
   if (BUNDLED_SKILLS.length > 0) break;
 }
-var webDistCandidates = process.env.PI_OUTPOST_WEB_DIST ? [path15.resolve(process.env.PI_OUTPOST_WEB_DIST)] : [
+var webDistCandidates = process.env.PI_OUTPOST_WEB_DIST ? [path16.resolve(process.env.PI_OUTPOST_WEB_DIST)] : [
   // Prefer the production build (Vite output) over the source web/ directory,
   // which contains a Vite-dev index.html referencing /src/main.tsx — that file
   // would be served as application/octet-stream and fail ESM module loading.
-  path15.resolve(import.meta.dirname, "./web/dist"),
-  path15.resolve(import.meta.dirname, "./web"),
-  path15.resolve(import.meta.dirname, "../../web/dist")
+  path16.resolve(import.meta.dirname, "./web/dist"),
+  path16.resolve(import.meta.dirname, "./web"),
+  path16.resolve(import.meta.dirname, "../../web/dist")
 ];
 var WEB_DIST;
 for (const candidate of webDistCandidates) {
@@ -99331,7 +99578,17 @@ if (EMBEDDED_WEB && Object.keys(EMBEDDED_WEB).length > 0) {
   console.log(`[server] serving web UI from ${WEB_DIST}`);
 }
 await app.listen({ port: PORT, host: HOST });
-console.log(`[server] http://${HOST}:${PORT}/`);
+{
+  const bound = app.server.address();
+  const url = typeof bound === "object" && bound !== null ? browsableUrl(bound) : `http://${HOST}:${PORT}/`;
+  console.log(`[server] ${url}`);
+  const servesTheInterface = EMBEDDED_WEB && Object.keys(EMBEDDED_WEB).length > 0 || WEB_DIST !== void 0;
+  if (servesTheInterface && shouldOpenBrowser({ explicit: cli.open, configured: config.openBrowser })) {
+    void openBrowser(url).then((opened) => {
+      if (!opened) console.log(`[server] could not open a browser \u2014 open ${url} yourself`);
+    });
+  }
+}
 var WEB_UI_CONTEXT = [
   "You are running inside pi-outpost, a web chat UI \u2014 not a terminal.",
   "Replies render as markdown with syntax-highlighted code, LaTeX math and mermaid diagrams.",
@@ -99410,29 +99667,29 @@ var createRuntime = async ({
         customTools: [
           createPdfExtractToolDefinition({
             cwd,
-            allowedRoots: [await fs13.realpath(cwd)],
+            allowedRoots: [await fs14.realpath(cwd)],
             maxBytes: config.pdf.maxBytes,
             // No sandbox: anything under the workspace is writable, the same
             // rule writeFileFromBrowser applies to the browser's own writes.
-            writableRoot: await fs13.realpath(cwd)
+            writableRoot: await fs14.realpath(cwd)
           }),
           createDocxExtractToolDefinition({
             cwd,
-            allowedRoots: [await fs13.realpath(cwd)],
+            allowedRoots: [await fs14.realpath(cwd)],
             maxBytes: config.docx.maxBytes,
-            writableRoot: await fs13.realpath(cwd)
+            writableRoot: await fs14.realpath(cwd)
           }),
           createXlsxExtractToolDefinition({
             cwd,
-            allowedRoots: [await fs13.realpath(cwd)],
+            allowedRoots: [await fs14.realpath(cwd)],
             maxBytes: config.xlsx.maxBytes,
-            writableRoot: await fs13.realpath(cwd)
+            writableRoot: await fs14.realpath(cwd)
           }),
           createPptxExtractToolDefinition({
             cwd,
-            allowedRoots: [await fs13.realpath(cwd)],
+            allowedRoots: [await fs14.realpath(cwd)],
             maxBytes: config.pptx.maxBytes,
-            writableRoot: await fs13.realpath(cwd)
+            writableRoot: await fs14.realpath(cwd)
           }),
           structuredExchangeTool
         ]
@@ -99551,11 +99808,11 @@ function snapshot() {
   };
 }
 var clients = /* @__PURE__ */ new Set();
-var WS_LOG_PATH = process.env.WS_LOG_PATH ? path15.resolve(process.env.WS_LOG_PATH) : void 0;
+var WS_LOG_PATH = process.env.WS_LOG_PATH ? path16.resolve(process.env.WS_LOG_PATH) : void 0;
 function broadcast(message) {
   const data = JSON.stringify(message);
   if (WS_LOG_PATH) {
-    fs13.appendFile(WS_LOG_PATH, data + "\n").catch(() => {
+    fs14.appendFile(WS_LOG_PATH, data + "\n").catch(() => {
     });
   }
   for (const socket of clients) {
@@ -99565,7 +99822,7 @@ function broadcast(message) {
 function send(socket, message) {
   const data = JSON.stringify(message);
   if (WS_LOG_PATH) {
-    fs13.appendFile(WS_LOG_PATH, data + "\n").catch(() => {
+    fs14.appendFile(WS_LOG_PATH, data + "\n").catch(() => {
     });
   }
   if (socket.readyState === socket.OPEN) socket.send(data);
@@ -99587,12 +99844,12 @@ async function announceFileChange(args) {
   console.log("[announceFileChange] args type=", typeof args, "targetPath=", targetPath);
   if (typeof targetPath !== "string") return;
   try {
-    const resolved = await realResolve(path15.resolve(BROWSER_ROOT, targetPath));
+    const resolved = await realResolve(path16.resolve(BROWSER_ROOT, targetPath));
     if (!isWithin(BROWSER_ROOT, resolved)) {
       console.log("[announceFileChange] not within BROWSER_ROOT, skipping");
       return;
     }
-    const relPath = path15.relative(BROWSER_ROOT, resolved).split(path15.sep).join("/");
+    const relPath = path16.relative(BROWSER_ROOT, resolved).split(path16.sep).join("/");
     console.log("[announceFileChange] broadcasting file_changed path=", relPath);
     broadcast({ type: "file_changed", path: relPath });
   } catch (e) {
@@ -99886,12 +100143,12 @@ async function editPrompt(socket, entryId, text, images) {
   }
   await handlePrompt(text, images);
 }
-async function isKnownSessionPath(path16) {
+async function isKnownSessionPath(path17) {
   const sessions = await SessionManager.list(AGENT_CWD, SESSION_DIR);
-  return sessions.some((info2) => info2.path === path16);
+  return sessions.some((info2) => info2.path === path17);
 }
-async function deleteSession(socket, path16) {
-  const live = liveSessionMatch(path16);
+async function deleteSession(socket, path17) {
+  const live = liveSessionMatch(path17);
   if (live === "live") {
     send(socket, { type: "error", message: "Cannot delete the active session" });
     return;
@@ -99900,20 +100157,20 @@ async function deleteSession(socket, path16) {
     send(socket, { type: "error", message: `${UNKNOWN_LIVE_SESSION} \u2014 deleting it could remove the running conversation` });
     return;
   }
-  if (!await isKnownSessionPath(path16)) {
+  if (!await isKnownSessionPath(path17)) {
     send(socket, { type: "error", message: "Unknown session" });
     return;
   }
-  await fs13.unlink(path16);
+  await fs14.unlink(path17);
   invalidateSessionScan();
   await listSessions(socket);
 }
-async function switchSession(socket, path16) {
-  if (!await isKnownSessionPath(path16)) {
+async function switchSession(socket, path17) {
+  if (!await isKnownSessionPath(path17)) {
     send(socket, { type: "error", message: "Unknown session" });
     return;
   }
-  await replaceSession(socket, () => runtime.switchSession(path16));
+  await replaceSession(socket, () => runtime.switchSession(path17));
 }
 var SESSION_LIST_LIMIT = 50;
 var SESSION_SCAN_TTL_MS = 1e3;
@@ -99937,13 +100194,13 @@ async function listSessions(socket) {
 async function broadcastSessions() {
   broadcast({ type: "sessions", sessions: await sessionList() });
 }
-async function renameSession(socket, path16, rawName) {
-  if (!await isKnownSessionPath(path16)) {
+async function renameSession(socket, path17, rawName) {
+  if (!await isKnownSessionPath(path17)) {
     send(socket, { type: "error", message: "Unknown session" });
     return;
   }
   const name = sanitizeName(rawName);
-  const live = liveSessionMatch(path16);
+  const live = liveSessionMatch(path17);
   if (live === "unknown") {
     send(socket, { type: "error", message: `${UNKNOWN_LIVE_SESSION} \u2014 renaming could corrupt the running conversation` });
     return;
@@ -99951,7 +100208,7 @@ async function renameSession(socket, path16, rawName) {
   if (live === "live") {
     await runtime.setSessionName(name);
   } else {
-    SessionManager.open(path16, SESSION_DIR, AGENT_CWD).appendSessionInfo(name);
+    SessionManager.open(path17, SESSION_DIR, AGENT_CWD).appendSessionInfo(name);
   }
   invalidateSessionScan();
   await broadcastSessions();
@@ -99959,7 +100216,7 @@ async function renameSession(socket, path16, rawName) {
 function liveSessionMatch(candidate) {
   const live = runtime.snapshot().sessionFile;
   if (live === void 0) return "unknown";
-  return path15.resolve(candidate) === path15.resolve(live) ? "live" : "not-live";
+  return path16.resolve(candidate) === path16.resolve(live) ? "live" : "not-live";
 }
 var UNKNOWN_LIVE_SESSION = "The agent runtime does not report which session file it is using, so this cannot be done safely";
 async function handleSearchSessions(socket, query, requestId) {