@@ -418,6 +418,10 @@ try (OnlineQueryMultiResult multi = client.onlineQueryMulti(List.of(users, merch
             // this query failed; the others are unaffected
             continue;
         }
+        if (result.getScalarsTable() == null) {
+            // this query never ran -- see getGlobalErrors() above for the reason
+            continue;
+        }
         // do something with the result
     }
 }
@@ -437,8 +441,10 @@ A few things to know:
 - **Close the wrapper, not the results.** Closing the `OnlineQueryMultiResult` closes every one of
   its results and releases all of their Arrow memory.
 - **Some settings apply to the whole request,** which carries one deadline and one set of headers.
-  Every query must agree on `environmentId`, `branch`, `queryName` and `queryNameVersion`, or the
-  call throws `ClientException` — a request resolves one branch to one deployment and routes named
-  queries by an exact match on the query name, so a mixed batch could not be honored. Run those as
-  separate queries. The deadline is the longest of the per-query timeouts, falling back to the
+  Every query must agree on `environmentId`, `branch` and `queryName`, or the call throws
+  `ClientException` — a request resolves one branch to one deployment and routes named queries by
+  an exact match on the query name, so a mixed batch could not be honored. Run those as separate
+  queries. Leaving one of these unset just takes the client's value, which is not a disagreement,
+  and `queryNameVersion` may differ freely since each query carries its own. The deadline is the
+  longest of the effective per-query timeouts, where a query that sets none is bounded by the
   client-level timeout, so per-query timeouts are not independently enforced.
@@ -188,15 +188,17 @@ default int ping() throws ChalkException {
      * <p> <b>Some settings apply to the whole request.</b> A request carries one
      * deadline and one set of headers, so:
      * <ul>
-     *   <li>Every query must agree on {@code environmentId}, {@code branch},
-     *       {@code queryName} and {@code queryNameVersion}. A disagreement throws
+     *   <li>Every query must agree on {@code environmentId}, {@code branch} and
+     *       {@code queryName}. A disagreement throws
      *       {@link ai.chalk.exceptions.ClientException}, because a request resolves
      *       one branch to one deployment and routes named queries by an exact match
      *       on the query name, so a mixed batch could not be honored. Run those as
-     *       separate queries.</li>
-     *   <li>The deadline is the longest of the per-query timeouts, falling back to
-     *       the client-level timeout. Per-query timeouts are not independently
-     *       enforced.</li>
+     *       separate queries. A query that leaves one of these unset simply takes the
+     *       client's value, which is not a disagreement. {@code queryNameVersion} may
+     *       differ freely: each query carries its own.</li>
+     *   <li>The deadline is the longest of the effective per-query timeouts, where a
+     *       query that sets none is bounded by the client-level timeout. Per-query
+     *       timeouts are not independently enforced.</li>
      *   <li>Branch selection is currently inert on the gRPC path for both single and
      *       multi queries: the client does not yet send the header the API server
      *       routes branches on.</li>
@@ -228,7 +230,7 @@ default OnlineQueryMultiResult onlineQueryMulti(List<OnlineQueryParamsComplete>
      */
     default OnlineQueryMultiResult onlineQueryMulti(OnlineQueryParamsComplete... params)
             throws ChalkException {
-        return onlineQueryMulti(Arrays.asList(params));
+        return onlineQueryMulti(params == null ? null : Arrays.asList(params));
     }
 
     /**
 
@@ -240,8 +240,8 @@ public OnlineQueryMultiResult onlineQueryMulti(List<OnlineQueryParamsComplete> p
 
         // Resolve the request-level settings before serializing anything, so a batch that
         // cannot be satisfied fails before doing the work of encoding its inputs.
-        Duration deadline = resolveDeadline(paramsList).orElse(null);
-        String environmentId = resolveEnvironment(paramsList);
+        Duration deadline = resolveDeadline(paramsList, this.timeout).orElse(null);
+        String environmentId = resolveEnvironment(paramsList, this.resolvedEnvironmentId);
         String queryName = resolveQueryName(paramsList);
         // Validated for agreement but deliberately unused: the gRPC client does not send the
         // "x-chalk-branch-id" header that the API server routes branches on, so branch
@@ -514,8 +514,7 @@ static OnlineQueryMultiResult decodeMultiResponse(
         // mismatch leaves every result unattributable. Fail rather than guess.
         if (response.getResponsesCount() != expectedCount) {
             throw new ClientException(String.format(
-                    "Expected %d sub-responses for %d queries, but got %d%s",
-                    expectedCount,
+                    "Expected %d sub-responses, one per query, but got %d%s",
                     expectedCount,
                     response.getResponsesCount(),
                     globalErrors.length == 0 ? "" : "; errors: " + describeErrors(globalErrors)
@@ -587,18 +586,30 @@ static void validateMultiParams(List<OnlineQueryParamsComplete> paramsList) thro
     }
 
     /**
-     * Resolves the deadline for the whole request as the longest of the per-query
-     * timeouts, so that no sub-query is cancelled before the time its caller
-     * allowed. Returns empty when no query sets one, which lets the client-level
-     * timeout apply. Per-query timeouts are not independently enforced: a single
+     * Resolves the deadline for the whole request as the longest of the effective
+     * per-query timeouts, so that no sub-query is cancelled before the time its
+     * caller allowed. Per-query timeouts are not independently enforced: a single
      * request carries a single deadline.
+     *
+     * <p> A query that sets no timeout of its own is bounded by the client-level
+     * timeout, so that is its effective timeout and it takes part in the maximum.
+     * Leaving it out would let one query's short timeout cut short a query that was
+     * relying on a longer client-level default. If any query is effectively
+     * unbounded -- it sets no timeout and the client sets none either -- the request
+     * gets no deadline.
      */
-    static Optional<Duration> resolveDeadline(List<OnlineQueryParamsComplete> paramsList) {
+    static Optional<Duration> resolveDeadline(
+            List<OnlineQueryParamsComplete> paramsList,
+            Optional<Duration> clientLevelTimeout
+    ) {
         Duration longest = null;
         for (OnlineQueryParamsComplete params : paramsList) {
-            Duration timeout = params.getTimeout();
+            Duration timeout = params.getTimeout() != null
+                    ? params.getTimeout()
+                    : clientLevelTimeout.orElse(null);
             if (timeout == null) {
-                continue;
+                // This query is unbounded, so the request cannot carry a deadline.
+                return Optional.empty();
             }
             if (longest == null || timeout.compareTo(longest) > 0) {
                 longest = timeout;
@@ -607,9 +618,17 @@ static Optional<Duration> resolveDeadline(List<OnlineQueryParamsComplete> params
         return Optional.ofNullable(longest);
     }
 
-    static @Nullable String resolveEnvironment(List<OnlineQueryParamsComplete> paramsList)
-            throws ClientException {
-        return requireAgreement(paramsList, OnlineQueryParamsComplete::getEnvironmentId, "environmentId");
+    static @Nullable String resolveEnvironment(
+            List<OnlineQueryParamsComplete> paramsList,
+            @Nullable String clientEnvironmentId
+    ) throws ClientException {
+        return requireAgreement(
+                paramsList,
+                params -> isBlank(params.getEnvironmentId())
+                        ? clientEnvironmentId
+                        : params.getEnvironmentId(),
+                "environmentId"
+        );
     }
 
     static @Nullable String resolveBranch(
@@ -623,11 +642,15 @@ static Optional<Duration> resolveDeadline(List<OnlineQueryParamsComplete> params
         );
     }
 
+    /*
+     * Only the name has to agree. Envoy route-matches named queries on the
+     * "x-chalk-query-name" header, of which the request has one. There is no
+     * corresponding header for the version -- each sub-request carries its own in its
+     * OnlineQueryContext -- so queries that differ only by version are satisfiable.
+     */
     static @Nullable String resolveQueryName(List<OnlineQueryParamsComplete> paramsList)
             throws ClientException {
-        String queryName = requireAgreement(paramsList, OnlineQueryParamsComplete::getQueryName, "queryName");
-        requireAgreement(paramsList, OnlineQueryParamsComplete::getQueryNameVersion, "queryNameVersion");
-        return queryName;
+        return requireAgreement(paramsList, OnlineQueryParamsComplete::getQueryName, "queryName");
     }
 
     /*
 
@@ -30,6 +30,17 @@ public class Unmarshaller {
     public static List<String> prefixToSkip = List.of(Constants.chalkDunderPrefix);
 
     public static <T extends FeaturesClass> T[] unmarshalOnlineQueryResult(OnlineQueryResult result, Class<T> target) throws ClientException {
+        if (result.getScalarsTable() == null) {
+            // No scalar data came back. For a multi-query this is what a sub-query that failed
+            // to execute leaves behind: an empty result whose reason sits in the multi-result's
+            // global errors rather than on the result itself.
+            throw new ClientException(
+                    "Cannot unmarshal an online query result that has no scalar data. Check "
+                            + "getErrors() on this result, and, if it came from onlineQueryMulti, "
+                            + "getGlobalErrors() on the OnlineQueryMultiResult -- a query that "
+                            + "failed to execute is reported there."
+            );
+        }
         try {
             var rootFeatureClasses = unmarshalTable(result.getScalarsTable(), target);
             // This only unmarshals if has-many features gets returned in `result.groupsTables`
 
@@ -24,6 +24,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
@@ -209,24 +210,57 @@ public void testBuildMultiRequestPreservesOrderAndUsesBulk() throws Exception {
 
     // ------------------------------------------------------- settings resolvers
 
-    @Test
-    public void testResolveDeadlineTakesTheLongest() {
-        assertTrue(GRPCClient.resolveDeadline(List.of(simpleParams(), simpleParams())).isEmpty());
-
-        OnlineQueryParamsComplete shortTimeout = OnlineQueryParams.builder()
+    private static OnlineQueryParamsComplete paramsWithTimeout(Duration timeout) {
+        return OnlineQueryParams.builder()
                 .withInput("user.id", List.of(1))
                 .withOutputs("user.socure_score")
-                .withTimeout(Duration.ofSeconds(1))
-                .build();
-        OnlineQueryParamsComplete longTimeout = OnlineQueryParams.builder()
-                .withInput("user.id", List.of(1))
-                .withOutputs("user.socure_score")
-                .withTimeout(Duration.ofSeconds(30))
+                .withTimeout(timeout)
                 .build();
+    }
+
+    @Test
+    public void testResolveDeadlineTakesTheLongest() {
+        var noClientTimeout = Optional.<Duration>empty();
+
+        // nothing set anywhere -> no deadline
+        assertTrue(GRPCClient.resolveDeadline(
+                List.of(simpleParams(), simpleParams()), noClientTimeout).isEmpty());
+
+        var shortTimeout = paramsWithTimeout(Duration.ofSeconds(1));
+        var longTimeout = paramsWithTimeout(Duration.ofSeconds(30));
+
+        assertEquals(
+                Duration.ofSeconds(30),
+                GRPCClient.resolveDeadline(List.of(shortTimeout, longTimeout), noClientTimeout)
+                        .orElseThrow());
+    }
+
+    /**
+     * A query that sets no timeout is bounded by the client-level timeout, so that is
+     * its effective timeout. Ignoring it would let one query's short timeout cut short
+     * a query that was relying on a longer client default.
+     */
+    @Test
+    public void testResolveDeadlineHonoursClientLevelTimeout() {
+        var fast = paramsWithTimeout(Duration.ofSeconds(1));
+        var clientTimeout = Optional.of(Duration.ofMinutes(5));
+
+        // `fast` wants 1s, the unset one is entitled to the client's 5m -> 5m wins
+        assertEquals(
+                Duration.ofMinutes(5),
+                GRPCClient.resolveDeadline(List.of(fast, simpleParams()), clientTimeout).orElseThrow());
 
+        // every query explicit -> the client default is irrelevant
         assertEquals(
                 Duration.ofSeconds(30),
-                GRPCClient.resolveDeadline(List.of(shortTimeout, longTimeout, simpleParams())).orElseThrow());
+                GRPCClient.resolveDeadline(
+                        List.of(fast, paramsWithTimeout(Duration.ofSeconds(30))), clientTimeout)
+                        .orElseThrow());
+
+        // an unset query with no client timeout is unbounded, so the request cannot
+        // carry a deadline at all
+        assertTrue(GRPCClient.resolveDeadline(
+                List.of(fast, simpleParams()), Optional.empty()).isEmpty());
     }
 
     @Test
@@ -246,51 +280,58 @@ public void testResolveQueryNameRequiresAgreement() throws Exception {
                 () -> GRPCClient.resolveQueryName(List.of(params("a"), simpleParams())));
     }
 
-    /**
-     * When both the name and the version disagree, the name is the more useful
-     * thing to report: it is what the caller actually set.
-     */
     @Test
-    public void testResolveQueryNameReportsNameBeforeVersion() {
-        OnlineQueryParamsComplete a = OnlineQueryParams.builder()
+    public void testResolveEnvironmentRequiresAgreement() throws Exception {
+        OnlineQueryParamsComplete envA = OnlineQueryParams.builder()
                 .withInput("user.id", List.of(1))
                 .withOutputs("user.socure_score")
-                .withQueryName("a")
-                .withQueryNameVersion("1")
+                .withEnvironmentId("env-a")
                 .build();
-        OnlineQueryParamsComplete b = OnlineQueryParams.builder()
+        OnlineQueryParamsComplete envB = OnlineQueryParams.builder()
                 .withInput("user.id", List.of(1))
                 .withOutputs("user.socure_score")
-                .withQueryName("b")
-                .withQueryNameVersion("2")
+                .withEnvironmentId("env-b")
                 .build();
 
+        assertEquals("env-a", GRPCClient.resolveEnvironment(List.of(envA, envA), null));
+
         var conflict = assertThrows(
-                ClientException.class, () -> GRPCClient.resolveQueryName(List.of(a, b)));
-        assertTrue(conflict.getMessage().contains("queryName,"));
-        assertTrue(!conflict.getMessage().contains("queryNameVersion"));
+                ClientException.class,
+                () -> GRPCClient.resolveEnvironment(List.of(envA, envB), null));
+        assertTrue(conflict.getMessage().contains("environmentId"));
+        assertTrue(conflict.getMessage().contains("'env-a'"));
+        assertTrue(conflict.getMessage().contains("'env-b'"));
+
+        // An unset environmentId means the client's environment, so naming that same
+        // environment explicitly on one query is not a conflict.
+        assertEquals(
+                "env-a",
+                GRPCClient.resolveEnvironment(List.of(envA, simpleParams()), "env-a"));
+        assertThrows(
+                ClientException.class,
+                () -> GRPCClient.resolveEnvironment(List.of(envA, simpleParams()), "env-other"));
     }
 
+    /**
+     * The version rides along in each sub-request's own context and has no header of
+     * its own, so queries that differ only by version are satisfiable.
+     */
     @Test
-    public void testResolveEnvironmentRequiresAgreement() throws Exception {
-        OnlineQueryParamsComplete envA = OnlineQueryParams.builder()
+    public void testResolveQueryNameAllowsDifferingVersions() throws Exception {
+        OnlineQueryParamsComplete v1 = OnlineQueryParams.builder()
                 .withInput("user.id", List.of(1))
                 .withOutputs("user.socure_score")
-                .withEnvironmentId("env-a")
+                .withQueryName("same")
+                .withQueryNameVersion("1")
                 .build();
-        OnlineQueryParamsComplete envB = OnlineQueryParams.builder()
+        OnlineQueryParamsComplete v2 = OnlineQueryParams.builder()
                 .withInput("user.id", List.of(1))
                 .withOutputs("user.socure_score")
-                .withEnvironmentId("env-b")
+                .withQueryName("same")
+                .withQueryNameVersion("2")
                 .build();
 
-        assertEquals("env-a", GRPCClient.resolveEnvironment(List.of(envA, envA)));
-
-        var conflict = assertThrows(
-                ClientException.class, () -> GRPCClient.resolveEnvironment(List.of(envA, envB)));
-        assertTrue(conflict.getMessage().contains("environmentId"));
-        assertTrue(conflict.getMessage().contains("'env-a'"));
-        assertTrue(conflict.getMessage().contains("'env-b'"));
+        assertEquals("same", GRPCClient.resolveQueryName(List.of(v1, v2)));
     }
 
     @Test
@@ -441,6 +482,30 @@ public void testDecodeMultiResponseExecutionFailureIsGlobalWithEmptySlot() throw
         assertEquals(0, this.allocator.getAllocatedMemory());
     }
 
+    /**
+     * Unmarshalling the empty slot left by a query that failed to execute must explain
+     * itself rather than surfacing an opaque NPE from deep inside the Arrow reader.
+     */
+    @Test
+    public void testUnmarshalEmptySlotExplainsItself() throws Exception {
+        var response = OnlineQueryMultiResponse.newBuilder()
+                .addResponses(wrap(OnlineQueryBulkResponse.newBuilder().build()))
+                .addErrors(error("Encountered an error occurred while executing query 1/1: rate limited"))
+                .build();
+
+        try (OnlineQueryMultiResult multi =
+                     GRPCClient.decodeMultiResponse(response, 1, TRACE_ID, this.allocator)) {
+            OnlineQueryResult empty = multi.getResults().get(0);
+            assertNull(empty.getScalarsTable());
+
+            var thrown = assertThrows(
+                    ClientException.class, () -> empty.unmarshal(TestGrpcMultiQueryUser.class));
+            assertTrue(thrown.getMessage().contains("no scalar data"));
+            assertTrue(thrown.getMessage().contains("getGlobalErrors()"));
+        }
+        assertEquals(0, this.allocator.getAllocatedMemory());
+    }
+
     @Test
     public void testDecodeMultiResponseCountMismatch() throws Exception {
         var tooFew = OnlineQueryMultiResponse.newBuilder()
 
@@ -0,0 +1,10 @@
+package ai.chalk.client;
+
+import ai.chalk.features.Feature;
+import ai.chalk.features.FeaturesClass;
+
+/** Minimal feature class used only to exercise the unmarshal guard. */
+public class TestGrpcMultiQueryUser extends FeaturesClass {
+    public Feature<String> id;
+    public Feature<Double> socure_score;
+}