Refuse on Two Repositories, Not on Two Filesystem Paths

The fallback added in this PR made every path its own root, so a run
naming two files outside any checkout was refused as spanning two
repositories. Reproduced: `prose_lint.py README.md docs/guide.md` from a
directory under no repository exits 2 here and 0 on develop. That is a
regression this PR introduced, not a pre-existing defect.
Only a repository declares a workflow model, so only distinct repositories
are ambiguous. The refusal now keys on non-empty git roots, which also
removes the need to mark non-repository roots in the message, since none
appear in it.
With no repository in play, the anchor follows discovery's own rule rather
than a second one invented here, so the rule set is decided over the tree
that will actually be read.
Two cases replace the one that asserted the marked-up message: several
loose paths are not a conflict, and one repository beside a loose path is
not either. Two real repositories still refuse, and the original defect
stays fixed, both checked live.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ptr727

scripts/prose_lint.py

@@ -1110,20 +1110,24 @@ def main(argv: list[str] | None = None) -> int:
 # Reading it from `.` discarded home-path on a release repository whenever the caller happened to stand in an operational one.
 # That silenced the rule that exists because real paths reached a public comment, announcing it on stderr and exiting 0.
 # A run spanning two repositories refuses instead of picking one, since the two can declare different models and one rule set cannot be right for both.
-# A path git cannot place resolves to itself, so the roots are not all repositories.
-# The refusal below names which is which rather than calling every one of them a repository.
-scan_roots= {}
-forrawin (a.pathsor ['.']):
-found=repo_root(Path(raw))
-scan_roots[foundorstr(Path(raw).resolve())] =bool(found)
-iflen(scan_roots) >1:
-named=', '.join(root+ (''ifis_repoelse' (no git repository)')
-forroot, is_repoinsorted(scan_roots.items()))
-print(f'error: the requested paths resolve to more than one root ({named}). A repository '
-'declares its own workflow model, so no single rule set is correct for all of them. '
-'Run the gate once per root.', file=sys.stderr)
+# Only a repository declares a workflow model, so only distinct repositories are ambiguous.
+# Two loose paths under no repository are not a conflict.
+# Refusing on them would break the ordinary multi-file invocation outside a checkout, where every argument resolves somewhere different.
+scan_paths=a.pathsor ['.']
+git_roots= {foundforfoundin (repo_root(Path(p)) forpinscan_paths) iffound}
+iflen(git_roots) >1:
+print('error: the requested paths span more than one repository ('+
+', '.join(sorted(git_roots)) +'). Each declares its own workflow model, so no '
+'single rule set is correct for all of them. Run the gate once per repository.',
+file=sys.stderr)
 return2
-scan_root=Path(next(iter(scan_roots)))
+# With one repository in play, the model is that repository's own.
+# With none, anchor the way discovery does, so the rule set is decided over the tree that will actually be read.
+ifgit_roots:
+scan_root=Path(next(iter(git_roots)))
+else:
+first=Path(scan_paths[0])
+scan_root=firstiffirst.is_dir() elsePath('.')
 
 # An operational repository's runbook carries the literal path an operator types.
 # That is the repository's own content, not an agent quoting an environment it observed.

scripts/test_prose_lint.py

@@ -1849,23 +1849,37 @@ def test_paths_spanning_two_repositories_refuse_rather_than_pick_one(self) -> No
 withmock.patch.object(prose_lint, 'repo_root', side_effect=lambdap: str(Path(p))):
 self.assertEqual(2, prose_lint.main(
  [str(self.release), str(self.operational), '--check', 'home-path']))
-self.assertIn('more than one root', self.err.getvalue())
+self.assertIn('more than one repository', self.err.getvalue())
 
-deftest_the_refusal_does_not_call_a_non_repository_path_a_repository(self) ->None:
-"""`repo_root` returns '' for a path git cannot place, and that root is not a repository.
+deftest_several_paths_under_no_repository_are_not_a_conflict(self) ->None:
+"""Only a repository declares a model, so two loose paths are not ambiguous.
 
-Naming it as one sends the reader looking for a workflow model in a directory that
-declares none.
+Refusing on distinct filesystem paths broke the ordinary multi-file invocation outside a
+checkout, where every argument resolves somewhere different.
  """
 loose=self.tmp/'loose'
+ (loose/'docs').mkdir(parents=True)
+one, two=loose/'a.md', loose/'docs'/'b.md'
+fortargetin (one, two):
+target.write_text('Nothing to find here.\n', encoding='utf-8')
+withmock.patch.object(prose_lint, 'repo_root', return_value=''), \
+mock.patch.object(prose_lint, 'discover', return_value=[one, two]):
+self.assertEqual(0, prose_lint.main([str(one), str(two), '--check', 'home-path']))
+self.assertNotIn('more than one repository', self.err.getvalue())
+
+deftest_one_repository_plus_a_loose_path_is_not_a_conflict(self) ->None:
+"""One model is in play, so there is nothing to disambiguate."""
+loose=self.tmp/'loose'
 loose.mkdir()
+bait=loose/'notes.md'
+bait.write_text(f'Deploy into {NIX_HOME}/stack here.\n', encoding='utf-8')
 withmock.patch.object(prose_lint, 'repo_root',
-side_effect=lambdap: str(self.release) ifPath(p) ==self.releaseelse''):
-self.assertEqual(2, prose_lint.main(
+side_effect=lambdap: str(self.release) ifPath(p) ==self.releaseelse''), \
+mock.patch.object(prose_lint, 'discover', return_value=[bait]):
+# The one repository in play is a release repo, so home-path stays on and finds it.
+self.assertEqual(1, prose_lint.main(
  [str(self.release), str(loose), '--check', 'home-path']))
-message=self.err.getvalue()
-self.assertIn('no git repository', message)
-self.assertIn(str(loose), message)
+self.assertNotIn('more than one repository', self.err.getvalue())
 
 deftest_a_path_under_no_repository_falls_back_to_itself_rather_than_the_caller(self) ->None:
 """The fallback must not reintroduce the dependency the fix removes.