@parall/daemon 1.44.0 → 1.45.0

package/bundle/parall-daemon.js

@@ -646,7 +646,7 @@ var init_client = __esm({
         return apiError;
       }
       /** Build headers common to all requests (auth, swimlane). */
-      buildHeaders(path19, extra) {
+      buildHeaders(path21, extra) {
         const headers = {
           "Content-Type": "application/json",
           ...extra
@@ -657,7 +657,7 @@ var init_client = __esm({
         if (this.swimlaneName) {
           headers["X-Prll-Swimlane"] = this.swimlaneName;
         }
-        if (path19.startsWith(API_BASE)) {
+        if (path21.startsWith(API_BASE)) {
           const overrides = this.getFeatureFlagOverrides?.();
           if (overrides)
             headers["X-Prll-FF-Override"] = overrides;
@@ -680,8 +680,8 @@ var init_client = __esm({
        * is authoritative, so wiki vs api routing can't drift from how a caller
        * happens to invoke the client.
        */
-      baseUrlFor(path19) {
-        return path19.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
+      baseUrlFor(path21) {
+        return path21.startsWith(WIKI_BASE) ? this.wikiBaseUrl : this.baseUrl;
       }
       setToken(token) {
         this.token = token;
@@ -708,10 +708,10 @@ var init_client = __esm({
        * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
        * No-op when the token is still fresh, missing, or un-parseable.
        */
-      async ensureFreshToken(path19) {
+      async ensureFreshToken(path21) {
         if (!this.token || !this.getRefreshToken)
           return;
-        const pathSuffix = path19.replace(/^\/api\/v1/, "");
+        const pathSuffix = path21.replace(/^\/api\/v1/, "");
         if (_ParallClient.AUTH_PATHS.has(pathSuffix))
           return;
         const exp = _ParallClient.decodeJwtExp(this.token);
@@ -743,11 +743,11 @@ var init_client = __esm({
           this.refreshPromise = null;
         }
       }
-      async request(method, path19, body, query, retried = false, opts) {
+      async request(method, path21, body, query, retried = false, opts) {
         if (!retried) {
-          await this.ensureFreshToken(path19);
+          await this.ensureFreshToken(path21);
         }
-        let url = `${this.baseUrlFor(path19)}${path19}`;
+        let url = `${this.baseUrlFor(path21)}${path21}`;
         if (query) {
           const params = new URLSearchParams();
           for (const [key, value] of Object.entries(query)) {
@@ -759,7 +759,7 @@ var init_client = __esm({
           if (qs)
             url += `?${qs}`;
         }
-        const headers = this.buildHeaders(path19);
+        const headers = this.buildHeaders(path21);
         const timeoutSignal = AbortSignal.timeout(opts?.timeoutMs ?? 15e3);
         const signal = opts?.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
         let res;
@@ -777,12 +777,12 @@ var init_client = __esm({
           throw _ParallClient.normalizeFetchError(err);
         }
         if (res.status === 401) {
-          const pathSuffix = path19.replace(/^\/api\/v1/, "");
+          const pathSuffix = path21.replace(/^\/api\/v1/, "");
           const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
           if (!retried && !isAuthPath && this.getRefreshToken) {
             const refreshed = await this.tryRefresh();
             if (refreshed) {
-              return this.request(method, path19, body, query, true, opts);
+              return this.request(method, path21, body, query, true, opts);
             }
           }
           if (this.onTokenExpired && !isAuthPath) {
@@ -812,15 +812,15 @@ var init_client = __esm({
        * hit the 100 MiB cap, so a longer 5-minute timeout is used so a
        * 50 MiB blob on a slow connection doesn't get chopped at 15 s.
        */
-      async multipartRequest(method, path19, body, retried = false) {
+      async multipartRequest(method, path21, body, retried = false) {
         if (!retried) {
-          await this.ensureFreshToken(path19);
+          await this.ensureFreshToken(path21);
         }
-        const { "Content-Type": _drop, ...headers } = this.buildHeaders(path19);
+        const { "Content-Type": _drop, ...headers } = this.buildHeaders(path21);
         void _drop;
         let res;
         try {
-          res = await fetch(`${this.baseUrlFor(path19)}${path19}`, {
+          res = await fetch(`${this.baseUrlFor(path21)}${path21}`, {
             method,
             headers,
             body,
@@ -830,12 +830,12 @@ var init_client = __esm({
           throw _ParallClient.normalizeFetchError(err);
         }
         if (res.status === 401) {
-          const pathSuffix = path19.replace(/^\/api\/v1/, "");
+          const pathSuffix = path21.replace(/^\/api\/v1/, "");
           const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
           if (!retried && !isAuthPath && this.getRefreshToken) {
             const refreshed = await this.tryRefresh();
             if (refreshed) {
-              return this.multipartRequest(method, path19, body, true);
+              return this.multipartRequest(method, path21, body, true);
             }
           }
           if (this.onTokenExpired && !isAuthPath) {
@@ -1539,8 +1539,8 @@ var init_client = __esm({
       async requestMachineUpdate(orgId, machineId, mandatory = false) {
         await this.request("POST", ENDPOINTS.MACHINE_REQUEST_UPDATE(orgId, machineId), { mandatory });
       }
-      async browseMachineFilesystem(orgId, machineId, path19) {
-        return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path19 }, void 0, false, { timeoutMs: 15e3 });
+      async browseMachineFilesystem(orgId, machineId, path21) {
+        return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path21 }, void 0, false, { timeoutMs: 15e3 });
       }
       /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
       async createMachineKey(orgId, machineId, name) {
@@ -2112,8 +2112,8 @@ var init_client = __esm({
       async deleteWikiRestriction(orgId, wikiId, restrictionId) {
         await this.request("DELETE", ENDPOINTS.WIKI_RESTRICTION(orgId, wikiId, restrictionId));
       }
-      async getWikiAccessStatus(orgId, wikiId, path19) {
-        return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path19 ? { path: path19 } : void 0);
+      async getWikiAccessStatus(orgId, wikiId, path21) {
+        return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path21 ? { path: path21 } : void 0);
       }
       async createWikiAccessRequest(orgId, wikiId, data) {
         await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -2122,14 +2122,14 @@ var init_client = __esm({
       async getWikiCommits(orgId, wikiId, params) {
         return this.request("GET", ENDPOINTS.WIKI_COMMITS(orgId, wikiId), void 0, params);
       }
-      async getWikiFileCommits(orgId, wikiId, path19, params) {
+      async getWikiFileCommits(orgId, wikiId, path21, params) {
         return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, {
-          path: path19,
+          path: path21,
           ...params
         });
       }
-      async getWikiBlame(orgId, wikiId, path19, ref) {
-        return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path19, ref });
+      async getWikiBlame(orgId, wikiId, path21, ref) {
+        return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path21, ref });
       }
       // ---- Wiki Operations (audit log) ----
       async getWikiOperations(orgId, wikiId, params) {
@@ -2781,6 +2781,7 @@ var TYPED_BACKOFF_CAP_MS;
 var init_gateway_lane_flow = __esm({
   "ts/agent-core/dist/gateway-lane-flow.js"() {
     "use strict";
+    init_dist();
     init_lane_ledger();
     TYPED_BACKOFF_CAP_MS = 5 * 6e4;
   }
@@ -4784,11 +4785,11 @@ var init_bounded_queue_export_promise_handler = __esm({
   "ts/node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.57.2_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js"() {
     __awaiter = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -4804,7 +4805,7 @@ var init_bounded_queue_export_promise_handler = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -8442,8 +8443,8 @@ var require_promise = __commonJS({
     exports2.Deferred = void 0;
     var Deferred = class {
       constructor() {
-        this._promise = new Promise((resolve8, reject) => {
-          this._resolve = resolve8;
+        this._promise = new Promise((resolve9, reject) => {
+          this._resolve = resolve9;
           this._reject = reject;
         });
       }
@@ -8506,10 +8507,10 @@ var require_exporter = __commonJS({
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     var suppress_tracing_1 = require_suppress_tracing();
     function _export(exporter, arg) {
-      return new Promise((resolve8) => {
+      return new Promise((resolve9) => {
         api_1.context.with((0, suppress_tracing_1.suppressTracing)(api_1.context.active()), () => {
           exporter.export(arg, (result) => {
-            resolve8(result);
+            resolve9(result);
           });
         });
       });
@@ -8784,11 +8785,11 @@ var init_otlp_export_delegate = __esm({
     init_esm();
     __awaiter2 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -8804,7 +8805,7 @@ var init_otlp_export_delegate = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -9015,7 +9016,7 @@ var require_aspromise = __commonJS({
       var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
       while (index < arguments.length)
         params[offset++] = arguments[index++];
-      return new Promise(function executor(resolve8, reject) {
+      return new Promise(function executor(resolve9, reject) {
         params[offset] = function callback(err) {
           if (pending) {
             pending = false;
@@ -9025,7 +9026,7 @@ var require_aspromise = __commonJS({
               var params2 = new Array(arguments.length - 1), offset2 = 0;
               while (offset2 < params2.length)
                 params2[offset2++] = arguments[offset2];
-              resolve8.apply(null, params2);
+              resolve9.apply(null, params2);
             }
           }
         };
@@ -20522,9 +20523,9 @@ var require_getMachineId_linux = __commonJS({
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     async function getMachineId() {
       const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
-      for (const path19 of paths) {
+      for (const path21 of paths) {
         try {
-          const result = await fs_1.promises.readFile(path19, { encoding: "utf8" });
+          const result = await fs_1.promises.readFile(path21, { encoding: "utf8" });
           return result.trim();
         } catch (e) {
           api_1.diag.debug(`error reading machine id: ${e}`);
@@ -23454,11 +23455,11 @@ var init_http_exporter_transport = __esm({
   "ts/node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.57.2_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js"() {
     __awaiter3 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -23474,7 +23475,7 @@ var init_http_exporter_transport = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -23565,10 +23566,10 @@ var init_http_exporter_transport = __esm({
               this._agent = createHttpAgent2(this._parameters.url, this._parameters.agentOptions);
               this._send = sendWithHttp2;
             }
-            return [2, new Promise(function(resolve8) {
+            return [2, new Promise(function(resolve9) {
               var _a2;
               (_a2 = _this._send) === null || _a2 === void 0 ? void 0 : _a2.call(_this, _this._parameters, _this._agent, data, function(result) {
-                resolve8(result);
+                resolve9(result);
               }, timeoutMillis);
             })];
           });
@@ -23593,11 +23594,11 @@ var init_retrying_transport = __esm({
   "ts/node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.57.2_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js"() {
     __awaiter4 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -23613,7 +23614,7 @@ var init_retrying_transport = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -23699,9 +23700,9 @@ var init_retrying_transport = __esm({
       }
       RetryingTransport2.prototype.retry = function(data, timeoutMillis, inMillis) {
         var _this = this;
-        return new Promise(function(resolve8, reject) {
+        return new Promise(function(resolve9, reject) {
           setTimeout(function() {
-            _this._transport.send(data, timeoutMillis).then(resolve8, reject);
+            _this._transport.send(data, timeoutMillis).then(resolve9, reject);
           }, inMillis);
         });
       };
@@ -23927,7 +23928,7 @@ function appendRootPathToUrlIfNeeded(url) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url, path19) {
+function appendResourcePathToUrl(url, path21) {
   try {
     new URL(url);
   } catch (_a) {
@@ -23937,11 +23938,11 @@ function appendResourcePathToUrl(url, path19) {
   if (!url.endsWith("/")) {
     url = url + "/";
   }
-  url += path19;
+  url += path21;
   try {
     new URL(url);
   } catch (_b) {
-    diag2.warn("Configuration: Provided URL appended with '" + path19 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
+    diag2.warn("Configuration: Provided URL appended with '" + path21 + "' is not a valid URL, using 'undefined' instead of '" + url + "'");
     return void 0;
   }
   return url;
@@ -25610,14 +25611,14 @@ var require_BatchSpanProcessorBase = __commonJS({
        * for all other cases _flush should be used
        * */
       _flushAll() {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           const promises = [];
           const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
           for (let i = 0, j = count; i < j; i++) {
             promises.push(this._flushOneBatch());
           }
           Promise.all(promises).then(() => {
-            resolve8();
+            resolve9();
           }).catch(reject);
         });
       }
@@ -25626,7 +25627,7 @@ var require_BatchSpanProcessorBase = __commonJS({
         if (this._finishedSpans.length === 0) {
           return Promise.resolve();
         }
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           const timer = setTimeout(() => {
             reject(new Error("Timeout"));
           }, this._exportTimeoutMillis);
@@ -25642,7 +25643,7 @@ var require_BatchSpanProcessorBase = __commonJS({
               var _a;
               clearTimeout(timer);
               if (result.code === core_1.ExportResultCode.SUCCESS) {
-                resolve8();
+                resolve9();
               } else {
                 reject((_a = result.error) !== null && _a !== void 0 ? _a : new Error("BatchSpanProcessor: span export failed"));
               }
@@ -25909,12 +25910,12 @@ var require_MultiSpanProcessor = __commonJS({
         for (const spanProcessor of this._spanProcessors) {
           promises.push(spanProcessor.forceFlush());
         }
-        return new Promise((resolve8) => {
+        return new Promise((resolve9) => {
           Promise.all(promises).then(() => {
-            resolve8();
+            resolve9();
           }).catch((error) => {
             (0, core_1.globalErrorHandler)(error || new Error("MultiSpanProcessor: forceFlush failed"));
-            resolve8();
+            resolve9();
           });
         });
       }
@@ -25933,9 +25934,9 @@ var require_MultiSpanProcessor = __commonJS({
         for (const spanProcessor of this._spanProcessors) {
           promises.push(spanProcessor.shutdown());
         }
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           Promise.all(promises).then(() => {
-            resolve8();
+            resolve9();
           }, reject);
         });
       }
@@ -26058,32 +26059,32 @@ var require_BasicTracerProvider = __commonJS({
       forceFlush() {
         const timeout = this._config.forceFlushTimeoutMillis;
         const promises = this._registeredSpanProcessors.map((spanProcessor) => {
-          return new Promise((resolve8) => {
+          return new Promise((resolve9) => {
             let state;
             const timeoutInterval = setTimeout(() => {
-              resolve8(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+              resolve9(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
               state = ForceFlushState.timeout;
             }, timeout);
             spanProcessor.forceFlush().then(() => {
               clearTimeout(timeoutInterval);
               if (state !== ForceFlushState.timeout) {
                 state = ForceFlushState.resolved;
-                resolve8(state);
+                resolve9(state);
               }
             }).catch((error) => {
               clearTimeout(timeoutInterval);
               state = ForceFlushState.error;
-              resolve8(error);
+              resolve9(error);
             });
           });
         });
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           Promise.all(promises).then((results) => {
             const errors = results.filter((result) => result !== ForceFlushState.resolved);
             if (errors.length > 0) {
               reject(errors);
             } else {
-              resolve8();
+              resolve9();
             }
           }).catch((error) => reject([error]));
         });
@@ -29102,14 +29103,14 @@ var require_BatchLogRecordProcessorBase = __commonJS({
        * for all other cases _flush should be used
        * */
       _flushAll() {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           const promises = [];
           const batchCount = Math.ceil(this._finishedLogRecords.length / this._maxExportBatchSize);
           for (let i = 0; i < batchCount; i++) {
             promises.push(this._flushOneBatch());
           }
           Promise.all(promises).then(() => {
-            resolve8();
+            resolve9();
           }).catch(reject);
         });
       }
@@ -29118,8 +29119,8 @@ var require_BatchLogRecordProcessorBase = __commonJS({
         if (this._finishedLogRecords.length === 0) {
           return Promise.resolve();
         }
-        return new Promise((resolve8, reject) => {
-          (0, core_1.callWithTimeout)(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis).then(() => resolve8()).catch(reject);
+        return new Promise((resolve9, reject) => {
+          (0, core_1.callWithTimeout)(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis).then(() => resolve9()).catch(reject);
         });
       }
       _maybeStartTimer() {
@@ -29639,6 +29640,329 @@ var init_config = __esm({
   }
 });
 
+// ts/daemon/dist/win-service.js
+import * as path4 from "node:path";
+function winServicePaths(home) {
+  const root = path4.join(home, ".parall-daemon");
+  const serviceDir = path4.join(root, "service");
+  const logDir = path4.join(root, "logs");
+  return {
+    serviceDir,
+    launcherCjs: path4.join(serviceDir, "parall-daemon-launcher.cjs"),
+    legacyLauncherJs: path4.join(serviceDir, "parall-daemon-launcher.js"),
+    launcherVbs: path4.join(serviceDir, "parall-daemon-launcher.vbs"),
+    taskXml: path4.join(serviceDir, "task.xml"),
+    pidFile: path4.join(root, "daemon.pid"),
+    logDir,
+    logFile: path4.join(logDir, "parall-daemon.log"),
+    overlayEntry: path4.join(root, "bundle", "current", "parall-daemon.js"),
+    runningMarker: path4.join(root, "bundle", "daemon-running")
+  };
+}
+function vbsQuote(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function encodeUtf16LeBom(content) {
+  return Buffer.from("\uFEFF" + content, "utf16le");
+}
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function buildLauncherVbs(p) {
+  const runCommand2 = `"${p.nodeExe}" "${p.launcherCjs}"`;
+  return [
+    "' generated by `parall-daemon service install` - do not edit",
+    'Set sh = CreateObject("WScript.Shell")',
+    `code = sh.Run(${vbsQuote(runCommand2)}, 0, True)`,
+    "WScript.Quit code",
+    ""
+  ].join("\r\n");
+}
+function buildLauncherCjs(p) {
+  return `// generated by \`parall-daemon service install\` - do not edit
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+// Must be set before the daemon loads: the bootstrap reads it at import time
+// to enable supervised self-update.
+process.env.PRLL_DAEMON_MANAGED = '1';
+
+const OVERLAY_ENTRY = ${JSON.stringify(p.overlayEntry)};
+const NPM_ENTRY = ${JSON.stringify(p.npmEntry)};
+const LOG_FILE = ${JSON.stringify(p.logFile)};
+const PID_FILE = ${JSON.stringify(p.pidFile)};
+
+fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+try {
+  if (fs.statSync(LOG_FILE).size > 20 * 1024 * 1024) {
+    fs.renameSync(LOG_FILE, LOG_FILE + '.old');
+  }
+} catch {}
+
+// Synchronous writes so an abrupt exit (self-update exit(42), crash) cannot
+// lose the log tail. The daemon is not chatty enough for this to matter.
+const logFd = fs.openSync(LOG_FILE, 'a');
+for (const stream of [process.stdout, process.stderr]) {
+  stream.write = (chunk, encoding, callback) => {
+    try {
+      fs.writeSync(
+        logFd,
+        Buffer.isBuffer(chunk)
+          ? chunk
+          : Buffer.from(chunk, typeof encoding === 'string' ? encoding : 'utf8'),
+      );
+    } catch {}
+    const done = typeof encoding === 'function' ? encoding : callback;
+    if (done) done();
+    return true;
+  };
+}
+
+fs.writeFileSync(PID_FILE, String(process.pid));
+process.on('exit', () => {
+  try {
+    if (fs.readFileSync(PID_FILE, 'utf8').trim() === String(process.pid)) {
+      fs.unlinkSync(PID_FILE);
+    }
+  } catch {}
+});
+
+// Overlay-first, mirroring the launchd/systemd wrapper semantics.
+const entry = fs.existsSync(OVERLAY_ENTRY) ? OVERLAY_ENTRY : NPM_ENTRY;
+// The daemon derives bridge-bundle siblings and self-update mode from its
+// entry path - argv[1] must point at the real bundle entry, not this file.
+process.argv[1] = entry;
+import(pathToFileURL(entry).href).catch((err) => {
+  process.stderr.write('launcher: failed to load ' + entry + ': ' + ((err && err.stack) || err) + '\\n');
+  process.exit(1);
+});
+`;
+}
+function buildTaskXml(p) {
+  const args = `//B //Nologo "${p.launcherVbs}"`;
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Parall Daemon (BYOC machine supervisor)</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+    <TimeTrigger>
+      <StartBoundary>2020-01-01T00:00:00</StartBoundary>
+      <Enabled>true</Enabled>
+      <Repetition>
+        <Interval>PT1H</Interval>
+      </Repetition>
+    </TimeTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>99</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xmlEscape(p.wscriptExe)}</Command>
+      <Arguments>${xmlEscape(args)}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+var WIN_TASK_NAME;
+var init_win_service = __esm({
+  "ts/daemon/dist/win-service.js"() {
+    "use strict";
+    WIN_TASK_NAME = "ParallDaemon";
+  }
+});
+
+// ts/daemon/dist/win-lifecycle.js
+import * as path5 from "node:path";
+function probePidIdentity(deps, pid) {
+  const script = `$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; if ($null -eq $p) { 'ABSENT' } else { 'PRESENT' + [char]9 + $p.Name + [char]9 + "$($p.CommandLine)" }`;
+  const r = deps.run("powershell.exe", ["-NoProfile", "-Command", script]);
+  if (r.code !== 0 || r.spawnError)
+    return "indeterminate";
+  const out = r.stdout.trim();
+  if (out === "ABSENT")
+    return "not-daemon";
+  if (!out.startsWith("PRESENT	"))
+    return "indeterminate";
+  const [, name = "", ...rest] = out.split("	");
+  const commandLine = rest.join("	").trim();
+  if (!/node/i.test(name))
+    return "not-daemon";
+  if (!commandLine) {
+    return "indeterminate";
+  }
+  const launcherNeedle = path5.join(deps.paths.serviceDir, "parall-daemon-launcher").toLowerCase();
+  return commandLine.toLowerCase().includes(launcherNeedle) ? "daemon" : "not-daemon";
+}
+function readTrackedPid(deps) {
+  const raw = deps.fs.readFile(deps.paths.pidFile);
+  if (raw === null)
+    return null;
+  const pid = Number(raw.trim());
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function queryTaskExists(deps) {
+  const script = `try { Get-ScheduledTask -TaskName '${WIN_TASK_NAME}' -ErrorAction Stop | Out-Null; 'PRESENT' } catch { if ($_.CategoryInfo.Category -eq 'ObjectNotFound') { 'ABSENT' } else { 'ERROR' } }`;
+  const r = deps.run("powershell.exe", ["-NoProfile", "-Command", script]);
+  if (r.code !== 0 || r.spawnError)
+    return "indeterminate";
+  const out = r.stdout.trim();
+  if (out === "PRESENT")
+    return true;
+  if (out === "ABSENT")
+    return false;
+  return "indeterminate";
+}
+function queryTaskDisabled(deps) {
+  const r = deps.run("schtasks", ["/Query", "/TN", WIN_TASK_NAME, "/XML"]);
+  if (r.code !== 0 || r.spawnError)
+    return "indeterminate";
+  return /<Enabled>\s*false\s*<\/Enabled>/i.test(r.stdout);
+}
+function confirmProcessGone(deps, problems) {
+  const pid = readTrackedPid(deps);
+  if (pid === null)
+    return true;
+  let identity = probePidIdentity(deps, pid);
+  if (identity === "not-daemon")
+    return true;
+  if (identity === "indeterminate") {
+    problems.push(`cannot verify ownership of pid ${pid} (process query failed) \u2014 leaving the pidfile in place`);
+    return false;
+  }
+  const kill = deps.run("taskkill", ["/T", "/F", "/PID", String(pid)]);
+  const deadline = deps.now() + PROCESS_EXIT_TIMEOUT_MS;
+  for (; ; ) {
+    identity = probePidIdentity(deps, pid);
+    if (identity === "not-daemon")
+      return true;
+    if (identity === "indeterminate") {
+      problems.push(`process query failed while confirming pid ${pid} exited`);
+      return false;
+    }
+    if (deps.now() >= deadline) {
+      problems.push(`daemon process ${pid} is still running after taskkill` + (kill.code !== 0 ? ` (taskkill exit ${kill.code ?? "spawn-failed"})` : ""));
+      return false;
+    }
+    deps.sleep(PROCESS_EXIT_POLL_MS);
+  }
+}
+function cleanupTracking(deps, problems) {
+  if (!deps.fs.unlink(deps.paths.pidFile)) {
+    problems.push(`could not remove pidfile ${deps.paths.pidFile}`);
+  }
+  if (!deps.fs.unlink(deps.paths.runningMarker)) {
+    problems.push(`could not remove crash marker ${deps.paths.runningMarker}`);
+  }
+}
+function stopDaemonWindows(deps) {
+  const problems = [];
+  const exists = queryTaskExists(deps);
+  if (exists === "indeterminate") {
+    problems.push("schtasks could not be executed to query the task");
+    return { ok: false, problems };
+  }
+  if (exists) {
+    const disable = deps.run("schtasks", ["/Change", "/TN", WIN_TASK_NAME, "/DISABLE"]);
+    if (disable.code !== 0) {
+      problems.push(`could not disable the task (schtasks /Change exit ${disable.code ?? "spawn-failed"})`);
+      return { ok: false, problems };
+    }
+    const disabled = queryTaskDisabled(deps);
+    if (disabled !== true) {
+      problems.push(disabled === "indeterminate" ? "could not read back the task state after disabling" : "task did not read back as disabled");
+      return { ok: false, problems };
+    }
+    deps.run("schtasks", ["/End", "/TN", WIN_TASK_NAME]);
+  }
+  if (!confirmProcessGone(deps, problems)) {
+    return { ok: false, problems };
+  }
+  cleanupTracking(deps, problems);
+  return { ok: problems.length === 0, problems };
+}
+function uninstallDaemonWindows(deps) {
+  const problems = [];
+  const exists = queryTaskExists(deps);
+  if (exists === "indeterminate") {
+    problems.push("schtasks could not be executed to query the task");
+    return { ok: false, problems };
+  }
+  if (exists) {
+    const disable = deps.run("schtasks", ["/Change", "/TN", WIN_TASK_NAME, "/DISABLE"]);
+    if (disable.code !== 0) {
+      problems.push(`could not disable the task before uninstalling (schtasks /Change exit ${disable.code ?? "spawn-failed"})`);
+      return { ok: false, problems };
+    }
+    const disabled = queryTaskDisabled(deps);
+    if (disabled !== true) {
+      problems.push(disabled === "indeterminate" ? "could not read back the task state after disabling" : "task did not read back as disabled before uninstall");
+      return { ok: false, problems };
+    }
+    deps.run("schtasks", ["/End", "/TN", WIN_TASK_NAME]);
+  }
+  if (!confirmProcessGone(deps, problems)) {
+    return { ok: false, problems };
+  }
+  if (exists) {
+    const del = deps.run("schtasks", ["/Delete", "/TN", WIN_TASK_NAME, "/F"]);
+    if (del.code !== 0) {
+      problems.push(`could not delete the task (schtasks /Delete exit ${del.code ?? "spawn-failed"})`);
+      return { ok: false, problems };
+    }
+    const stillThere = queryTaskExists(deps);
+    if (stillThere !== false) {
+      problems.push(stillThere === "indeterminate" ? "could not confirm the task was deleted" : "task is still registered after /Delete");
+      return { ok: false, problems };
+    }
+  }
+  cleanupTracking(deps, problems);
+  for (const artifact of [
+    deps.paths.launcherCjs,
+    deps.paths.legacyLauncherJs,
+    deps.paths.launcherVbs,
+    deps.paths.taskXml
+  ]) {
+    if (!deps.fs.unlink(artifact)) {
+      problems.push(`could not remove ${artifact}`);
+    }
+  }
+  return { ok: problems.length === 0, problems };
+}
+var PROCESS_EXIT_TIMEOUT_MS, PROCESS_EXIT_POLL_MS;
+var init_win_lifecycle = __esm({
+  "ts/daemon/dist/win-lifecycle.js"() {
+    "use strict";
+    init_win_service();
+    PROCESS_EXIT_TIMEOUT_MS = 5e3;
+    PROCESS_EXIT_POLL_MS = 200;
+  }
+});
+
 // ts/daemon/dist/updater-manifest.js
 import { verify } from "node:crypto";
 function canonicalize(obj) {
@@ -29739,7 +30063,7 @@ __export(updater_exports, {
   DaemonUpdater: () => DaemonUpdater
 });
 import * as fs2 from "node:fs";
-import * as path4 from "node:path";
+import * as path6 from "node:path";
 import * as https2 from "node:https";
 import * as http2 from "node:http";
 import { createHash } from "node:crypto";
@@ -29835,20 +30159,20 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
           return false;
         if (!state.previous_version)
           return false;
-        const previousDir = path4.join(this.bundleDir, "versions", state.previous_version);
+        const previousDir = path6.join(this.bundleDir, "versions", state.previous_version);
         if (!fs2.existsSync(previousDir))
           return false;
         this.log.warn(`rollback: ${current.version} failed ${state.boot_count} boots, reverting to ${state.previous_version}`);
         if (process.platform === "win32") {
-          const currentDir = path4.join(this.bundleDir, "current");
+          const currentDir = path6.join(this.bundleDir, "current");
           if (fs2.existsSync(currentDir)) {
             for (const file of fs2.readdirSync(currentDir)) {
-              fs2.unlinkSync(path4.join(currentDir, file));
+              fs2.unlinkSync(path6.join(currentDir, file));
             }
           }
           fs2.mkdirSync(currentDir, { recursive: true });
           for (const file of fs2.readdirSync(previousDir)) {
-            fs2.copyFileSync(path4.join(previousDir, file), path4.join(currentDir, file));
+            fs2.copyFileSync(path6.join(previousDir, file), path6.join(currentDir, file));
           }
         } else {
           this.swapSymlink(state.previous_version);
@@ -29970,11 +30294,11 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             return false;
           }
         }
-        const stagingDir = path4.join(this.bundleDir, "staging");
+        const stagingDir = path6.join(this.bundleDir, "staging");
         this.cleanDir(stagingDir);
         fs2.mkdirSync(stagingDir, { recursive: true });
         for (const [filename, meta] of Object.entries(remote.files)) {
-          const filePath = path4.join(stagingDir, filename);
+          const filePath = path6.join(stagingDir, filename);
           const fileUrl = `${this.cdnBaseUrl}/${remote.version}/${filename}`;
           try {
             await this.downloadFile(fileUrl, filePath);
@@ -29996,7 +30320,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             return false;
           }
         }
-        fs2.writeFileSync(path4.join(stagingDir, "manifest.json"), JSON.stringify(remote, null, 2));
+        fs2.writeFileSync(path6.join(stagingDir, "manifest.json"), JSON.stringify(remote, null, 2));
         const rollbackVersion = state?.confirmed_version ?? local?.version;
         const newState = {
           confirmed_version: rollbackVersion,
@@ -30011,9 +30335,9 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         return true;
       }
       atomicSwap(stagingDir, newVersion) {
-        const versionsDir = path4.join(this.bundleDir, "versions");
-        const targetDir = path4.join(versionsDir, newVersion);
-        const currentLink = path4.join(this.bundleDir, "current");
+        const versionsDir = path6.join(this.bundleDir, "versions");
+        const targetDir = path6.join(versionsDir, newVersion);
+        const currentLink = path6.join(this.bundleDir, "current");
         fs2.mkdirSync(versionsDir, { recursive: true });
         if (fs2.existsSync(targetDir)) {
           fs2.rmSync(targetDir, { recursive: true });
@@ -30023,12 +30347,12 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
           const currentDir = currentLink;
           if (fs2.existsSync(currentDir)) {
             for (const file of fs2.readdirSync(currentDir)) {
-              fs2.unlinkSync(path4.join(currentDir, file));
+              fs2.unlinkSync(path6.join(currentDir, file));
             }
           }
           fs2.mkdirSync(currentDir, { recursive: true });
           for (const file of fs2.readdirSync(targetDir)) {
-            fs2.copyFileSync(path4.join(targetDir, file), path4.join(currentDir, file));
+            fs2.copyFileSync(path6.join(targetDir, file), path6.join(currentDir, file));
           }
         } else {
           this.swapSymlink(newVersion);
@@ -30036,7 +30360,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         this.pruneOldVersions(versionsDir, newVersion);
       }
       swapSymlink(version) {
-        const currentLink = path4.join(this.bundleDir, "current");
+        const currentLink = path6.join(this.bundleDir, "current");
         const tmpLink = `${currentLink}.new`;
         try {
           fs2.unlinkSync(tmpLink);
@@ -30055,7 +30379,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         try {
           for (const entry of fs2.readdirSync(versionsDir)) {
             if (!keep.has(entry)) {
-              fs2.rmSync(path4.join(versionsDir, entry), { recursive: true });
+              fs2.rmSync(path6.join(versionsDir, entry), { recursive: true });
             }
           }
         } catch {
@@ -30063,8 +30387,8 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
       }
       // --- Manifest & State I/O ---
       loadLocalManifest() {
-        const currentDir = path4.join(this.bundleDir, "current");
-        const manifestPath = path4.join(currentDir, "manifest.json");
+        const currentDir = path6.join(this.bundleDir, "current");
+        const manifestPath = path6.join(currentDir, "manifest.json");
         try {
           return JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
         } catch {
@@ -30072,7 +30396,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         }
       }
       loadUpdateState() {
-        const statePath = path4.join(this.bundleDir, "update-state.json");
+        const statePath = path6.join(this.bundleDir, "update-state.json");
         try {
           return JSON.parse(fs2.readFileSync(statePath, "utf-8"));
         } catch {
@@ -30080,8 +30404,8 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         }
       }
       saveUpdateState(state) {
-        const statePath = path4.join(this.bundleDir, "update-state.json");
-        const stateDir = path4.dirname(statePath);
+        const statePath = path6.join(this.bundleDir, "update-state.json");
+        const stateDir = path6.dirname(statePath);
         fs2.mkdirSync(stateDir, { recursive: true });
         const tmpPath = `${statePath}.tmp-${process.pid}-${Date.now()}`;
         let fd;
@@ -30125,7 +30449,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         return new URL(location, fromUrl).toString();
       }
       httpGet(url, maxRedirects = 5) {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           const mod2 = url.startsWith("https") ? https2 : http2;
           const req = mod2.get(url, (res) => {
             if (this.isRedirect(res.statusCode)) {
@@ -30139,7 +30463,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
                   return;
                 }
                 res.resume();
-                this.httpGet(redirectUrl, maxRedirects - 1).then(resolve8, reject);
+                this.httpGet(redirectUrl, maxRedirects - 1).then(resolve9, reject);
                 return;
               }
               res.resume();
@@ -30153,7 +30477,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             }
             const chunks = [];
             res.on("data", (chunk) => chunks.push(chunk));
-            res.on("end", () => resolve8(Buffer.concat(chunks).toString("utf-8")));
+            res.on("end", () => resolve9(Buffer.concat(chunks).toString("utf-8")));
             res.on("error", reject);
           });
           req.on("error", reject);
@@ -30163,7 +30487,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
         });
       }
       downloadFile(url, dest, maxRedirects = 5) {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           const mod2 = url.startsWith("https") ? https2 : http2;
           const req = mod2.get(url, (res) => {
             if (this.isRedirect(res.statusCode)) {
@@ -30177,7 +30501,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
                   return;
                 }
                 res.resume();
-                this.downloadFile(redirectUrl, dest, maxRedirects - 1).then(resolve8, reject);
+                this.downloadFile(redirectUrl, dest, maxRedirects - 1).then(resolve9, reject);
                 return;
               }
               res.resume();
@@ -30193,7 +30517,7 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
             res.pipe(file);
             file.on("finish", () => {
               file.close();
-              resolve8();
+              resolve9();
             });
             file.on("error", (err) => {
               fs2.unlinkSync(dest);
@@ -30217,10 +30541,10 @@ MCowBQYDK2VwAyEAQHQAZThNX7+deJNyHl/5DgiAa1OHx7UQoJotam0JhUk=
 });
 
 // ts/daemon/dist/cli.js
-import { execSync, spawn } from "node:child_process";
+import { execFileSync, execSync, spawn } from "node:child_process";
 import * as fs3 from "node:fs";
 import * as os3 from "node:os";
-import * as path5 from "node:path";
+import * as path7 from "node:path";
 import * as readline from "node:readline";
 function readConfig() {
   try {
@@ -30236,10 +30560,10 @@ function writeConfig(config) {
 }
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve8(answer.trim());
+      resolve9(answer.trim());
     });
   });
 }
@@ -30249,11 +30573,156 @@ function isMacOS() {
 function isLinux() {
   return process.platform === "linux";
 }
+function isWindows() {
+  return process.platform === "win32";
+}
+function sleepSync(ms) {
+  Atomics.wait(SLEEP_SIGNAL, 0, 0, ms);
+}
+function runWinCmd(file, args) {
+  try {
+    const stdout = execFileSync(file, args, {
+      encoding: "utf8",
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: WIN_CMD_TIMEOUT_MS
+    });
+    return { code: 0, stdout };
+  } catch (err) {
+    const e = err;
+    const code = typeof e.status === "number" ? e.status : null;
+    return {
+      code,
+      stdout: String(e.stdout ?? ""),
+      spawnError: code === null ? String(e.message ?? err) : void 0
+    };
+  }
+}
+function winDeps() {
+  return {
+    run: runWinCmd,
+    fs: {
+      readFile(p) {
+        try {
+          return fs3.readFileSync(p, "utf8");
+        } catch {
+          return null;
+        }
+      },
+      unlink(p) {
+        try {
+          fs3.unlinkSync(p);
+          return true;
+        } catch (err) {
+          return err.code === "ENOENT";
+        }
+      }
+    },
+    paths: winServicePaths(os3.homedir()),
+    sleep: sleepSync,
+    now: () => Date.now()
+  };
+}
+function reportWinProblems(problems) {
+  for (const problem of problems) {
+    console.error(`ERROR: ${problem}`);
+  }
+  console.error("State was left in place so nothing is orphaned; fix the cause and retry.");
+}
+function installServiceWindows() {
+  let npmEntry;
+  try {
+    npmEntry = fs3.realpathSync(process.argv[1] ?? "");
+  } catch {
+    console.error("Cannot resolve the daemon entry script; reinstall with `npm install -g @parall/daemon`.");
+    process.exit(1);
+  }
+  if (/[\\/]_npx[\\/]/.test(npmEntry)) {
+    console.warn("Warning: installing from an npx cache path. Run `npm install -g @parall/daemon` and re-run\n`parall-daemon service install`, or the service breaks when the npx cache is pruned\n(a completed self-update heals this by switching to the overlay bundle).");
+  }
+  const p = winServicePaths(os3.homedir());
+  fs3.mkdirSync(p.serviceDir, { recursive: true });
+  fs3.mkdirSync(p.logDir, { recursive: true });
+  fs3.writeFileSync(p.launcherCjs, buildLauncherCjs({
+    npmEntry,
+    overlayEntry: p.overlayEntry,
+    pidFile: p.pidFile,
+    logFile: p.logFile
+  }));
+  try {
+    fs3.unlinkSync(p.legacyLauncherJs);
+  } catch {
+  }
+  const wscriptExe = path7.join(process.env.SystemRoot || "C:\\Windows", "System32", "wscript.exe");
+  fs3.writeFileSync(p.launcherVbs, encodeUtf16LeBom(buildLauncherVbs({ nodeExe: process.execPath, launcherCjs: p.launcherCjs })));
+  fs3.writeFileSync(p.taskXml, encodeUtf16LeBom(buildTaskXml({ wscriptExe, launcherVbs: p.launcherVbs })));
+  const create = runWinCmd("schtasks", ["/Create", "/TN", WIN_TASK_NAME, "/XML", p.taskXml, "/F"]);
+  if (create.code !== 0) {
+    console.error(`ERROR: could not register the Task Scheduler task (schtasks /Create exit ${create.code ?? "spawn-failed"}).`);
+    console.error(`       Task XML: ${p.taskXml}`);
+    process.exit(1);
+  }
+  const run = runWinCmd("schtasks", ["/Run", "/TN", WIN_TASK_NAME]);
+  if (run.code !== 0) {
+    console.error(`ERROR: the task registered but would not start (schtasks /Run exit ${run.code ?? "spawn-failed"}).`);
+    console.error(`       Start it from Task Scheduler, or check ${p.logFile}.`);
+    process.exit(1);
+  }
+  console.log(`Task Scheduler task installed: ${WIN_TASK_NAME} (artifacts in ${p.serviceDir})`);
+  console.log("Task registered and triggered. Check `parall-daemon status` for the daemon itself.");
+  console.log(`Logs: ${p.logFile}`);
+}
+function stopWindows() {
+  const result = stopDaemonWindows(winDeps());
+  if (!result.ok) {
+    reportWinProblems(result.problems);
+    process.exit(1);
+  }
+  console.log("Daemon stopped (Task Scheduler task disabled). Re-arm with `parall-daemon service install`.");
+}
+function statusWindows() {
+  const deps = winDeps();
+  const exists = queryTaskExists(deps);
+  if (exists === "indeterminate") {
+    console.log("Service: unknown (schtasks query failed)");
+  } else if (!exists) {
+    console.log("Service: not installed");
+  } else {
+    const disabled = queryTaskDisabled(deps);
+    const suffix = disabled === true ? ", disabled" : disabled === "indeterminate" ? ", state unknown" : "";
+    console.log(`Service: installed${suffix} (Task Scheduler: ${WIN_TASK_NAME})`);
+  }
+  const pid = readTrackedPid(deps);
+  if (pid === null) {
+    console.log("Daemon: stopped");
+    return;
+  }
+  switch (probePidIdentity(deps, pid)) {
+    case "daemon":
+      console.log("Daemon: running");
+      console.log(`PID: ${pid}`);
+      break;
+    case "not-daemon":
+      console.log("Daemon: stopped (stale pidfile)");
+      break;
+    case "indeterminate":
+      console.log(`Daemon: unknown (could not verify pid ${pid} \u2014 process query failed)`);
+      break;
+  }
+}
+function serviceUninstallWindows() {
+  const result = uninstallDaemonWindows(winDeps());
+  if (!result.ok) {
+    reportWinProblems(result.problems);
+    process.exit(1);
+  }
+  console.log("Task Scheduler task uninstalled (logs kept).");
+}
 function plistPath() {
-  return path5.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return path7.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function systemdUnitPath() {
-  return path5.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
+  return path7.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
 }
 function getDaemonBin() {
   try {
@@ -30263,7 +30732,7 @@ function getDaemonBin() {
   }
 }
 function generatePlist(daemonBin) {
-  const logPath = path5.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  const logPath = path7.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -30316,16 +30785,20 @@ function installService() {
     console.error("No config found. Run `parall-daemon init` first.");
     process.exit(1);
   }
+  if (isWindows()) {
+    installServiceWindows();
+    return;
+  }
   const bin = getDaemonBin();
   if (isMacOS()) {
-    const dir = path5.dirname(plistPath());
+    const dir = path7.dirname(plistPath());
     fs3.mkdirSync(dir, { recursive: true });
     fs3.writeFileSync(plistPath(), generatePlist(bin));
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
     execSync(`launchctl bootstrap gui/$(id -u) ${plistPath()}`);
     console.log(`launchd agent installed: ${plistPath()}`);
   } else if (isLinux()) {
-    const dir = path5.dirname(systemdUnitPath());
+    const dir = path7.dirname(systemdUnitPath());
     fs3.mkdirSync(dir, { recursive: true });
     fs3.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
     execSync("systemctl --user daemon-reload");
@@ -30354,6 +30827,10 @@ async function cmdInit() {
 function cmdStatus() {
   const config = readConfig();
   console.log(`Config: ${config ? CONFIG_PATH : "not configured"}`);
+  if (isWindows()) {
+    statusWindows();
+    return;
+  }
   if (isMacOS()) {
     try {
       const output = execSync(`launchctl print gui/$(id -u)/${PLIST_LABEL} 2>&1`, {
@@ -30377,6 +30854,10 @@ function cmdStatus() {
   }
 }
 function cmdStop() {
+  if (isWindows()) {
+    stopWindows();
+    return;
+  }
   if (isMacOS()) {
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`, {
       stdio: "inherit"
@@ -30394,7 +30875,23 @@ function cmdLogs(lines) {
     child2.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  const logPath = path5.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  if (isWindows()) {
+    const p = winServicePaths(os3.homedir());
+    if (!fs3.existsSync(p.logFile)) {
+      console.log("No log file found at", p.logFile);
+      return;
+    }
+    const tailCount = Number.parseInt(lines, 10);
+    const tail = Number.isInteger(tailCount) && tailCount > 0 ? tailCount : 50;
+    const child2 = spawn("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      `Get-Content -LiteralPath $env:PRLL_DAEMON_LOG_PATH -Tail ${tail} -Wait`
+    ], { stdio: "inherit", env: { ...process.env, PRLL_DAEMON_LOG_PATH: p.logFile } });
+    child2.on("exit", (code) => process.exit(code ?? 0));
+    return;
+  }
+  const logPath = path7.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
   if (!fs3.existsSync(logPath)) {
     console.log("No log file found at", logPath);
     return;
@@ -30403,6 +30900,10 @@ function cmdLogs(lines) {
   child.on("exit", (code) => process.exit(code ?? 0));
 }
 function cmdServiceUninstall() {
+  if (isWindows()) {
+    serviceUninstallWindows();
+    return;
+  }
   if (isMacOS()) {
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
     if (fs3.existsSync(plistPath()))
@@ -30466,7 +30967,7 @@ Usage:
   parall-daemon stop               Stop the background service
   parall-daemon update [--check]   Check for / apply daemon updates
   parall-daemon logs [-n LINES]    Tail daemon logs
-  parall-daemon service install    Install as background service (launchd/systemd)
+  parall-daemon service install    Install as background service (launchd/systemd/Task Scheduler)
   parall-daemon service uninstall  Uninstall background service
   parall-daemon help               Show this help
 `.trim());
@@ -30526,30 +31027,34 @@ async function runCLI(args) {
       return "run-daemon";
   }
 }
-var CONFIG_DIR, CONFIG_PATH, PLIST_LABEL;
+var CONFIG_DIR, CONFIG_PATH, SLEEP_SIGNAL, WIN_CMD_TIMEOUT_MS, PLIST_LABEL;
 var init_cli = __esm({
   "ts/daemon/dist/cli.js"() {
     "use strict";
     init_config();
+    init_win_service();
+    init_win_lifecycle();
     CONFIG_DIR = daemonConfigDir();
     CONFIG_PATH = daemonConfigPath();
+    SLEEP_SIGNAL = new Int32Array(new SharedArrayBuffer(4));
+    WIN_CMD_TIMEOUT_MS = 2e4;
     PLIST_LABEL = "com.parall.daemon";
   }
 });
 
 // ts/daemon/dist/clip-runtime/bun-resolver.js
 import * as fs4 from "node:fs";
-import * as path6 from "node:path";
-import { execFileSync } from "node:child_process";
+import * as path8 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
 function findBunBinary() {
-  const isWindows = process.platform === "win32";
-  const binName = isWindows ? "bun.exe" : "bun";
-  const embedded = path6.join(path6.dirname(process.execPath), binName);
+  const isWindows2 = process.platform === "win32";
+  const binName = isWindows2 ? "bun.exe" : "bun";
+  const embedded = path8.join(path8.dirname(process.execPath), binName);
   if (fs4.existsSync(embedded))
     return embedded;
-  if (!isWindows) {
+  if (!isWindows2) {
     const candidates = [
-      path6.join(process.env.HOME || "", ".bun", "bin", "bun"),
+      path8.join(process.env.HOME || "", ".bun", "bin", "bun"),
       "/usr/local/bin/bun",
       "/opt/homebrew/bin/bun"
     ];
@@ -30558,10 +31063,10 @@ function findBunBinary() {
         return candidate;
     }
   }
-  const lookupCmd = isWindows ? "where.exe" : "which";
-  const lookupArg = isWindows ? "bun.exe" : "bun";
+  const lookupCmd = isWindows2 ? "where.exe" : "which";
+  const lookupArg = isWindows2 ? "bun.exe" : "bun";
   try {
-    const result = execFileSync(lookupCmd, [lookupArg], { encoding: "utf-8" }).trim();
+    const result = execFileSync2(lookupCmd, [lookupArg], { encoding: "utf-8" }).trim();
     const firstLine = result.split("\n")[0]?.trim();
     if (firstLine)
       return firstLine;
@@ -30577,9 +31082,9 @@ var init_bun_resolver = __esm({
 
 // ts/daemon/dist/clip-runtime/clip-installer.js
 import * as fs5 from "node:fs";
-import * as path7 from "node:path";
+import * as path9 from "node:path";
 import * as crypto from "node:crypto";
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { pipeline } from "node:stream/promises";
 function parseSource(source) {
   const trimmed = source.trim();
@@ -30618,17 +31123,17 @@ async function httpGet(url, maxRedirects = 10) {
   if (maxRedirects < 0)
     throw new Error(`too many redirects for ${url}`);
   const mod2 = url.startsWith("https") ? await import("node:https") : await import("node:http");
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const req = mod2.get(url, { headers: { Accept: "application/json" } }, (res) => {
       if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        httpGet(res.headers.location, maxRedirects - 1).then(resolve8, reject);
+        httpGet(res.headers.location, maxRedirects - 1).then(resolve9, reject);
         res.resume();
         return;
       }
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
       res.on("end", () => {
-        resolve8({
+        resolve9({
           statusCode: res.statusCode ?? 0,
           headers: res.headers,
           body: Buffer.concat(chunks)
@@ -30643,10 +31148,10 @@ async function httpDownload(url, destPath, maxRedirects = 10) {
   if (maxRedirects < 0)
     throw new Error(`too many redirects for ${url}`);
   const mod2 = url.startsWith("https") ? await import("node:https") : await import("node:http");
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const req = mod2.get(url, (res) => {
       if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        httpDownload(res.headers.location, destPath, maxRedirects - 1).then(resolve8, reject);
+        httpDownload(res.headers.location, destPath, maxRedirects - 1).then(resolve9, reject);
         res.resume();
         return;
       }
@@ -30656,7 +31161,7 @@ async function httpDownload(url, destPath, maxRedirects = 10) {
         return;
       }
       const ws = fs5.createWriteStream(destPath);
-      pipeline(res, ws).then(resolve8, reject);
+      pipeline(res, ws).then(resolve9, reject);
     });
     req.on("error", reject);
   });
@@ -30791,13 +31296,13 @@ function verifyChecksum(filePath, algo, expectedHex) {
   hash.update(content);
   const actual = hash.digest("hex");
   if (actual !== expectedHex) {
-    throw new Error(`checksum mismatch for ${path7.basename(filePath)}: expected ${algo}:${expectedHex}, got ${algo}:${actual}`);
+    throw new Error(`checksum mismatch for ${path9.basename(filePath)}: expected ${algo}:${expectedHex}, got ${algo}:${actual}`);
   }
 }
 function validateTarEntries(tarballPath) {
   let listing;
   try {
-    listing = execFileSync2("tar", ["tzf", tarballPath], {
+    listing = execFileSync3("tar", ["tzf", tarballPath], {
       encoding: "utf-8",
       maxBuffer: 16 * 1024 * 1024
     });
@@ -30808,11 +31313,11 @@ function validateTarEntries(tarballPath) {
     const trimmed = entry.trim();
     if (!trimmed)
       continue;
-    if (path7.isAbsolute(trimmed)) {
+    if (path9.isAbsolute(trimmed)) {
       throw new Error(`tarball contains absolute path: "${trimmed}"`);
     }
-    const normalized = path7.normalize(trimmed);
-    if (normalized.startsWith("..") || normalized.includes(`${path7.sep}..${path7.sep}`)) {
+    const normalized = path9.normalize(trimmed);
+    if (normalized.startsWith("..") || normalized.includes(`${path9.sep}..${path9.sep}`)) {
       throw new Error(`tarball contains path traversal: "${trimmed}"`);
     }
   }
@@ -30821,7 +31326,7 @@ function extractTarball(tarballPath, destDir) {
   const stripComponents = detectStripComponents(tarballPath);
   fs5.mkdirSync(destDir, { recursive: true });
   try {
-    execFileSync2("tar", [
+    execFileSync3("tar", [
       "xzf",
       tarballPath,
       "-C",
@@ -30837,7 +31342,7 @@ function extractTarball(tarballPath, destDir) {
 function detectStripComponents(tarballPath) {
   let listing;
   try {
-    listing = execFileSync2("tar", ["tzf", tarballPath], {
+    listing = execFileSync3("tar", ["tzf", tarballPath], {
       encoding: "utf-8",
       maxBuffer: 16 * 1024 * 1024
     });
@@ -30860,7 +31365,7 @@ function detectStripComponents(tarballPath) {
   return commonPrefix ? 1 : 0;
 }
 function installDeps(clipDir) {
-  const pkgJsonPath = path7.join(clipDir, "package.json");
+  const pkgJsonPath = path9.join(clipDir, "package.json");
   if (!fs5.existsSync(pkgJsonPath))
     return;
   let hasDeps = false;
@@ -30879,11 +31384,11 @@ function installDeps(clipDir) {
   if (bunPath) {
     const bunEnv = {
       ...process.env,
-      PATH: `${path7.dirname(bunPath)}${path7.delimiter}${process.env.PATH ?? ""}`
+      PATH: `${path9.dirname(bunPath)}${path9.delimiter}${process.env.PATH ?? ""}`
     };
     for (const args of [["install", "--frozen-lockfile"], ["install"]]) {
       try {
-        execFileSync2(bunPath, args, {
+        execFileSync3(bunPath, args, {
           cwd: clipDir,
           stdio: "pipe",
           timeout: 12e4,
@@ -30896,7 +31401,7 @@ function installDeps(clipDir) {
     }
   }
   try {
-    execFileSync2("npm", ["install", "--production"], {
+    execFileSync3("npm", ["install", "--production"], {
       cwd: clipDir,
       stdio: "pipe",
       timeout: 12e4
@@ -30915,19 +31420,19 @@ async function installClip(opts) {
   const registryUrl = (opts.registryUrl ?? DEFAULT_REGISTRY_URL).replace(/\/+$/, "");
   const parsed = parseSource(opts.source);
   const alias = opts.alias ?? deriveAlias(parsed);
-  const destDir = path7.join(opts.clipsDir, alias);
+  const destDir = path9.join(opts.clipsDir, alias);
   const versionMeta = await resolveVersionMeta(registryUrl, parsed);
-  const tmpDir = path7.join(opts.clipsDir, `.tmp-${alias}-${Date.now()}`);
+  const tmpDir = path9.join(opts.clipsDir, `.tmp-${alias}-${Date.now()}`);
   fs5.mkdirSync(tmpDir, { recursive: true });
-  const tarballPath = path7.join(tmpDir, `${alias}-${versionMeta.version}.tgz`);
-  const stageDir = path7.join(tmpDir, "stage");
+  const tarballPath = path9.join(tmpDir, `${alias}-${versionMeta.version}.tgz`);
+  const stageDir = path9.join(tmpDir, "stage");
   try {
     await httpDownload(versionMeta.tarball, tarballPath);
     verifyChecksum(tarballPath, versionMeta.checksumAlgo, versionMeta.checksumHex);
     validateTarEntries(tarballPath);
     extractTarball(tarballPath, stageDir);
     installDeps(stageDir);
-    const backupDir = path7.join(opts.clipsDir, `.backup-${alias}-${Date.now()}`);
+    const backupDir = path9.join(opts.clipsDir, `.backup-${alias}-${Date.now()}`);
     let backedUp = false;
     try {
       if (fs5.existsSync(destDir)) {
@@ -30968,9 +31473,9 @@ var init_clip_installer = __esm({
 
 // ts/daemon/dist/clip-runtime/manifest.js
 import * as fs6 from "node:fs";
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 function loadClipJson(dir) {
-  const filePath = path8.join(dir, "clip.json");
+  const filePath = path10.join(dir, "clip.json");
   try {
     const content = fs6.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
@@ -30979,7 +31484,7 @@ function loadClipJson(dir) {
   }
 }
 function loadPackageJson(dir) {
-  const filePath = path8.join(dir, "package.json");
+  const filePath = path10.join(dir, "package.json");
   try {
     const content = fs6.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
@@ -31094,19 +31599,19 @@ function manifestFromIpc(ipcManifest) {
 function resolveEntrypoint(clip) {
   const clipJson = loadClipJson(clip.path);
   if (clipJson?.main)
-    return path8.join(clip.path, clipJson.main);
+    return path10.join(clip.path, clipJson.main);
   const pkgJson = loadPackageJson(clip.path);
   if (pkgJson?.main)
-    return path8.join(clip.path, pkgJson.main);
+    return path10.join(clip.path, pkgJson.main);
   if (pkgJson?.bin) {
     const binPath = typeof pkgJson.bin === "string" ? pkgJson.bin : Object.values(pkgJson.bin)[0];
     if (binPath)
-      return path8.join(clip.path, binPath);
+      return path10.join(clip.path, binPath);
   }
-  const defaultEntry = path8.join(clip.path, "index.ts");
+  const defaultEntry = path10.join(clip.path, "index.ts");
   if (fs6.existsSync(defaultEntry))
     return defaultEntry;
-  return path8.join(clip.path, "index.js");
+  return path10.join(clip.path, "index.js");
 }
 function finalizeManifest(manifest) {
   const m = { ...manifest };
@@ -31136,7 +31641,8 @@ var init_manifest = __esm({
 // ts/daemon/dist/runtimes.js
 import * as fs7 from "node:fs";
 import * as os4 from "node:os";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
+import { fileURLToPath } from "node:url";
 function buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
   const env = { ...baseEnv };
   clearAllProviderCreds(env);
@@ -31153,19 +31659,47 @@ function buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
   delete env.PRLL_DAEMON_MODE;
   return env;
 }
-function getRuntimeAdapter(runtimeType) {
+function bundledSiblingBin(overlayName, entryPath) {
+  const candidateDirs = [];
+  const entry = entryPath ?? process.argv[1];
+  if (entry) {
+    try {
+      candidateDirs.push(path11.dirname(fs7.realpathSync(entry)));
+    } catch {
+      candidateDirs.push(path11.dirname(path11.resolve(entry)));
+    }
+  }
+  try {
+    candidateDirs.push(path11.dirname(fileURLToPath(import.meta.url)));
+  } catch {
+  }
+  for (const dir of candidateDirs) {
+    const bin = path11.join(dir, overlayName);
+    try {
+      if (fs7.existsSync(bin))
+        return bin;
+    } catch {
+    }
+  }
+  return null;
+}
+function getRuntimeAdapter(runtimeType, opts) {
   const base = RUNTIME_ADAPTERS[runtimeType] ?? defaultAdapter;
   const overlayName = OVERLAY_BIN_NAMES[runtimeType];
   if (!overlayName)
     return base;
   try {
-    const bundleDir = resolveBundleDir();
-    const overlayBin = path9.join(bundleDir, "current", overlayName);
+    const bundleDir = resolveBundleDir(opts?.env);
+    const overlayBin = path11.join(bundleDir, "current", overlayName);
     if (fs7.existsSync(overlayBin)) {
       return { ...base, bin: process.execPath, args: [overlayBin] };
     }
   } catch {
   }
+  const siblingBin = bundledSiblingBin(overlayName, opts?.entryPath);
+  if (siblingBin) {
+    return { ...base, bin: process.execPath, args: [siblingBin] };
+  }
   return base;
 }
 function assertAgentKey(apiKey) {
@@ -31194,9 +31728,9 @@ var init_runtimes = __esm({
       buildEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
         const env = buildStandardEnv(baseEnv, agentId, orgId, apiKey, dirs, pc);
         if (baseEnv.KUBERNETES_SERVICE_HOST || llmSource(pc) !== "runtime_auth") {
-          env.PRLL_CODEX_HOME = path9.join(dirs.stateDir, ".codex");
+          env.PRLL_CODEX_HOME = path11.join(dirs.stateDir, ".codex");
         } else if (dirs.homeDir && !env.CODEX_HOME) {
-          env.CODEX_HOME = path9.join(baseEnv.HOME || os4.homedir(), ".codex");
+          env.CODEX_HOME = path11.join(baseEnv.HOME || os4.homedir(), ".codex");
         }
         return env;
       }
@@ -31298,7 +31832,7 @@ var init_ipc = __esm({
         return p;
       }
       doWrite(message) {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           if (this._closed) {
             reject(IPC_CLOSED_ERROR);
             return;
@@ -31309,7 +31843,7 @@ var init_ipc = __esm({
               this._closed = true;
               reject(err);
             } else {
-              resolve8();
+              resolve9();
             }
           });
         });
@@ -31383,13 +31917,13 @@ function sanitizeEnvForClip(extra) {
   return env;
 }
 function makeDeferred() {
-  let resolve8;
+  let resolve9;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve8 = res;
+    resolve9 = res;
     reject = rej;
   });
-  return { promise, resolve: resolve8, reject };
+  return { promise, resolve: resolve9, reject };
 }
 var CLIP_REGISTER_TIMEOUT_MS, CLIP_STOP_TIMEOUT_MS, ClipCommandError, ClipProcess;
 var init_process = __esm({
@@ -31487,12 +32021,12 @@ var init_process = __esm({
           throw new Error(`clip "${this.clip.name}" is not running`);
         const requestId = String(this.nextId++);
         const events = [];
-        const resultPromise = new Promise((resolve8, reject) => {
+        const resultPromise = new Promise((resolve9, reject) => {
           this.pending.set(requestId, (event) => {
             switch (event.type) {
               case MessageType.Result: {
                 this.pending.delete(requestId);
-                resolve8({ output: event.output });
+                resolve9({ output: event.output });
                 break;
               }
               case MessageType.Error: {
@@ -31517,7 +32051,7 @@ var init_process = __esm({
                 if (output === void 0 && events.length > 0) {
                   output = events.map((e) => e.output);
                 }
-                resolve8({ output });
+                resolve9({ output });
                 break;
               }
             }
@@ -31543,12 +32077,12 @@ var init_process = __esm({
         this.stopping = true;
         this.child.kill("SIGTERM");
         let timer;
-        const timeout = new Promise((resolve8) => {
+        const timeout = new Promise((resolve9) => {
           timer = setTimeout(() => {
             if (this.child && this.alive()) {
               this.child.kill("SIGKILL");
             }
-            resolve8();
+            resolve9();
           }, timeoutMs);
         });
         try {
@@ -31899,7 +32433,7 @@ var init_hub_client = __esm({
       unary(method, request3) {
         const timeoutMs = this.opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
         const url = new URL(this.opts.serviceUrl);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           let settled = false;
           const session = http22.connect(url.origin);
           const chunks = [];
@@ -31945,7 +32479,7 @@ var init_hub_client = __esm({
               return;
             }
             try {
-              resolve8(text ? JSON.parse(text) : {});
+              resolve9(text ? JSON.parse(text) : {});
             } catch (err) {
               reject(new Error(`hub ${method} bad response: ${String(err)}`));
             }
@@ -31960,7 +32494,7 @@ var init_hub_client = __esm({
       serverStream(method, request3) {
         const timeoutMs = this.opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
         const url = new URL(this.opts.serviceUrl);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           let settled = false;
           const session = http22.connect(url.origin);
           const decoder = new EnvelopeDecoder();
@@ -31986,7 +32520,7 @@ var init_hub_client = __esm({
               return;
             settled = true;
             cleanup();
-            resolve8(messages);
+            resolve9(messages);
           };
           const timer = setTimeout(() => fail(new Error(`hub ${method} timed out`)), timeoutMs);
           timer.unref?.();
@@ -32042,7 +32576,7 @@ var init_hub_client = __esm({
 
 // ts/daemon/dist/clip-runtime/process-manager.js
 import * as fs8 from "node:fs";
-import * as path10 from "node:path";
+import * as path12 from "node:path";
 function browserCapabilityConfig() {
   return {
     name: BROWSER_CAPABILITY_NAME,
@@ -32301,7 +32835,7 @@ var init_process_manager = __esm({
        * Reads clip-config.json if present, or scans subdirectories for clip.json files.
        */
       async loadInstalledClips() {
-        const configFile = path10.join(path10.dirname(this.clipsDir), "clip-config.json");
+        const configFile = path12.join(path12.dirname(this.clipsDir), "clip-config.json");
         if (fs8.existsSync(configFile)) {
           try {
             const content = fs8.readFileSync(configFile, "utf-8");
@@ -32320,9 +32854,9 @@ var init_process_manager = __esm({
         for (const entry of entries) {
           if (!entry.isDirectory())
             continue;
-          const clipDir = path10.join(this.clipsDir, entry.name);
-          const clipJsonPath = path10.join(clipDir, "clip.json");
-          const pkgJsonPath = path10.join(clipDir, "package.json");
+          const clipDir = path12.join(this.clipsDir, entry.name);
+          const clipJsonPath = path12.join(clipDir, "clip.json");
+          const pkgJsonPath = path12.join(clipDir, "package.json");
           if (fs8.existsSync(clipJsonPath)) {
             try {
               const clipJson = JSON.parse(fs8.readFileSync(clipJsonPath, "utf-8"));
@@ -32392,7 +32926,7 @@ var init_process_manager = __esm({
           // shells out to `bun` by name resolves it — the daemon's launchd PATH
           // does not include Frameworks/. Symmetric with installDeps(); relies on
           // the embedded binary being named `bun` (Frameworks/bun).
-          PATH: `${path10.dirname(bunPath)}${path10.delimiter}${process.env.PATH ?? ""}`
+          PATH: `${path12.dirname(bunPath)}${path12.delimiter}${process.env.PATH ?? ""}`
         });
         this.setStatus(config.name, "running", "starting");
         try {
@@ -32421,7 +32955,7 @@ var init_process_manager = __esm({
         return proc;
       }
       ensureClipDataDir(config, context2 = {}) {
-        const dir = path10.join(this.dataDir, config.name, context2.clipId ?? "default");
+        const dir = path12.join(this.dataDir, config.name, context2.clipId ?? "default");
         fs8.mkdirSync(dir, { recursive: true });
         return dir;
       }
@@ -32944,12 +33478,12 @@ var init_clip_provider = __esm({
           throw new Error("stream not open");
         }
         const envelope = encodeEnvelope2(msg);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           this.stream.write(envelope, (err) => {
             if (err)
               reject(err);
             else
-              resolve8();
+              resolve9();
           });
         });
       }
@@ -33063,7 +33597,7 @@ function formatErrorForLog(err) {
   return message.replace(/\s+/g, " ").slice(0, 300);
 }
 async function findFreePort() {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const server = net.createServer();
     server.unref();
     server.on("error", reject);
@@ -33071,7 +33605,7 @@ async function findFreePort() {
       const address = server.address();
       server.close(() => {
         if (address && typeof address === "object") {
-          resolve8(address.port);
+          resolve9(address.port);
         } else {
           reject(new Error("failed to allocate free port"));
         }
@@ -33080,12 +33614,12 @@ async function findFreePort() {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 function waitForChildExit(child, log2, graceMs = 5e3, hardCapMs = 15e3) {
   if (child.exitCode !== null || child.signalCode !== null)
     return Promise.resolve();
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let killTimer;
     let capTimer;
     const finish = () => {
@@ -33094,7 +33628,7 @@ function waitForChildExit(child, log2, graceMs = 5e3, hardCapMs = 15e3) {
         clearTimeout(killTimer);
       if (capTimer)
         clearTimeout(capTimer);
-      resolve8();
+      resolve9();
     };
     child.once("exit", finish);
     try {
@@ -33711,8 +34245,8 @@ import { spawn as spawn4 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7 } from "node:fs";
 import { createRequire } from "node:module";
-import * as path11 from "node:path";
-import { fileURLToPath } from "node:url";
+import * as path13 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function hostsMatch(a, b) {
   const norm = (h) => h.toLowerCase().replace(/^www\./, "");
   return norm(a) === norm(b);
@@ -33769,14 +34303,14 @@ function comparableUrl(url) {
   }
 }
 function resolveBbBrowserDaemonPath() {
-  const sibling = path11.join(path11.dirname(fileURLToPath(import.meta.url)), "bb-browser-daemon.js");
+  const sibling = path13.join(path13.dirname(fileURLToPath2(import.meta.url)), "bb-browser-daemon.js");
   if (existsSync8(sibling))
     return sibling;
   const require2 = createRequire(import.meta.url);
   const pkgPath = require2.resolve("@pinixai/bb-browser-pro/package.json");
   const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
   const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["bb-browser-daemon"] ?? "./dist/daemon.js";
-  const full = path11.resolve(path11.dirname(pkgPath), rel);
+  const full = path13.resolve(path13.dirname(pkgPath), rel);
   if (!existsSync8(full)) {
     throw new Error(`bb-browser-daemon entrypoint not found at ${full}`);
   }
@@ -34339,7 +34873,7 @@ var init_browser_profile_manager = __esm({
 
 // ts/daemon/dist/clip-runtime/browser-profile-pool.js
 import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import * as path12 from "node:path";
+import * as path14 from "node:path";
 function isSafeProfileId(id) {
   return /^brp_[A-Za-z0-9_-]+$/.test(id);
 }
@@ -34699,11 +35233,11 @@ var init_browser_profile_pool = __esm({
         }
       }
       profileHome(profileId) {
-        return path12.join(this.opts.baseHomeDir, sanitizeProfileId(profileId));
+        return path14.join(this.opts.baseHomeDir, sanitizeProfileId(profileId));
       }
       /** Legacy shared-layout cookie file for a profile (pre per-profile homes). */
       legacyAccountFile(profileId) {
-        return path12.join(this.opts.baseHomeDir, "accounts", `${sanitizeProfileId(profileId)}.json`);
+        return path14.join(this.opts.baseHomeDir, "accounts", `${sanitizeProfileId(profileId)}.json`);
       }
       /**
        * Remove every on-disk trace of a profile: its per-profile home AND any
@@ -34731,7 +35265,7 @@ var init_browser_profile_pool = __esm({
       // reset_generation to this value: a newer server value means a reset was missed
       // while offline → wipe. Missing/corrupt reads as 0 (so any server reset wins).
       metaFile(profileId) {
-        return path12.join(this.profileHome(profileId), ".parall-profile-meta.json");
+        return path14.join(this.profileHome(profileId), ".parall-profile-meta.json");
       }
       /** The reset_generation this daemon has applied for the profile (0 if unknown). */
       appliedResetGeneration(profileId) {
@@ -34749,7 +35283,7 @@ var init_browser_profile_pool = __esm({
       writeResetGeneration(profileId, generation) {
         const home = this.profileHome(profileId);
         mkdirSync6(home, { recursive: true });
-        const tmp = path12.join(home, `.parall-profile-meta.json.tmp-${process.pid}`);
+        const tmp = path14.join(home, `.parall-profile-meta.json.tmp-${process.pid}`);
         writeFileSync3(tmp, JSON.stringify({ reset_generation: generation }));
         renameSync3(tmp, this.metaFile(profileId));
       }
@@ -34775,7 +35309,7 @@ var init_browser_profile_pool = __esm({
         } catch {
         }
         try {
-          const accountsDir = path12.join(this.opts.baseHomeDir, "accounts");
+          const accountsDir = path14.join(this.opts.baseHomeDir, "accounts");
           for (const e of readdirSync3(accountsDir, { withFileTypes: true })) {
             if (!e.isFile() || !e.name.endsWith(".json"))
               continue;
@@ -34801,8 +35335,8 @@ var init_browser_profile_pool = __esm({
         const legacy = this.legacyAccountFile(profileId);
         if (!existsSync9(legacy))
           return;
-        const destDir = path12.join(this.profileHome(profileId), "accounts");
-        const dest = path12.join(destDir, path12.basename(legacy));
+        const destDir = path14.join(this.profileHome(profileId), "accounts");
+        const dest = path14.join(destDir, path14.basename(legacy));
         if (existsSync9(dest))
           return;
         try {
@@ -34834,10 +35368,10 @@ var init_clip_runtime = __esm({
 
 // ts/daemon/dist/filesystem.js
 import * as fs9 from "fs";
-import * as path13 from "path";
+import * as path15 from "path";
 import * as os5 from "os";
 function browseDenyReason(value) {
-  const normalized = path13.resolve(value).split(path13.sep).join("/");
+  const normalized = path15.resolve(value).split(path15.sep).join("/");
   if (normalized === "/")
     return "";
   for (const prefix of SYSTEM_DIR_PREFIXES) {
@@ -34867,8 +35401,8 @@ function syntheticRoots() {
   return roots;
 }
 async function listDirectory(dirPath) {
-  const resolved = path13.resolve(dirPath);
-  const normalized = resolved.split(path13.sep).join("/");
+  const resolved = path15.resolve(dirPath);
+  const normalized = resolved.split(path15.sep).join("/");
   if (normalized === "/") {
     return { entries: syntheticRoots() };
   }
@@ -34885,7 +35419,7 @@ async function listDirectory(dirPath) {
       return { entries: [], error: "Directory not found" };
     return { entries: [], error: "Permission denied" };
   }
-  const realDeny = browseDenyReason(realPath.split(path13.sep).join("/"));
+  const realDeny = browseDenyReason(realPath.split(path15.sep).join("/"));
   if (realDeny) {
     return { entries: [], error: `Access denied: ${realDeny}` };
   }
@@ -34954,7 +35488,7 @@ var init_filesystem = __esm({
 
 // ts/daemon/dist/home-isolation.js
 import * as fs10 from "node:fs";
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 function ensureIsolatedHome(spec, agentId, log2, platform2 = process.platform) {
   fs10.mkdirSync(spec.homeDir, { recursive: true });
   const failures = [];
@@ -34966,18 +35500,18 @@ function ensureIsolatedHome(spec, agentId, log2, platform2 = process.platform) {
     }
   };
   attempt(".claude link", () => {
-    fs10.mkdirSync(path14.join(spec.claudeStateRoot, ".claude"), { recursive: true });
-    ensureLink(path14.join(spec.homeDir, ".claude"), path14.join(spec.claudeStateRoot, ".claude"), agentId, log2);
+    fs10.mkdirSync(path16.join(spec.claudeStateRoot, ".claude"), { recursive: true });
+    ensureLink(path16.join(spec.homeDir, ".claude"), path16.join(spec.claudeStateRoot, ".claude"), agentId, log2);
   });
-  attempt(".claude.json link", () => ensureLink(path14.join(spec.homeDir, ".claude.json"), path14.join(spec.claudeStateRoot, ".claude.json"), agentId, log2));
+  attempt(".claude.json link", () => ensureLink(path16.join(spec.homeDir, ".claude.json"), path16.join(spec.claudeStateRoot, ".claude.json"), agentId, log2));
   if (platform2 === "darwin") {
     attempt("Library/Keychains link", () => {
-      fs10.mkdirSync(path14.join(spec.homeDir, "Library"), { recursive: true });
-      ensureLink(path14.join(spec.homeDir, "Library", "Keychains"), path14.join(spec.systemHome, "Library", "Keychains"), agentId, log2);
+      fs10.mkdirSync(path16.join(spec.homeDir, "Library"), { recursive: true });
+      ensureLink(path16.join(spec.homeDir, "Library", "Keychains"), path16.join(spec.systemHome, "Library", "Keychains"), agentId, log2);
     });
   }
   attempt(".gitconfig", () => {
-    const gitconfig = path14.join(spec.homeDir, ".gitconfig");
+    const gitconfig = path16.join(spec.homeDir, ".gitconfig");
     if (!fs10.existsSync(gitconfig)) {
       fs10.writeFileSync(gitconfig, `[user]
 	name = ${gitConfigValue(spec.gitUserName)}
@@ -35003,7 +35537,7 @@ function ensureLink(linkPath, target, agentId, log2) {
   if (existing) {
     if (existing.isSymbolicLink()) {
       const current = fs10.readlinkSync(linkPath);
-      if (path14.resolve(path14.dirname(linkPath), current) === path14.resolve(target))
+      if (path16.resolve(path16.dirname(linkPath), current) === path16.resolve(target))
         return;
       fs10.unlinkSync(linkPath);
       log2.info(`agent ${agentId}: relinking ${linkPath} \u2192 ${target}`);
@@ -35016,16 +35550,16 @@ function ensureLink(linkPath, target, agentId, log2) {
   fs10.symlinkSync(target, linkPath);
 }
 function ensureSharedCredentialLink(rootClaudeHome, agentClaudeHome, agentId, log2) {
-  const sharedCredentials = path14.resolve(sharedClaudeCredentialsFileFor(rootClaudeHome));
+  const sharedCredentials = path16.resolve(sharedClaudeCredentialsFileFor(rootClaudeHome));
   const agentCredentials = agentClaudeCredentialsFileFor(agentClaudeHome);
-  const agentCredentialsDir = path14.dirname(agentCredentials);
-  fs10.mkdirSync(path14.dirname(sharedCredentials), { recursive: true });
+  const agentCredentialsDir = path16.dirname(agentCredentials);
+  fs10.mkdirSync(path16.dirname(sharedCredentials), { recursive: true });
   fs10.mkdirSync(agentCredentialsDir, { recursive: true });
   try {
     const existing = fs10.lstatSync(agentCredentials);
     if (existing.isSymbolicLink()) {
       const currentTarget = fs10.readlinkSync(agentCredentials);
-      if (path14.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
+      if (path16.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
         return;
       }
       fs10.unlinkSync(agentCredentials);
@@ -35050,17 +35584,17 @@ var init_home_isolation = __esm({
 });
 
 // ts/daemon/dist/runtime-bin-resolver.js
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import * as fs11 from "node:fs";
 import * as os6 from "node:os";
-import * as path15 from "node:path";
+import * as path17 from "node:path";
 function runtimeBinaryEnvVar(runtimeType) {
   return RUNTIME_BINARIES[runtimeType]?.envVar;
 }
-function applyRuntimeBinaryEnv(runtimeType, baseEnv, log2) {
+function applyRuntimeBinaryEnv(runtimeType, baseEnv, log2, platform2 = process.platform) {
   const env = { ...baseEnv };
   const originalPath = env.PATH;
-  const pathPlan = cachedCandidatePathPlan(env);
+  const pathPlan = cachedCandidatePathPlan(env, platform2);
   const primaryPath = mergePath(pathPlan.primaryDirs, originalPath);
   env.PATH = mergePath([...pathPlan.primaryDirs, ...pathPlan.versionedFallbackDirs], originalPath);
   const spec = RUNTIME_BINARIES[runtimeType];
@@ -35068,7 +35602,7 @@ function applyRuntimeBinaryEnv(runtimeType, baseEnv, log2) {
     return env;
   const configured = env[spec.envVar]?.trim();
   if (configured) {
-    const resolved2 = resolveRuntimeCommand(configured, env, originalPath, primaryPath, env.PATH);
+    const resolved2 = resolveRuntimeCommand(configured, env, originalPath, primaryPath, env.PATH, platform2);
     if (resolved2) {
       env[spec.envVar] = resolved2.binaryPath;
       env.PATH = anchorResolvedPath(env.PATH, resolved2);
@@ -35078,7 +35612,7 @@ function applyRuntimeBinaryEnv(runtimeType, baseEnv, log2) {
     }
     return env;
   }
-  const resolved = resolveRuntimeCommand(spec.command, env, originalPath, primaryPath, env.PATH);
+  const resolved = resolveRuntimeCommand(spec.command, env, originalPath, primaryPath, env.PATH, platform2);
   if (resolved) {
     env[spec.envVar] = resolved.binaryPath;
     env.PATH = anchorResolvedPath(env.PATH, resolved);
@@ -35088,8 +35622,8 @@ function applyRuntimeBinaryEnv(runtimeType, baseEnv, log2) {
   }
   return env;
 }
-function resolveRuntimeCommand(command, env, inheritedPath, primaryPath, fallbackPath) {
-  const cacheKey = `runtime\0${command}\0${primaryPath}\0${fallbackPath}\0${env.SHELL ?? ""}\0${env.HOME ?? ""}`;
+function resolveRuntimeCommand(command, env, inheritedPath, primaryPath, fallbackPath, platform2) {
+  const cacheKey = `runtime\0${command}\0${primaryPath}\0${fallbackPath}\0${env.SHELL ?? ""}\0${env.HOME ?? ""}\0${platform2}`;
   const cached = getCachedResolution(cacheKey);
   if (cached)
     return cached;
@@ -35100,24 +35634,24 @@ function resolveRuntimeCommand(command, env, inheritedPath, primaryPath, fallbac
     setCachedResolution(cacheKey, resolved);
     return resolved;
   }
-  const fromInheritedPath = resolveFromPath(command, inheritedPath, env);
+  const fromInheritedPath = resolveFromPath(command, inheritedPath, env, platform2);
   if (fromInheritedPath) {
     setCachedResolution(cacheKey, fromInheritedPath);
     return fromInheritedPath;
   }
   if (runLoginShell) {
-    const fromShell = resolveFromLoginShell(command, { ...env, PATH: inheritedPath });
+    const fromShell = resolveFromLoginShell(command, { ...env, PATH: inheritedPath }, platform2);
     if (fromShell) {
       setCachedResolution(cacheKey, fromShell);
       return fromShell;
     }
   }
-  const fromPrimaryPath = resolveFromPath(command, primaryPath, env);
+  const fromPrimaryPath = resolveFromPath(command, primaryPath, env, platform2);
   if (fromPrimaryPath) {
     setCachedResolution(cacheKey, fromPrimaryPath);
     return fromPrimaryPath;
   }
-  const fromFallbackPath = fallbackPath === primaryPath ? null : resolveFromPath(command, fallbackPath, env);
+  const fromFallbackPath = fallbackPath === primaryPath ? null : resolveFromPath(command, fallbackPath, env, platform2);
   if (fromFallbackPath) {
     setCachedResolution(cacheKey, fromFallbackPath);
     return fromFallbackPath;
@@ -35130,28 +35664,30 @@ function resolveRuntimeCommand(command, env, inheritedPath, primaryPath, fallbac
 function resolveDirectPath(command) {
   if (!command.includes("/") && !command.includes("\\"))
     return null;
-  const abs = path15.isAbsolute(command) ? command : path15.resolve(process.cwd(), command);
+  const abs = path17.isAbsolute(command) ? command : path17.resolve(process.cwd(), command);
   return isExecutable(abs) ? abs : null;
 }
-function resolveFromPath(command, pathValue, env) {
+function resolveFromPath(command, pathValue, env, platform2) {
   if (!pathValue || command.includes("/") || command.includes("\\"))
     return null;
-  const dirs = pathValue.split(path15.delimiter).filter(Boolean);
+  const dirs = pathValue.split(path17.delimiter).filter(Boolean);
   for (const dir of dirs) {
-    for (const file of commandCandidates(command, env)) {
-      const candidate = path15.join(dir, file);
+    for (const file of commandCandidates(command, env, platform2)) {
+      const candidate = path17.join(dir, file);
       if (isExecutable(candidate))
         return { binaryPath: candidate, pathValue };
     }
   }
   return null;
 }
-function resolveFromLoginShell(command, env) {
+function resolveFromLoginShell(command, env, platform2) {
+  if (platform2 === "win32")
+    return null;
   if (command.includes("/") || command.includes("\\"))
     return null;
   const shells = unique([
     env.SHELL?.trim(),
-    process.platform === "darwin" ? "/bin/zsh" : void 0,
+    platform2 === "darwin" ? "/bin/zsh" : void 0,
     "/bin/bash",
     "/bin/sh"
   ]);
@@ -35159,7 +35695,7 @@ function resolveFromLoginShell(command, env) {
     if (!shell || !isExecutable(shell))
       continue;
     try {
-      const out = execFileSync3(shell, [
+      const out = execFileSync4(shell, [
         "-lic",
         `resolved=$(command -v ${shellQuote(command)}) || exit $?; printf '__PRLL_BIN__%s
 __PRLL_PATH__%s
@@ -35178,7 +35714,7 @@ __PRLL_PATH__%s
         if (line.startsWith("__PRLL_PATH__"))
           pathValue = line.slice("__PRLL_PATH__".length);
       }
-      if (path15.isAbsolute(binaryPath) && isExecutable(binaryPath)) {
+      if (path17.isAbsolute(binaryPath) && isExecutable(binaryPath)) {
         return { binaryPath, pathValue: pathValue || void 0 };
       }
     } catch {
@@ -35186,35 +35722,54 @@ __PRLL_PATH__%s
   }
   return null;
 }
-function cachedCandidatePathPlan(env) {
-  const key = `${env.HOME ?? ""}\0${env.PRLL_DAEMON_RUNTIME_PATH ?? ""}\0${env.PRLL_DAEMON_EXTRA_PATH ?? ""}`;
+function cachedCandidatePathPlan(env, platform2) {
+  const key = `${env.HOME ?? ""}\0${env.PRLL_DAEMON_RUNTIME_PATH ?? ""}\0${env.PRLL_DAEMON_EXTRA_PATH ?? ""}\0${env.APPDATA ?? ""}\0${env.LOCALAPPDATA ?? ""}\0${env.PNPM_HOME ?? ""}\0${platform2}`;
   const hit = pathPlanCache.get(key);
   if (hit && hit.expiresAt > Date.now())
     return hit.value;
-  const value = candidatePathPlan(env);
+  const value = candidatePathPlan(env, platform2);
   pathPlanCache.set(key, { value, expiresAt: Date.now() + RESOLUTION_CACHE_TTL_MS });
   return value;
 }
-function candidatePathPlan(env) {
+function candidatePathPlan(env, platform2 = process.platform) {
   const home = env.HOME || os6.homedir();
+  if (platform2 === "win32") {
+    const appData = env.APPDATA || path17.join(home, "AppData", "Roaming");
+    const localAppData = env.LOCALAPPDATA || path17.join(home, "AppData", "Local");
+    const winPrimaryDirs = [
+      ...splitPath(env.PRLL_DAEMON_RUNTIME_PATH),
+      ...splitPath(env.PRLL_DAEMON_EXTRA_PATH),
+      path17.dirname(process.execPath),
+      env.PNPM_HOME,
+      path17.join(appData, "npm"),
+      path17.join(localAppData, "pnpm"),
+      path17.join(localAppData, "Volta", "bin"),
+      path17.join(home, ".volta", "bin"),
+      path17.join(home, ".bun", "bin")
+    ];
+    return {
+      primaryDirs: unique(winPrimaryDirs).filter((dir) => !!dir && isDirectory(dir)),
+      versionedFallbackDirs: []
+    };
+  }
   const primaryDirs = [
     ...splitPath(env.PRLL_DAEMON_RUNTIME_PATH),
     ...splitPath(env.PRLL_DAEMON_EXTRA_PATH),
-    path15.dirname(process.execPath),
-    path15.join(path15.dirname(process.execPath), "bin"),
-    path15.resolve(path15.dirname(process.execPath), "..", "Resources", "bin"),
-    path15.join(home, ".local", "bin"),
-    path15.join(home, "bin"),
-    path15.join(home, ".npm-global", "bin"),
-    path15.join(home, "Library", "pnpm"),
-    path15.join(home, ".local", "share", "pnpm"),
-    path15.join(home, ".volta", "bin"),
-    path15.join(home, ".bun", "bin"),
-    path15.join(home, ".asdf", "shims"),
-    path15.join(home, ".local", "share", "mise", "shims"),
-    path15.join(home, ".mise", "shims"),
-    path15.join(home, ".fnm", "aliases", "default", "bin"),
-    path15.join(home, "Library", "Application Support", "fnm", "aliases", "default", "bin"),
+    path17.dirname(process.execPath),
+    path17.join(path17.dirname(process.execPath), "bin"),
+    path17.resolve(path17.dirname(process.execPath), "..", "Resources", "bin"),
+    path17.join(home, ".local", "bin"),
+    path17.join(home, "bin"),
+    path17.join(home, ".npm-global", "bin"),
+    path17.join(home, "Library", "pnpm"),
+    path17.join(home, ".local", "share", "pnpm"),
+    path17.join(home, ".volta", "bin"),
+    path17.join(home, ".bun", "bin"),
+    path17.join(home, ".asdf", "shims"),
+    path17.join(home, ".local", "share", "mise", "shims"),
+    path17.join(home, ".mise", "shims"),
+    path17.join(home, ".fnm", "aliases", "default", "bin"),
+    path17.join(home, "Library", "Application Support", "fnm", "aliases", "default", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -35233,19 +35788,19 @@ function candidatePathPlan(env) {
   };
 }
 function nvmVersionBinDirs(home) {
-  const root = path15.join(home, ".nvm", "versions", "node");
+  const root = path17.join(home, ".nvm", "versions", "node");
   let versions;
   try {
     versions = fs11.readdirSync(root);
   } catch {
     return [];
   }
-  return sortVersionNamesDesc(versions).map((version) => path15.join(root, version, "bin"));
+  return sortVersionNamesDesc(versions).map((version) => path17.join(root, version, "bin"));
 }
 function fnmVersionBinDirs(home) {
   const roots = [
-    path15.join(home, ".fnm", "node-versions"),
-    path15.join(home, "Library", "Application Support", "fnm", "node-versions")
+    path17.join(home, ".fnm", "node-versions"),
+    path17.join(home, "Library", "Application Support", "fnm", "node-versions")
   ];
   const dirs = [];
   for (const root of roots) {
@@ -35255,7 +35810,7 @@ function fnmVersionBinDirs(home) {
     } catch {
       continue;
     }
-    dirs.push(...sortVersionNamesDesc(versions).map((version) => path15.join(root, version, "installation", "bin")));
+    dirs.push(...sortVersionNamesDesc(versions).map((version) => path17.join(root, version, "installation", "bin")));
   }
   return dirs;
 }
@@ -35277,22 +35832,22 @@ function parseVersionName(value) {
   return value.replace(/^v/i, "").split(".").map((part) => Number.parseInt(part, 10)).filter((part) => Number.isFinite(part));
 }
 function splitPath(value) {
-  return value?.split(path15.delimiter).filter(Boolean) ?? [];
+  return value?.split(path17.delimiter).filter(Boolean) ?? [];
 }
 function mergePath(prependDirs, existing) {
-  return unique([...prependDirs, ...splitPath(existing)]).join(path15.delimiter);
+  return unique([...prependDirs, ...splitPath(existing)]).join(path17.delimiter);
 }
 function anchorResolvedPath(pathValue, resolution) {
-  return mergePath([path15.dirname(resolution.binaryPath), ...splitPath(resolution.pathValue)], pathValue);
+  return mergePath([path17.dirname(resolution.binaryPath), ...splitPath(resolution.pathValue)], pathValue);
 }
-function commandCandidates(command, env) {
-  if (process.platform !== "win32")
+function commandCandidates(command, env, platform2 = process.platform) {
+  if (platform2 !== "win32")
     return [command];
   const hasExt = /\.[^\\/]+$/.test(command);
   if (hasExt)
     return [command];
-  const exts = (env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean).map((ext) => ext.toLowerCase());
-  return [command, ...exts.map((ext) => `${command}${ext}`)];
+  const exts = (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean).map((ext) => ext.toLowerCase());
+  return exts.map((ext) => `${command}${ext}`);
 }
 function getCachedResolution(cacheKey) {
   const entry = resolutionCache.get(cacheKey);
@@ -35371,7 +35926,7 @@ function resolveRuntimeBinary(runtimeType, baseEnv) {
   return binaryPath ? { binaryPath, env } : null;
 }
 function probeVersion(binaryPath, env) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     execFile(
       IS_WIN32 ? quoteWin32Arg(binaryPath) : binaryPath,
       ["--version"],
@@ -35380,11 +35935,11 @@ function probeVersion(binaryPath, env) {
       { env, timeout: VERSION_PROBE_TIMEOUT_MS, windowsHide: true, shell: IS_WIN32 },
       (err, stdout) => {
         if (err) {
-          resolve8({ ok: false });
+          resolve9({ ok: false });
           return;
         }
         const line = String(stdout).split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0) ?? "";
-        resolve8(line ? { ok: true, version: line.slice(0, VERSION_MAX_LEN) } : { ok: true });
+        resolve9(line ? { ok: true, version: line.slice(0, VERSION_MAX_LEN) } : { ok: true });
       }
     );
   });
@@ -35438,7 +35993,7 @@ var init_runtime_detector = __esm({
 import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import * as fs12 from "node:fs";
-import * as path16 from "node:path";
+import * as path18 from "node:path";
 async function prepareWorkspace(opts) {
   const prior = opts.attached.workspace_state;
   const plan = buildWorkspacePlan(opts.attached.daemon_config, opts.defaultWorkspaceDir, prior?.config_hash);
@@ -35583,8 +36138,8 @@ async function ensureWorkspace(plan, log2) {
       assertSafeCustomWorkspacePath(plan);
     }
     if (!fs12.existsSync(plan.workspaceDir)) {
-      fs12.mkdirSync(path16.dirname(plan.workspaceDir), { recursive: true });
-      assertWritableWorkspaceDir(path16.dirname(plan.workspaceDir));
+      fs12.mkdirSync(path18.dirname(plan.workspaceDir), { recursive: true });
+      assertWritableWorkspaceDir(path18.dirname(plan.workspaceDir));
       await runCommand("git", ["clone", remote, plan.workspaceDir], process.cwd());
     } else {
       const st = fs12.statSync(plan.workspaceDir);
@@ -35715,7 +36270,7 @@ async function tryGitOutput(cmd, args, cwd) {
   }
 }
 function runCommand(cmd, args, cwd, timeoutMs = 12e4, env = process.env) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let tail = "";
     let timedOut = false;
     let settled = false;
@@ -35757,7 +36312,7 @@ ${tail}`)));
         return;
       }
       if (code === 0) {
-        settle(() => resolve8(tail));
+        settle(() => resolve9(tail));
       } else {
         settle(() => reject(new Error(`command failed (${code ?? signal}): ${cmd} ${args.join(" ")}
 ${tail}`)));
@@ -35766,10 +36321,10 @@ ${tail}`)));
   });
 }
 function requireAbsolute(value, field) {
-  if (!value || !path16.isAbsolute(value)) {
+  if (!value || !path18.isAbsolute(value)) {
     throw new Error(`${field} must be an absolute path`);
   }
-  return path16.resolve(value);
+  return path18.resolve(value);
 }
 function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
   if (!plan.customWorkspaceField)
@@ -35779,14 +36334,14 @@ function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
   if (reason) {
     throw new Error(`${plan.customWorkspaceField} must point to a project folder, not ${reason}: ${normalized}`);
   }
-  const defaultWorkspace = path16.resolve(plan.defaultWorkspaceDir);
+  const defaultWorkspace = path18.resolve(plan.defaultWorkspaceDir);
   if (isAncestorPath(normalized, defaultWorkspace) || normalized === defaultWorkspace) {
     throw new Error(`${plan.customWorkspaceField} must not point at daemon state directories: ${normalized}`);
   }
 }
 function assertWritableWorkspaceDir(dir) {
   fs12.accessSync(dir, fs12.constants.R_OK | fs12.constants.W_OK | fs12.constants.X_OK);
-  const probe = path16.join(dir, `.parall-workspace-check-${process.pid}-${Date.now()}`);
+  const probe = path18.join(dir, `.parall-workspace-check-${process.pid}-${Date.now()}`);
   const fd = fs12.openSync(probe, "wx", 384);
   fs12.closeSync(fd);
   fs12.unlinkSync(probe);
@@ -35850,11 +36405,11 @@ function workspacePathDenyReason(value) {
   return "";
 }
 function isAncestorPath(parent, child) {
-  const relative2 = path16.relative(parent, child);
-  return relative2 !== "" && !relative2.startsWith("..") && !path16.isAbsolute(relative2);
+  const relative2 = path18.relative(parent, child);
+  return relative2 !== "" && !relative2.startsWith("..") && !path18.isAbsolute(relative2);
 }
 function toPolicyPath(value) {
-  return path16.resolve(value).split(path16.sep).join("/");
+  return path18.resolve(value).split(path18.sep).join("/");
 }
 function isNodeError(err) {
   return err instanceof Error && "code" in err;
@@ -35873,18 +36428,18 @@ var init_workspace = __esm({
 import { spawn as spawn6 } from "node:child_process";
 import * as fs13 from "node:fs";
 import * as os7 from "node:os";
-import * as path17 from "node:path";
+import * as path19 from "node:path";
 function sleepCancellable(ms, signal) {
   if (signal.aborted)
     return Promise.resolve(false);
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve8(true);
+      resolve9(true);
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve8(false);
+      resolve9(false);
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -36024,7 +36579,7 @@ var init_supervisor = __esm({
         this.migrateFlatLayout();
         if (process.env.PRLL_CLIP_RUNTIME_ENABLED === "true") {
           this.browserProfilePool = new BrowserProfilePool({
-            baseHomeDir: path17.join(this.config.rootStateDir, "bb-browser"),
+            baseHomeDir: path19.join(this.config.rootStateDir, "bb-browser"),
             log: this.log,
             reportStatus: (profileId, status, errorMsg, generation) => {
               this.client.reportBrowserProfileStatus(profileId, status, errorMsg, generation).catch((err) => this.log.warn(`browser profile status report failed: ${String(err)}`));
@@ -36032,8 +36587,8 @@ var init_supervisor = __esm({
             resolveProxy: (profileId) => this.resolveBrowserProfileProxy(profileId)
           });
           this.clipManager = new ClipProcessManager({
-            clipsDir: path17.join(this.config.rootStateDir, "clips"),
-            dataDir: path17.join(this.config.rootStateDir, "clip-data"),
+            clipsDir: path19.join(this.config.rootStateDir, "clips"),
+            dataDir: path19.join(this.config.rootStateDir, "clip-data"),
             browserProfileManager: this.browserProfilePool,
             // Execution side: nested browser dependency invokes resolve their
             // binding and route through the hub (no local shortcut).
@@ -36141,8 +36696,8 @@ var init_supervisor = __esm({
           }
         });
         await this.ws.connect();
-        await new Promise((resolve8) => {
-          this.stopResolve = resolve8;
+        await new Promise((resolve9) => {
+          this.stopResolve = resolve9;
         });
         signal.removeEventListener("abort", onAbort);
       }
@@ -36438,12 +36993,12 @@ var init_supervisor = __esm({
        */
       migrateFlatLayout() {
         const root = this.config.rootStateDir;
-        const agentsDir = path17.join(root, "agents");
-        const flatWorkspace = path17.join(root, "workspace");
+        const agentsDir = path19.join(root, "agents");
+        const flatWorkspace = path19.join(root, "workspace");
         if (!fs13.existsSync(flatWorkspace) || fs13.existsSync(agentsDir))
           return;
         let ownerAgentId;
-        const sessionsDir = path17.join(root, "sessions");
+        const sessionsDir = path19.join(root, "sessions");
         if (fs13.existsSync(sessionsDir)) {
           try {
             for (const file of fs13.readdirSync(sessionsDir)) {
@@ -36460,13 +37015,13 @@ var init_supervisor = __esm({
           }
         }
         const targetId = ownerAgentId ?? "_orphan";
-        const targetDir = path17.join(agentsDir, targetId);
+        const targetDir = path19.join(agentsDir, targetId);
         try {
           fs13.mkdirSync(targetDir, { recursive: true });
           for (const sub of ["workspace", "sessions", "dispatch-context"]) {
-            const src = path17.join(root, sub);
+            const src = path19.join(root, sub);
             if (fs13.existsSync(src)) {
-              fs13.renameSync(src, path17.join(targetDir, sub));
+              fs13.renameSync(src, path19.join(targetDir, sub));
             }
           }
           this.log.info(`migrated legacy flat state \u2192 agents/${targetId}/`);
@@ -36757,7 +37312,7 @@ var init_supervisor = __esm({
         return this.runtimeDetectInFlight;
       }
       machineClipToConfig(clip) {
-        const clipPath = path17.join(this.config.rootStateDir, "clips", clip.alias);
+        const clipPath = path19.join(this.config.rootStateDir, "clips", clip.alias);
         return {
           clipId: clip.clip_id,
           name: clip.alias,
@@ -36823,7 +37378,7 @@ var init_supervisor = __esm({
         if (!sourceRef) {
           throw new Error(`registry clip "${config.name}" is missing source_ref`);
         }
-        const expectedPath = path17.join(this.config.rootStateDir, "clips", config.name);
+        const expectedPath = path19.join(this.config.rootStateDir, "clips", config.name);
         const localVersion = this.readInstalledClipVersion(expectedPath);
         if (localVersion && (!config.version || localVersion === config.version)) {
           return { ...config, path: expectedPath, source: expectedPath };
@@ -36841,7 +37396,7 @@ var init_supervisor = __esm({
         const result = await installClip({
           source,
           alias: config.name,
-          clipsDir: path17.join(this.config.rootStateDir, "clips"),
+          clipsDir: path19.join(this.config.rootStateDir, "clips"),
           registryUrl: process.env.PRLL_PINIX_REGISTRY_URL?.trim() || void 0
         });
         this.log.info(`clip ensured: ${result.alias} v${result.version} at ${result.path}`);
@@ -36856,7 +37411,7 @@ var init_supervisor = __esm({
       readInstalledClipVersion(dir) {
         for (const file of ["clip.json", "package.json"]) {
           try {
-            const raw = fs13.readFileSync(path17.join(dir, file), "utf-8");
+            const raw = fs13.readFileSync(path19.join(dir, file), "utf-8");
             const parsed = JSON.parse(raw);
             if (typeof parsed.version === "string" && parsed.version.trim()) {
               return parsed.version.trim();
@@ -37326,7 +37881,7 @@ var init_supervisor = __esm({
         child.once("error", (err) => {
           if (err.code === "ENOENT") {
             if (adapter.args.length > 0) {
-              this.log.error(`Node runtime "${adapter.bin}" not found \u2014 is the Desktop app installed?`);
+              this.log.error(`Node runtime "${adapter.bin}" not found while launching ${adapter.args[0]} \u2014 reinstall the daemon (npm install -g @parall/daemon) or the Desktop app`);
             } else {
               const pkg = RUNTIME_PACKAGES[state.runtimeType] ?? `@parall/${state.runtimeType}-agent`;
               this.log.error(`Runtime binary "${adapter.bin}" not found in PATH. Install: npm install -g ${pkg}`);
@@ -37352,15 +37907,15 @@ var init_supervisor = __esm({
         const child = state.child;
         if (!child)
           return;
-        return new Promise((resolve8) => {
-          const onExit = () => resolve8();
+        return new Promise((resolve9) => {
+          const onExit = () => resolve9();
           child.once("exit", onExit);
           try {
             child.kill("SIGTERM");
           } catch (err) {
             this.log.warn(`SIGTERM ${state.agentId} threw: ${String(err)}`);
             child.off("exit", onExit);
-            resolve8();
+            resolve9();
             return;
           }
           const hardKill = setTimeout(() => {
@@ -37578,7 +38133,7 @@ var init_daemon_main = __esm({
 init_daemon_paths();
 init_daemon_update_mode();
 import * as fs14 from "node:fs";
-import * as path18 from "node:path";
+import * as path20 from "node:path";
 var UPDATE_EXIT_CODE2 = 42;
 function formatError2(reason) {
   if (reason instanceof Error) {
@@ -37603,7 +38158,7 @@ function clearRunningMarker(markerPath) {
 }
 function prepareDaemonBootstrap(env = process.env, args = process.argv.slice(2)) {
   const bundleDir = resolveBundleDir(env);
-  const runningMarker = path18.join(bundleDir, "daemon-running");
+  const runningMarker = path20.join(bundleDir, "daemon-running");
   const lifecycleMarkerEnabled = args.length === 0 && !isSelfUpdateDisabledByEnv(env) && isSelfUpdateManaged(bundleDir, env);
   if (!lifecycleMarkerEnabled) {
     return { lifecycleMarkerEnabled: false, runningMarker, uncleanPrevExit: false };