@vtxmacro/cli 2026.9.51 → 2026.9.52

package/README.md

@@ -21,9 +21,11 @@ service start, and periodically while running, it checks the official npm regist
 and verifies the exact release integrity and installed CLI version in a new
 versioned directory. Before switching, it stops new admission and lets active
 Provider calls and Agent turns finish while keeping heartbeats alive. It selects
-the candidate only after every configured worker reports ready. A
-failed candidate is rejected and the last working runtime resumes. The service
-keeps only the active release and one rollback release. If the update check is
+the candidate only after every configured worker reports ready. A stable recovery
+launcher starts the versioned updater and keeps the previous working release.
+Routine updates do not replace this recovery launcher. If activation fails or
+the updated process exits unexpectedly, it rejects that release and restores the
+previous runtime. The service keeps the active release and its recovery release. If the update check is
 unavailable, it keeps the last verified runtime. An intentionally stopped
 service stays stopped and makes no update request. Hosts installed before this
 private launcher need one final normal npm update and service reinstall to

package/bin/vtx-service-bootstrap.js

@@ -2,21 +2,21 @@
 import { spawn as spawn2 } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import {
-  access,
+  access as access2,
   appendFile,
   mkdir as mkdir2,
-  readFile as readFile2,
+  readFile as readFile3,
   readdir,
   rename as rename2,
-  rm as rm2
+  rm as rm3
 } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, win32 as windowsPath2 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3, relative as relative3, resolve as resolve3, win32 as windowsPath2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.51",
+  package_version: "2026.9.52",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",
@@ -207,6 +207,8 @@ var runtime_policy_generated_default = {
     service: {
       update_check_interval_ms: 3e5,
       update_registry_timeout_ms: 15e3,
+      bootstrap_readiness_timeout_ms: 6e5,
+      bootstrap_stop_timeout_ms: 1e4,
       startup_max_attempts: 40,
       startup_poll_interval_ms: 250,
       restart_stable_uptime_ms: 6e4,
@@ -289,6 +291,10 @@ var runtime_policy_generated_default = {
   }
 };
 
+// lib/inference-host/service-launcher-state.ts
+import { access, readFile as readFile2, rm as rm2 } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+
 // lib/inference-host/config.ts
 import { randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
@@ -899,7 +905,7 @@ var WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES = /* @__PURE__ */ new Set([
 async function replaceAtomicInferencePrivateFile(temporaryPath, destinationPath, options = {}) {
   const platform = options.platform ?? process.platform;
   const renameFile = options.renameFile ?? rename;
-  const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve3) => setTimeout(resolve3, milliseconds)));
+  const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve4) => setTimeout(resolve4, milliseconds)));
   const maxAttempts = Math.max(1, options.maxAttempts ?? 40);
   const retryDelayMs = Math.max(0, options.retryDelayMs ?? 25);
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
@@ -1150,19 +1156,58 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
   };
 }
 
+// lib/inference-host/service-launcher-state.ts
+var launcherSibling = (manifest, suffix) => {
+  if (!manifest.endsWith(".service.json")) throw new Error("Invalid service manifest path.");
+  return `${manifest.slice(0, -".service.json".length)}${suffix}`;
+};
+var within = (parent, child) => {
+  const part = relative2(resolve2(parent), resolve2(child));
+  return Boolean(part) && !part.startsWith("..") && !isAbsolute2(part);
+};
+var launcherSelection = (manifest, value) => {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (r.schema_version !== "vtx_inference_service_release_v1" || r.package_name !== "@vtxmacro/cli" || typeof r.package_version !== "string" || !/^\d{4}\.\d{1,2}\.\d{1,3}$/u.test(r.package_version) || typeof r.integrity !== "string" || typeof r.selected_at !== "string" || !Number.isFinite(Date.parse(r.selected_at)) || typeof r.script !== "string" || !isAbsolute2(r.script) || /[\r\n\0]/u.test(r.script) || !within(launcherSibling(manifest, ".service-releases"), r.script)) return null;
+  return r;
+};
+var readLauncherState = async (manifest) => {
+  let value;
+  try {
+    value = JSON.parse(await readFile2(launcherSibling(manifest, ".service-launcher.json"), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  if (!value || typeof value !== "object") throw new Error("Invalid service launcher state.");
+  const r = value;
+  const target = (v) => {
+    if (!v || typeof v !== "object") return false;
+    const t = v;
+    return typeof t.package_version === "string" && /^\d{4}\.\d{1,2}\.\d{1,3}$/u.test(t.package_version) && typeof t.script === "string" && isAbsolute2(t.script) && !/[\r\n\0]/u.test(t.script) && (within(launcherSibling(manifest, ".service-releases"), t.script) || resolve2(t.script) === resolve2(launcherSibling(manifest, ".service-bootstrap.previous.js"))) && (t.selection === null || (() => {
+      const selected = launcherSelection(manifest, t.selection);
+      return Boolean(selected && selected.package_version === t.package_version && (resolve2(t.script) === resolve2(join2(dirname2(selected.script), "vtx-service-bootstrap.js")) || resolve2(t.script) === resolve2(launcherSibling(manifest, ".service-bootstrap.previous.js"))));
+    })());
+  };
+  if (r.schema_version !== "vtx_inference_service_launcher_v1" || !target(r.active) || r.previous !== null && !target(r.previous) || typeof r.pending !== "boolean") {
+    throw new Error("Invalid service launcher recovery targets.");
+  }
+  return r;
+};
+
 // lib/inference-host/service-bootstrap.ts
 var OFFICIAL_NPM_REGISTRY = "https://registry.npmjs.org";
 var PACKAGE_NAME = "@vtxmacro/cli";
 var UPDATE_ATTEMPTS = 3;
 var UPDATE_RETRY_MS = 2e3;
-var CANDIDATE_READINESS_TIMEOUT_MS = 10 * 60 * 1e3;
+var CANDIDATE_READINESS_TIMEOUT_MS = runtime_policy_generated_default.external_inference.service.bootstrap_readiness_timeout_ms;
 var SERVICE_DRAIN_COMMAND = "vtx-inference-host-service-drain-v1";
 var SERVICE_QUIESCE_COMMAND = "vtx-inference-host-service-quiesce-v1";
 var safePath = (value, label) => {
   if (typeof value !== "string" || !value || /[\r\n\0]/u.test(value)) {
     throw new Error(`Inference-host bootstrap ${label} is invalid.`);
   }
-  return resolve2(value);
+  return resolve3(value);
 };
 var parseManifest = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -1201,7 +1246,7 @@ var releasesPathFor = (manifestPath) => serviceSiblingPath(manifestPath, ".servi
 var rejectionPathFor = (manifestPath) => serviceSiblingPath(manifestPath, ".service-release-rejection.json");
 var runtimePathFor = (manifestPath) => serviceSiblingPath(manifestPath, ".service-runtime.json");
 var readDesired = async (manifestPath) => {
-  const value = JSON.parse(await readFile2(desiredPathFor(manifestPath), "utf8"));
+  const value = JSON.parse(await readFile3(desiredPathFor(manifestPath), "utf8"));
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Inference-host bootstrap desired state is invalid.");
   }
@@ -1231,17 +1276,17 @@ var compareInferenceHostReleaseVersions = (left, right) => {
   return 0;
 };
 var isPathWithin = (parent, child) => {
-  const childRelative = relative2(resolve2(parent), resolve2(child));
-  return childRelative !== "" && !childRelative.startsWith("..") && !isAbsolute2(childRelative);
+  const childRelative = relative3(resolve3(parent), resolve3(child));
+  return childRelative !== "" && !childRelative.startsWith("..") && !isAbsolute3(childRelative);
 };
 var parseSelection = async (manifestPath) => {
   try {
-    const value = JSON.parse(await readFile2(selectionPathFor(manifestPath), "utf8"));
+    const value = JSON.parse(await readFile3(selectionPathFor(manifestPath), "utf8"));
     if (!value || typeof value !== "object" || Array.isArray(value)) return null;
     const record = value;
     const script = safePath(record.script, "selected script");
     if (record.schema_version !== "vtx_inference_service_release_v1" || record.package_name !== PACKAGE_NAME || typeof record.package_version !== "string" || !parseVersion(record.package_version) || typeof record.integrity !== "string" || typeof record.selected_at !== "string" || !Number.isFinite(Date.parse(record.selected_at)) || !isPathWithin(releasesPathFor(manifestPath), script)) return null;
-    await access(script);
+    await access2(script);
     return record;
   } catch (error) {
     if (error.code === "ENOENT") return null;
@@ -1250,7 +1295,7 @@ var parseSelection = async (manifestPath) => {
 };
 var parseRejection = async (manifestPath) => {
   try {
-    const value = JSON.parse(await readFile2(rejectionPathFor(manifestPath), "utf8"));
+    const value = JSON.parse(await readFile3(rejectionPathFor(manifestPath), "utf8"));
     if (!value || typeof value !== "object" || Array.isArray(value)) return null;
     const record = value;
     if (record.schema_version !== "vtx_inference_service_release_rejection_v1" || typeof record.package_version !== "string" || !parseVersion(record.package_version) || typeof record.rejected_at !== "string" || !Number.isFinite(Date.parse(record.rejected_at)) || typeof record.reason !== "string" || !/^[a-z0-9_]{1,96}$/u.test(record.reason)) return null;
@@ -1289,7 +1334,7 @@ var defaultRunCommand = async (command, args) => await new Promise((resolvePromi
   }));
 });
 var runInferenceHostBootstrapNpmCommand = async (executable, args, platform = process.platform, runCommand = defaultRunCommand) => {
-  if (platform !== "win32") return await runCommand(join2(dirname2(executable), "npm"), args);
+  if (platform !== "win32") return await runCommand(join3(dirname3(executable), "npm"), args);
   const npmScript = windowsPath2.join(
     windowsPath2.dirname(executable),
     "node_modules",
@@ -1328,7 +1373,7 @@ var defaultRunSupervisor = (executable, args) => {
   };
 };
 var appendBootstrapLog = async (path, event, fields = {}) => {
-  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  await mkdir2(dirname3(path), { recursive: true, mode: 448 });
   await appendFile(
     path,
     `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), event, ...fields })}
@@ -1363,7 +1408,7 @@ var verifyIntegrity = async (tarballPath, integrity) => {
   }).filter((entry) => entry !== null);
   const supported = ["sha512", "sha384", "sha256"].map((algorithm) => candidates.find((candidate) => candidate.algorithm === algorithm)).find(Boolean);
   if (!supported) throw new Error("release_integrity_unsupported");
-  const actual = createHash(supported.algorithm).update(await readFile2(tarballPath)).digest("base64");
+  const actual = createHash(supported.algorithm).update(await readFile3(tarballPath)).digest("base64");
   if (actual !== supported.digest) throw new Error("release_integrity_mismatch");
 };
 var atomicWriteSelection = async (manifestPath, selection) => {
@@ -1383,9 +1428,9 @@ var verifyInstalledRelease = async (prefix, targetVersion, executable, platform,
   if (rootResult.exitCode !== 0 || !rootResult.stdout.trim()) {
     throw new Error("release_install_invalid");
   }
-  const packagePath = resolve2(rootResult.stdout.trim(), PACKAGE_NAME);
+  const packagePath = resolve3(rootResult.stdout.trim(), PACKAGE_NAME);
   if (!isPathWithin(prefix, packagePath)) throw new Error("release_install_invalid");
-  const packageJson = JSON.parse(await readFile2(join2(packagePath, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile3(join3(packagePath, "package.json"), "utf8"));
   if (!packageJson || typeof packageJson !== "object" || Array.isArray(packageJson)) {
     throw new Error("release_install_invalid");
   }
@@ -1393,9 +1438,9 @@ var verifyInstalledRelease = async (prefix, targetVersion, executable, platform,
   const bin = packageRecord.bin;
   const binPath = bin && typeof bin === "object" && !Array.isArray(bin) ? bin.vtx : null;
   if (packageRecord.name !== PACKAGE_NAME || packageRecord.version !== targetVersion || typeof binPath !== "string") throw new Error("release_install_invalid");
-  const script = resolve2(packagePath, binPath);
+  const script = resolve3(packagePath, binPath);
   if (!isPathWithin(packagePath, script)) throw new Error("release_install_invalid");
-  await access(script);
+  await access2(script);
   const verified = await runCommand(executable, [script, "--version"]);
   if (verified.exitCode !== 0 || verified.stdout.trim() !== targetVersion) {
     throw new Error("release_version_verification_failed");
@@ -1406,19 +1451,19 @@ var cleanupInterruptedReleaseStaging = async (releasesPath) => {
   const entries = await readdir(releasesPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && /^\.(?:staging|download)-\d{4}\.\d{1,2}\.\d{1,3}-[0-9a-f-]{36}$/u.test(entry.name)) {
-      await rm2(resolve2(releasesPath, entry.name), { recursive: true, force: true });
+      await rm3(resolve3(releasesPath, entry.name), { recursive: true, force: true });
     }
   }
 };
 var stageRelease = async (manifestPath, target, executable, platform, runCommand, now) => {
   const releasesPath = releasesPathFor(manifestPath);
-  const finalPath = join2(releasesPath, target.version);
-  const stagingPath = join2(releasesPath, `.staging-${target.version}-${randomUUID()}`);
-  const downloadPath = join2(releasesPath, `.download-${target.version}-${randomUUID()}`);
+  const finalPath = join3(releasesPath, target.version);
+  const stagingPath = join3(releasesPath, `.staging-${target.version}-${randomUUID()}`);
+  const downloadPath = join3(releasesPath, `.download-${target.version}-${randomUUID()}`);
   await mkdir2(releasesPath, { recursive: true, mode: 448 });
   await cleanupInterruptedReleaseStaging(releasesPath);
   try {
-    await access(finalPath);
+    await access2(finalPath);
     const existingScript = await verifyInstalledRelease(
       finalPath,
       target.version,
@@ -1458,7 +1503,7 @@ var stageRelease = async (manifestPath, target, executable, platform, runCommand
     } catch {
       throw new Error("release_download_invalid");
     }
-    const tarballPath = resolve2(downloadPath, filename);
+    const tarballPath = resolve3(downloadPath, filename);
     if (!filename || !isPathWithin(downloadPath, tarballPath)) {
       throw new Error("release_download_invalid");
     }
@@ -1488,7 +1533,7 @@ var stageRelease = async (manifestPath, target, executable, platform, runCommand
       if (error.code !== "EEXIST") throw error;
       throw new Error("release_path_already_exists");
     }
-    const finalScript = resolve2(finalPath, relative2(stagingPath, stagedScript));
+    const finalScript = resolve3(finalPath, relative3(stagingPath, stagedScript));
     const selection = {
       schema_version: "vtx_inference_service_release_v1",
       package_name: PACKAGE_NAME,
@@ -1499,8 +1544,8 @@ var stageRelease = async (manifestPath, target, executable, platform, runCommand
     };
     return selection;
   } finally {
-    await rm2(stagingPath, { recursive: true, force: true }).catch(() => void 0);
-    await rm2(downloadPath, { recursive: true, force: true }).catch(() => void 0);
+    await rm3(stagingPath, { recursive: true, force: true }).catch(() => void 0);
+    await rm3(downloadPath, { recursive: true, force: true }).catch(() => void 0);
   }
 };
 var updateSelection = async (manifestPath, manifest, dependencies) => {
@@ -1546,8 +1591,8 @@ var waitForCandidateReadiness = async (manifestPath, candidate, signal, timeoutM
   while (!signal.aborted && Date.now() < deadline) {
     if (!await readDesired(manifestPath)) return "aborted";
     try {
-      const currentManifest = parseManifest(JSON.parse(await readFile2(manifestPath, "utf8")));
-      const value = JSON.parse(await readFile2(runtimePathFor(manifestPath), "utf8"));
+      const currentManifest = parseManifest(JSON.parse(await readFile3(manifestPath, "utf8")));
+      const value = JSON.parse(await readFile3(runtimePathFor(manifestPath), "utf8"));
       if (value && typeof value === "object" && !Array.isArray(value)) {
         const runtime = value;
         const workers = Array.isArray(runtime.workers) ? runtime.workers : [];
@@ -1563,8 +1608,10 @@ var waitForCandidateReadiness = async (manifestPath, candidate, signal, timeoutM
 };
 var prunePrivateReleases = async (manifestPath, keep) => {
   const releasesPath = releasesPathFor(manifestPath);
+  const recovery = await readLauncherState(manifestPath);
+  const retained = [...keep, recovery?.active.selection ?? null, recovery?.previous?.selection ?? null];
   const keepPaths = new Set(
-    keep.filter((item) => item !== null).map((item) => resolve2(item.script)).filter((script) => isPathWithin(releasesPath, script)).map((script) => resolve2(releasesPath, relative2(releasesPath, script).split(/[\\/]/u)[0]))
+    retained.filter((item) => item !== null).map((item) => resolve3(item.script)).filter((script) => isPathWithin(releasesPath, script)).map((script) => resolve3(releasesPath, relative3(releasesPath, script).split(/[\\/]/u)[0]))
   );
   let entries;
   try {
@@ -1575,9 +1622,9 @@ var prunePrivateReleases = async (manifestPath, keep) => {
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || !parseVersion(entry.name)) continue;
-    const releasePath = resolve2(releasesPath, entry.name);
+    const releasePath = resolve3(releasesPath, entry.name);
     if (!keepPaths.has(releasePath)) {
-      await rm2(releasePath, { recursive: true, force: true });
+      await rm3(releasePath, { recursive: true, force: true });
     }
   }
 };
@@ -1602,7 +1649,7 @@ var waitForUpdateCheck = async (milliseconds, signal) => {
   });
 };
 var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies = {}, lockPathValue) => {
-  const manifestPath = resolve2(manifestPathValue);
+  const manifestPath = resolve3(manifestPathValue);
   const lockPath = safePath(
     lockPathValue ?? serviceSiblingPath(manifestPath, ".service-bootstrap.lock"),
     "lock path"
@@ -1618,11 +1665,16 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
     }
   };
   dependencies.signal?.addEventListener("abort", stop, { once: true });
+  const launcherStop = (message) => {
+    if (message && typeof message === "object" && message.type === "vtx-inference-host-launcher-stop-v1") stop();
+  };
+  process.on("message", launcherStop);
+  if (process.env.VTX_INFERENCE_HOST_LAUNCHER_PROTOCOL === "1") process.on("disconnect", stop);
   process.on("SIGTERM", stop);
   process.on("SIGINT", stop);
   if (dependencies.signal?.aborted) stop();
   try {
-    let manifest = parseManifest(JSON.parse(await readFile2(manifestPath, "utf8")));
+    let manifest = parseManifest(JSON.parse(await readFile3(manifestPath, "utf8")));
     const shouldRun = async () => !lifetime.signal.aborted && await readDesired(manifestPath);
     if (!await shouldRun()) {
       await appendBootstrapLog(manifest.log_path, "service_bootstrap_stopped");
@@ -1642,7 +1694,7 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
       signal: lifetime.signal
     };
     const checkUpdate = async () => {
-      manifest = parseManifest(JSON.parse(await readFile2(manifestPath, "utf8")));
+      manifest = parseManifest(JSON.parse(await readFile3(manifestPath, "utf8")));
       const active = await parseSelection(manifestPath);
       try {
         return await updateSelection(manifestPath, manifest, updateDependencies);
@@ -1653,16 +1705,18 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
         return { active, candidate: null };
       }
     };
+    let launchedAt = now().toISOString();
     const launch = async (selection) => {
-      manifest = parseManifest(JSON.parse(await readFile2(manifestPath, "utf8")));
+      manifest = parseManifest(JSON.parse(await readFile3(manifestPath, "utf8")));
       const script = selection?.script ?? manifest.script;
-      await access(manifest.executable);
-      await access(script);
+      await access2(manifest.executable);
+      await access2(script);
       if (!await shouldRun()) return null;
       await appendBootstrapLog(manifest.log_path, "service_bootstrap_launch", {
         package_version: selection?.package_version ?? agent_cli_release_default.package_version
       });
       if (!await shouldRun()) return null;
+      launchedAt = now().toISOString();
       live.supervisor = runSupervisor(manifest.executable, supervisorArguments(script, manifestPath));
       return live.supervisor;
     };
@@ -1670,7 +1724,7 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
     while (await shouldRun()) {
       if (updatePlan.candidate) {
         const candidate = { ...updatePlan.candidate, selected_at: now().toISOString() };
-        await rm2(runtimePathFor(manifestPath), { force: true });
+        await rm3(runtimePathFor(manifestPath), { force: true });
         await appendBootstrapLog(manifest.log_path, "service_release_candidate_started", {
           package_version: candidate.package_version
         });
@@ -1696,7 +1750,7 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
           ]);
           if (first.kind === "ready" && await shouldRun()) {
             await atomicWriteSelection(manifestPath, candidate);
-            await rm2(rejectionPathFor(manifestPath), { force: true }).catch(() => void 0);
+            await rm3(rejectionPathFor(manifestPath), { force: true }).catch(() => void 0);
             await prunePrivateReleases(manifestPath, [candidate, updatePlan.active]).catch(
               async () => await appendBootstrapLog(
                 manifest.log_path,
@@ -1750,6 +1804,24 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
       }
       const supervisor = live.supervisor ?? await launch(updatePlan.active);
       if (!supervisor) return 0;
+      if (process.env.VTX_INFERENCE_HOST_LAUNCHER_PROTOCOL === "1" && process.send) {
+        const readiness = new AbortController();
+        const cancel = () => readiness.abort();
+        lifetime.signal.addEventListener("abort", cancel, { once: true });
+        void waitForCandidateReadiness(manifestPath, {
+          ...updatePlan.active ?? {
+            schema_version: "vtx_inference_service_release_v1",
+            package_name: PACKAGE_NAME,
+            package_version: agent_cli_release_default.package_version,
+            integrity: "",
+            script: manifest.script
+          },
+          selected_at: launchedAt
+        }, readiness.signal, dependencies.readinessTimeoutMs ?? CANDIDATE_READINESS_TIMEOUT_MS).then((status) => {
+          if (status === "ready" && process.connected) process.send?.({ type: "vtx-inference-host-bootstrap-ready-v1", package_version: agent_cli_release_default.package_version }, () => void 0);
+        }).catch(() => void 0).finally(() => lifetime.signal.removeEventListener("abort", cancel));
+        void supervisor.completion.finally(cancel).catch(() => void 0);
+      }
       let exited = false;
       const completion = supervisor.completion.then(
         (exitCode) => {
@@ -1817,12 +1889,14 @@ var runInferenceHostServiceBootstrap = async (manifestPathValue, dependencies =
       await live.supervisor.completion.catch(() => 1);
     }
     dependencies.signal?.removeEventListener("abort", stop);
+    process.removeListener("message", launcherStop);
+    process.removeListener("disconnect", stop);
     process.removeListener("SIGTERM", stop);
     process.removeListener("SIGINT", stop);
     await lock.release();
   }
 };
-var invokedPath = process.argv[1] ? resolve2(process.argv[1]) : "";
+var invokedPath = process.argv[1] ? resolve3(process.argv[1]) : "";
 if (invokedPath === fileURLToPath(import.meta.url)) {
   const manifestIndex = process.argv.indexOf("--service-manifest");
   const lockIndex = process.argv.indexOf("--service-lock");