diff --git a/pressure-vessel/runtime.c b/pressure-vessel/runtime.c
index b8e245a3245c836a36dd356002e1e90f306e1b01..64be4c2ba97c03e368d027c25fe2508ea87bdc2a 100644
--- a/pressure-vessel/runtime.c
+++ b/pressure-vessel/runtime.c
@@ -1143,15 +1143,18 @@ pv_runtime_new (const char *source_files,
  * and rely on bubblewrap's init process for this, but we currently
  * can't do that without breaking gameoverlayrender.so's assumptions,
  * and we want -adverb for its locale functionality anyway. */
-gchar *
+gboolean
 pv_runtime_get_adverb (PvRuntime *self,
                        FlatpakBwrap *bwrap)
 {
-  g_return_val_if_fail (PV_IS_RUNTIME (self), NULL);
+  g_return_val_if_fail (PV_IS_RUNTIME (self), FALSE);
   /* This will be true if pv_runtime_bind() was successfully called. */
-  g_return_val_if_fail (self->adverb_in_container != NULL, NULL);
-  g_return_val_if_fail (bwrap != NULL, NULL);
-  g_return_val_if_fail (!pv_bwrap_was_finished (bwrap), NULL);
+  g_return_val_if_fail (self->adverb_in_container != NULL, FALSE);
+  g_return_val_if_fail (bwrap != NULL, FALSE);
+  g_return_val_if_fail (flatpak_bwrap_is_empty (bwrap), FALSE);
+  g_return_val_if_fail (!pv_bwrap_was_finished (bwrap), FALSE);
+
+  flatpak_bwrap_add_arg (bwrap, self->adverb_in_container);
 
   if (self->flags & PV_RUNTIME_FLAGS_GENERATE_LOCALES)
     flatpak_bwrap_add_args (bwrap, "--generate-locales", NULL);
@@ -1190,7 +1193,7 @@ pv_runtime_get_adverb (PvRuntime *self,
                               NULL);
     }
 
-  return g_strdup (self->adverb_in_container);
+  return TRUE;
 }
 
 /*
diff --git a/pressure-vessel/runtime.h b/pressure-vessel/runtime.h
index 1d8ede2adda4854b96020aec7c3504fe7475c41e..1d4d4ea33e0de221ef3f56619735b0580eccfde7 100644
--- a/pressure-vessel/runtime.h
+++ b/pressure-vessel/runtime.h
@@ -80,8 +80,8 @@ PvRuntime *pv_runtime_new (const char *source_files,
                            PvRuntimeFlags flags,
                            GError **error);
 
-gchar *pv_runtime_get_adverb (PvRuntime *self,
-                              FlatpakBwrap *adverb_args);
+gboolean pv_runtime_get_adverb (PvRuntime *self,
+                                FlatpakBwrap *adverb_args);
 gboolean pv_runtime_bind (PvRuntime *self,
                           FlatpakExports *exports,
                           FlatpakBwrap *bwrap,
diff --git a/pressure-vessel/wrap.c b/pressure-vessel/wrap.c
index cec7d2e26288ddcad8f8e300cdf1ab455b8ff010..a541ae7e3a140c39db45e18fb4c591a5de090b6b 100644
--- a/pressure-vessel/wrap.c
+++ b/pressure-vessel/wrap.c
@@ -1213,8 +1213,6 @@ main (int argc,
   gboolean is_flatpak_env = g_file_test ("/.flatpak-info", G_FILE_TEST_IS_REGULAR);
   g_autoptr(FlatpakBwrap) bwrap = NULL;
   g_autoptr(FlatpakExports) exports = NULL;
-  g_autoptr(FlatpakBwrap) adverb_args = NULL;
-  g_autofree gchar *adverb_in_container = NULL;
   g_autoptr(FlatpakBwrap) wrapped_command = NULL;
   g_autofree gchar *launch_executable = NULL;
   g_autofree gchar *bwrap_executable = NULL;
@@ -2196,106 +2194,116 @@ main (int argc,
         goto out;
     }
 
-  adverb_args = flatpak_bwrap_new (flatpak_bwrap_empty_env);
+  /* Set up adverb inside container */
+    {
+      g_autoptr(FlatpakBwrap) adverb_argv = NULL;
 
-  if (runtime != NULL)
-    adverb_in_container = pv_runtime_get_adverb (runtime, adverb_args);
+      adverb_argv = flatpak_bwrap_new (flatpak_bwrap_empty_env);
 
-  if (opt_terminate_timeout >= 0.0)
-    {
-      if (opt_terminate_idle_timeout > 0.0)
-        flatpak_bwrap_add_arg_printf (adverb_args,
-                                      "--terminate-idle-timeout=%f",
-                                      opt_terminate_idle_timeout);
+      if (runtime != NULL)
+        {
+          if (!pv_runtime_get_adverb (runtime, adverb_argv))
+            goto out;
+        }
+      else
+        {
+          /* If not using a runtime, the adverb in the container has the
+           * same path as outside */
+          g_autofree gchar *adverb_in_container =
+            g_build_filename (tools_dir, "pressure-vessel-adverb", NULL);
 
-      flatpak_bwrap_add_arg_printf (adverb_args,
-                                    "--terminate-timeout=%f",
-                                    opt_terminate_timeout);
-    }
+          flatpak_bwrap_add_arg (adverb_argv, adverb_in_container);
+        }
 
-  /* If not using a runtime, the adverb in the container has the
-   * same path as outside */
-  if (adverb_in_container == NULL)
-    adverb_in_container = g_build_filename (tools_dir,
-                                            "pressure-vessel-adverb",
-                                            NULL);
+      if (opt_terminate_timeout >= 0.0)
+        {
+          if (opt_terminate_idle_timeout > 0.0)
+            flatpak_bwrap_add_arg_printf (adverb_argv,
+                                          "--terminate-idle-timeout=%f",
+                                          opt_terminate_idle_timeout);
+
+          flatpak_bwrap_add_arg_printf (adverb_argv,
+                                        "--terminate-timeout=%f",
+                                        opt_terminate_timeout);
+        }
 
-  flatpak_bwrap_add_args (bwrap,
-                          adverb_in_container,
-                          "--exit-with-parent",
-                          "--subreaper",
-                          NULL);
+      flatpak_bwrap_add_args (adverb_argv,
+                              "--exit-with-parent",
+                              "--subreaper",
+                              NULL);
 
-  if (opt_pass_fds != NULL)
-    {
-      for (i = 0; i < opt_pass_fds->len; i++)
+      if (opt_pass_fds != NULL)
         {
-          int fd = g_array_index (opt_pass_fds, int, i);
+          for (i = 0; i < opt_pass_fds->len; i++)
+            {
+              int fd = g_array_index (opt_pass_fds, int, i);
 
-          flatpak_bwrap_add_fd (bwrap, fd);
-          flatpak_bwrap_add_arg_printf (bwrap, "--pass-fd=%d", fd);
+              flatpak_bwrap_add_fd (adverb_argv, fd);
+              flatpak_bwrap_add_arg_printf (adverb_argv, "--pass-fd=%d", fd);
+            }
         }
-    }
 
-  for (i = 0; i < pass_fds_through_adverb->len; i++)
-    {
-      int fd = g_array_index (pass_fds_through_adverb, int, i);
+      for (i = 0; i < pass_fds_through_adverb->len; i++)
+        {
+          int fd = g_array_index (pass_fds_through_adverb, int, i);
 
-      flatpak_bwrap_add_arg_printf (bwrap, "--pass-fd=%d", fd);
-    }
+          flatpak_bwrap_add_arg_printf (adverb_argv, "--pass-fd=%d", fd);
+        }
 
-  flatpak_bwrap_add_arg_printf (bwrap, "--pass-fd=%s", lock_env_fd);
+      flatpak_bwrap_add_arg_printf (adverb_argv, "--pass-fd=%s", lock_env_fd);
 
-  switch (opt_shell)
-    {
-      case PV_SHELL_AFTER:
-        flatpak_bwrap_add_arg (bwrap, "--shell=after");
-        break;
+      switch (opt_shell)
+        {
+          case PV_SHELL_AFTER:
+            flatpak_bwrap_add_arg (adverb_argv, "--shell=after");
+            break;
 
-      case PV_SHELL_FAIL:
-        flatpak_bwrap_add_arg (bwrap, "--shell=fail");
-        break;
+          case PV_SHELL_FAIL:
+            flatpak_bwrap_add_arg (adverb_argv, "--shell=fail");
+            break;
 
-      case PV_SHELL_INSTEAD:
-        flatpak_bwrap_add_arg (bwrap, "--shell=instead");
-        break;
+          case PV_SHELL_INSTEAD:
+            flatpak_bwrap_add_arg (adverb_argv, "--shell=instead");
+            break;
 
-      case PV_SHELL_NONE:
-        flatpak_bwrap_add_arg (bwrap, "--shell=none");
-        break;
+          case PV_SHELL_NONE:
+            flatpak_bwrap_add_arg (adverb_argv, "--shell=none");
+            break;
 
-      default:
-        g_warn_if_reached ();
-    }
+          default:
+            g_warn_if_reached ();
+        }
 
-  switch (opt_terminal)
-    {
-      case PV_TERMINAL_AUTO:
-        flatpak_bwrap_add_arg (bwrap, "--terminal=auto");
-        break;
+      switch (opt_terminal)
+        {
+          case PV_TERMINAL_AUTO:
+            flatpak_bwrap_add_arg (adverb_argv, "--terminal=auto");
+            break;
 
-      case PV_TERMINAL_NONE:
-        flatpak_bwrap_add_arg (bwrap, "--terminal=none");
-        break;
+          case PV_TERMINAL_NONE:
+            flatpak_bwrap_add_arg (adverb_argv, "--terminal=none");
+            break;
 
-      case PV_TERMINAL_TTY:
-        flatpak_bwrap_add_arg (bwrap, "--terminal=tty");
-        break;
+          case PV_TERMINAL_TTY:
+            flatpak_bwrap_add_arg (adverb_argv, "--terminal=tty");
+            break;
 
-      case PV_TERMINAL_XTERM:
-        flatpak_bwrap_add_arg (bwrap, "--terminal=xterm");
-        break;
+          case PV_TERMINAL_XTERM:
+            flatpak_bwrap_add_arg (adverb_argv, "--terminal=xterm");
+            break;
 
-      default:
-        g_warn_if_reached ();
-        break;
-    }
+          default:
+            g_warn_if_reached ();
+            break;
+        }
 
-  if (opt_verbose)
-    flatpak_bwrap_add_arg (bwrap, "--verbose");
+      if (opt_verbose)
+        flatpak_bwrap_add_arg (adverb_argv, "--verbose");
 
-  flatpak_bwrap_append_bwrap (bwrap, adverb_args);
-  flatpak_bwrap_add_arg (bwrap, "--");
+      flatpak_bwrap_add_arg (adverb_argv, "--");
+
+      flatpak_bwrap_append_bwrap (bwrap, adverb_argv);
+    }
 
   if (opt_launcher)
     {