@@ -96,16 +96,20 @@ def list_value(assignments, name):
     return []
 
 
+def is_variadic(recipe):
+    parameters = recipe["parameters"]
+    return bool(parameters and parameters[-1]["kind"] in ("star", "plus"))
+
+
 def accepts(recipe, argc):
     """Check whether a recipe can be called with a given number of arguments."""
     parameters = recipe["parameters"]
-    variadic = parameters and parameters[-1]["kind"] in ("star", "plus")
     required = sum(
         1
         for parameter in parameters
         if parameter["default"] is None and parameter["kind"] != "star"
     )
-    return required <= argc and (variadic or argc <= len(parameters))
+    return required <= argc and (is_variadic(recipe) or argc <= len(parameters))
 
 
 def implements(dump, command, argc):
@@ -141,12 +145,14 @@ def dump_all(justfiles):
     with ThreadPoolExecutor(PROBE_WORKERS) as executor:
         dumps = list(executor.map(dump_justfile, justfiles))
     parsed = []
+    failed = False
     for justfile, (dump, failure) in zip(justfiles, dumps):
         if dump is None:
+            failed = True
             error(f"could not read {justfile}:\n{failure}")
         else:
             parsed.append((justfile, dump))
-    return parsed
+    return parsed, failed
 
 
 def git(directory, *args):
@@ -159,28 +165,26 @@ def git(directory, *args):
     )
     if result.returncode != 0:
         error(f"`git {' '.join(args)}` failed in {directory}:\n{result.stderr.strip()}")
-        return []
-    return result.stdout.splitlines()
+        return [], True
+    return result.stdout.splitlines(), False
 
 
 def submodules(directory):
     """List the initialised submodules under a directory."""
-    toplevel = git(directory, "rev-parse", "--show-toplevel")
+    toplevel, failed = git(directory, "rev-parse", "--show-toplevel")
     if not toplevel or not (Path(toplevel[0]) / ".gitmodules").exists():
-        return []
-    paths = [
-        Path(toplevel[0]) / line.split(" ", 1)[1]
-        for line in git(
-            toplevel[0], "config", "--file", ".gitmodules", "--get-regexp", r"\.path$"
-        )
-    ]
+        return [], failed
+    lines, config_failed = git(
+        toplevel[0], "config", "--file", ".gitmodules", "--get-regexp", r"\.path$"
+    )
+    paths = [Path(toplevel[0]) / line.split(" ", 1)[1] for line in lines]
     within = Path(directory).resolve()
     return [
         Path(directory) / os.path.relpath(path, within)
         for path in paths
         # An uninitialised submodule is an empty directory, with nothing to run.
         if path.is_relative_to(within) and (path / ".git").exists()
-    ]
+    ], failed or config_failed
 
 
 def find_justfiles(directory):
@@ -191,21 +195,21 @@ def find_justfiles(directory):
     worth finding.
     """
     justfiles = set()
-    for repository in [directory, *submodules(directory)]:
-        justfiles.update(
-            Path(repository) / line
-            for line in git(
-                repository,
-                "ls-files",
-                "--cached",
-                "--others",
-                "--exclude-standard",
-                "--",
-                "justfile",
-                "*/justfile",
-            )
+    repositories, failed = submodules(directory)
+    for repository in [directory, *repositories]:
+        lines, git_failed = git(
+            repository,
+            "ls-files",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+            "--",
+            "justfile",
+            "*/justfile",
         )
-    return justfiles
+        failed = failed or git_failed
+        justfiles.update(Path(repository) / line for line in lines)
+    return justfiles, failed
 
 
 def invocation_path(path, *, like):
@@ -230,7 +234,8 @@ def find_justfiles_above(command, arg):
     ]
     found = []
     seen = []
-    for justfile, dump in dump_all(candidates):
+    parsed, failed = dump_all(candidates)
+    for justfile, dump in parsed:
         # A justfile sitting exactly on the argument is called without it, as the
         # argument would only repeat where it already is.
         argc = 0 if justfile.parent.resolve() == directory else 1
@@ -248,7 +253,7 @@ def find_justfiles_above(command, arg):
         if recipe is not None and recipe not in seen:
             seen.append(recipe)
             found.append((justfile, recipe))
-    return found
+    return found, failed
 
 
 def find_justfiles_below(command, directory, covered=()):
@@ -263,10 +268,13 @@ def find_justfiles_below(command, directory, covered=()):
     but ask to be named rather than found.
     """
     # The justfile at `directory` is covered by the search above it.
-    candidates = sorted(find_justfiles(directory) - {Path(directory) / "justfile"})
+    justfiles, failed = find_justfiles(directory)
+    candidates = sorted(justfiles - {Path(directory) / "justfile"})
     matches = []
     opted_out = []
-    for justfile, dump in dump_all(candidates):
+    parsed, dump_failed = dump_all(candidates)
+    failed = failed or dump_failed
+    for justfile, dump in parsed:
         recipe = implements(dump, command, 0)
         if recipe is None:
             continue
@@ -283,7 +291,7 @@ def find_justfiles_below(command, directory, covered=()):
             continue
         contributed.setdefault(justfile.parent, []).append(recipe)
         found.append((justfile, recipe))
-    return sorted(found, key=lambda match: match[0]), sorted(opted_out)
+    return sorted(found, key=lambda match: match[0]), sorted(opted_out), failed
 
 
 def resolve(command, arg):
@@ -294,18 +302,18 @@ def resolve(command, arg):
     on. One found below gets its own directory instead, as there the argument only said
     where to look. Justfiles below that asked to be named are returned separately.
     """
-    above = find_justfiles_above(command, arg)
-    resolved = [(justfile, arg, recipe["name"]) for justfile, recipe in above]
+    above, failed = find_justfiles_above(command, arg)
+    resolved = [(justfile, arg, recipe) for justfile, recipe in above]
     opted_out = []
     if os.path.isdir(arg):
-        below, opted_out = find_justfiles_below(
+        below, opted_out, below_failed = find_justfiles_below(
             command, arg, [recipe for _, recipe in above]
         )
+        failed = failed or below_failed
         resolved += [
-            (justfile, str(justfile.parent), recipe["name"])
-            for justfile, recipe in below
+            (justfile, str(justfile.parent), recipe) for justfile, recipe in below
         ]
-    return resolved, opted_out
+    return resolved, opted_out, failed
 
 
 def report_opted_out(command, justfiles, *, ran):
@@ -340,6 +348,19 @@ def invoke_just(cwd, args):
     return 0
 
 
+def invocation_argument_groups(recipe, pos_args):
+    """Split arguments into what the recipe can be called with at once.
+
+    Every recipe reachable from a verb today is variadic or takes none, so this only
+    ever yields one group. It is here because the arguments are paths and running the
+    verb once per path is what a fixed-arity recipe would mean, where passing them
+    together would fail on arity alone and say nothing useful about why.
+    """
+    if is_variadic(recipe) or len(pos_args) <= 1:
+        return [pos_args]
+    return [[arg] for arg in pos_args]
+
+
 def forward(cmd, args):
     """Forward a command to language-specific justfiles."""
     is_non_positional = re.compile(r"^(-.*|\+|[A-Z_][A-Z_0-9]*=.*)$")
@@ -348,27 +369,38 @@ def forward(cmd, args):
 
     justfiles = {}
     opted_out = []
+    resolution_failed = False
     for arg in positional_args or ["."]:
-        resolved, skipped = resolve(cmd, arg)
+        resolved, skipped, failed = resolve(cmd, arg)
         opted_out += skipped
+        resolution_failed = resolution_failed or failed
         if not resolved:
+            # A candidate that could not be read is reported below rather than here:
+            # saying nothing matched would blame the argument for a broken justfile.
+            if failed:
+                continue
             error(f"No justfile found for {cmd} on {arg}")
             report_opted_out(cmd, skipped, ran=False)
             return 1
         for justfile, justfile_arg, recipe in resolved:
             justfiles.setdefault(justfile, (recipe, []))[1].append(justfile_arg)
 
+    if resolution_failed:
+        report_opted_out(cmd, opted_out, ran=False)
+        return 1
+
     invocations = []
     for justfile, (recipe, pos_args) in justfiles.items():
         # An argument standing for the whole directory subsumes any more specific one
         # that ended up on the same justfile.
         whole_directory = str(justfile.parent)
         if whole_directory in pos_args:
             pos_args = [whole_directory]
-        cwd, just_args = get_just_context(justfile, recipe, flags, pos_args)
-        prefix = f"cd {cwd}; " if cwd else ""
-        print(f"-> {prefix}just {' '.join(just_args)}")
-        invocations.append((cwd, just_args))
+        for group in invocation_argument_groups(recipe, pos_args):
+            cwd, just_args = get_just_context(justfile, recipe["name"], flags, group)
+            prefix = f"cd {cwd}; " if cwd else ""
+            print(f"-> {prefix}just {' '.join(just_args)}")
+            invocations.append((cwd, just_args))
 
     report_opted_out(cmd, opted_out, ran=True)
 
 
@@ -290,7 +290,11 @@ def found(self, outer, inner):
             "dump_justfile",
             side_effect=lambda justfile: (dumps[Path(justfile)], None),
         ):
-            return forward_command.find_justfiles_above("format", str(self.argument))
+            found, failed = forward_command.find_justfiles_above(
+                "format", str(self.argument)
+            )
+        self.assertFalse(failed)
+        return found
 
     def test_a_recipe_reached_under_two_spellings_runs_once(self):
         found = self.found(self.implementing(), self.implementing())
@@ -308,6 +312,77 @@ def test_two_roots_sharing_a_comment_still_both_run_if_they_do_different_work(se
         self.assertEqual([justfile for justfile, _ in found], [self.inner, self.outer])
 
 
+class TestDiscoveryFailures(unittest.TestCase):
+    def test_dump_all_reports_every_failure(self):
+        justfiles = [Path("one/justfile"), Path("two/justfile"), Path("three/justfile")]
+        dumps = [(None, "bad one"), (dump(), None), (None, "bad three")]
+        with mock.patch.object(
+            forward_command, "dump_justfile", side_effect=dumps
+        ), mock.patch.object(forward_command, "error") as report:
+            parsed, failed = forward_command.dump_all(justfiles)
+        self.assertTrue(failed)
+        self.assertEqual(parsed, [(Path("two/justfile"), dump())])
+        self.assertEqual(report.call_count, 2)
+
+    def test_git_failure_is_reported_to_callers(self):
+        result = subprocess.CompletedProcess(
+            ["git"], 128, stdout="", stderr="fatal: not a repository"
+        )
+        with mock.patch.object(
+            subprocess, "run", return_value=result
+        ), mock.patch.object(forward_command, "error"):
+            lines, failed = forward_command.git(".", "ls-files")
+        self.assertEqual(lines, [])
+        self.assertTrue(failed)
+
+    def test_forward_fails_without_running_after_resolution_failure(self):
+        justfile = Path("pkg/justfile")
+        resolved = [(justfile, "pkg", recipe("test", [parameter("ARGS", "star")]))]
+        with mock.patch.object(
+            forward_command, "resolve", return_value=(resolved, [], True)
+        ), mock.patch.object(forward_command, "invoke_just") as invoke:
+            self.assertEqual(forward_command.forward("test", ["pkg"]), 1)
+        invoke.assert_not_called()
+
+
+class TestForwardInvocations(unittest.TestCase):
+    def test_accumulates_variadic_recipe_arguments(self):
+        justfile = Path("pkg/justfile")
+        test_recipe = recipe("test", [parameter("ARGS", "star")])
+
+        def resolve(command, arg):
+            return [(justfile, arg, test_recipe)], [], False
+
+        with mock.patch.object(
+            forward_command, "resolve", side_effect=resolve
+        ), mock.patch.object(forward_command, "invoke_just", return_value=0) as invoke:
+            self.assertEqual(forward_command.forward("test", ["pkg/a", "pkg/b"]), 0)
+
+        invoke.assert_called_once_with(
+            None, ["--justfile", "pkg/justfile", "test", "pkg/a", "pkg/b"]
+        )
+
+    def test_splits_non_variadic_recipe_arguments(self):
+        justfile = Path("pkg/justfile")
+        test_recipe = recipe("test", [parameter("ARG")])
+
+        def resolve(command, arg):
+            return [(justfile, arg, test_recipe)], [], False
+
+        with mock.patch.object(
+            forward_command, "resolve", side_effect=resolve
+        ), mock.patch.object(forward_command, "invoke_just", return_value=0) as invoke:
+            self.assertEqual(forward_command.forward("test", ["pkg/a", "pkg/b"]), 0)
+
+        self.assertEqual(
+            invoke.call_args_list,
+            [
+                mock.call(None, ["--justfile", "pkg/justfile", "test", "pkg/a"]),
+                mock.call(None, ["--justfile", "pkg/justfile", "test", "pkg/b"]),
+            ],
+        )
+
+
 # Resolve the same binary `forward_command` will run: it honours JUST_EXECUTABLE, so a
 # pinned `just` would otherwise have these fixtures checked against a different binary
 # than the code uses. `which` covers both spellings, returning an explicit path as given