fix: address whole-PR review findings

Three issues caught in the final review against the spec:

* Multi-path CLI invocations were still loading state. The
  LOCAL_ONLY_COMMANDS check was inside `if len(paths) == 1:`, mirroring
  the existing `SKIP_LOAD_COMMANDS` shape. But unlike load-skipping,
  local-only behaviour is independent of project count - multi-project
  monorepo users running `sqlmesh --paths a --paths b format` should
  not hit state either. Lifted the check out of the conditional.
  Verified empirically: multi-path format against an unreachable
  Postgres state now exits 0.

* `GenericContext.__init__` had `load_state` inserted between `load`
  and `users`, shifting positional arguments for any caller outside
  this repo passing `users`, `config_loader_kwargs`, or `selector`
  positionally. Moved `load_state` to the end of the signature. In-repo
  callers (cli/main.py, magics.py, github controller) all use kwargs
  so they are unaffected.

* The lint test was running with the linter disabled, so no built-in
  rule actually executed under `load_state=False`. Added the existing
  pattern's `LinterConfig(enabled=False, ...)` -> `enabled=True,
  rules=["nomissingexternalmodels"]` rewrite so the test exercises a
  real rule's code path while state is patched to raise.

Plan updated to reflect the final signature placement and the lifted
CLI check.

Coding-Agent: pi
Model: anthropic/claude-opus-4-7
Signed-off-by: Joe Hartshorn <8881940+j-hartshorn@users.noreply.github.com>

Author: j-hartshorn

docs/2026-05-21_local-only-format/plan.md

@@ -95,7 +95,7 @@ Two tasks, two commits, one PR.
 
 In `sqlmesh/core/context.py`:
 - Extend the `GenericContext` class docstring args block at lines 356-368 with a one-line entry for the new parameter: a brief description noting it gates the remote-state merge inside `load()` and is only meaningful when `load=True`.
-- Add `load_state: bool = True` to `GenericContext.__init__` after the existing `load: bool = True` at line 385.
+- Add `load_state: bool = True` to `GenericContext.__init__` at the *end* of the parameter list (after `selector`). Placing it last avoids shifting any existing positional arguments for callers outside this repo who may pass `users`, `config_loader_kwargs`, or `selector` positionally.
 - Store as `self._load_state` on the instance during `__init__`, alongside the other private attributes (`self._loaded`, `self._loaders`, etc., around lines 396-415).
 - In `Context.load()`, tighten the two `if any(self._projects):` guards at lines 677 and 685 by ANDing `self._load_state` into each predicate. No other changes to `load()` body. `update_schemas`, `Linter.from_rules`, and the `analytics.collector.on_project_loaded` call are unaffected.
 
@@ -135,7 +135,7 @@ All three tests share a setup factored into `_setup_local_only_project(tmp_path,
 
 In `sqlmesh/cli/main.py`:
 - Add a new module-level constant `LOCAL_ONLY_COMMANDS = ("format", "lint")` immediately after `SKIP_CONTEXT_COMMANDS` (line 43), matching the surrounding tuple style.
-- Inside `cli(...)` (lines 117-123), mirror the existing `load = True; if ... in SKIP_LOAD_COMMANDS: load = False` pattern to introduce a `load_state` local that defaults to `True` and flips to `False` when `ctx.invoked_subcommand in LOCAL_ONLY_COMMANDS`.
+- Inside `cli(...)` (around line 117), compute `load_state = ctx.invoked_subcommand not in LOCAL_ONLY_COMMANDS` *outside* the `if len(paths) == 1:` block. Unlike `SKIP_LOAD_COMMANDS` (whose `load = False` toggle is inside the single-path conditional), `load_state` must apply regardless of how many `--paths` were provided — multi-project monorepo invocations of `format`/`lint` need to be local-only too.
 - Pass `load_state=load_state` as an additional keyword argument in the `Context(...)` call at lines 132-137.
 
 **Verification:**

sqlmesh/cli/main.py

@@ -116,7 +116,7 @@ def cli(
     configure_console(ignore_warnings=ignore_warnings)
 
     load = True
-    load_state = True
+    load_state = ctx.invoked_subcommand not in LOCAL_ONLY_COMMANDS
 
     if len(paths) == 1:
         path = os.path.abspath(paths[0])
@@ -125,8 +125,6 @@ def cli(
             return
         if ctx.invoked_subcommand in SKIP_LOAD_COMMANDS:
             load = False
-        if ctx.invoked_subcommand in LOCAL_ONLY_COMMANDS:
-            load_state = False
 
     configs = load_configs(config, Context.CONFIG_TYPE, paths, dotenv_path=dotenv)
     log_limit = list(configs.values())[0].log_limit

sqlmesh/core/context.py

@@ -384,10 +384,10 @@ def __init__(
         concurrent_tasks: t.Optional[int] = None,
         loader: t.Optional[t.Type[Loader]] = None,
         load: bool = True,
-        load_state: bool = True,
         users: t.Optional[t.List[User]] = None,
         config_loader_kwargs: t.Optional[t.Dict[str, t.Any]] = None,
         selector: t.Optional[t.Type[Selector]] = None,
+        load_state: bool = True,
     ):
         self.configs = (
             config

tests/core/linter/test_builtin.py

@@ -235,7 +235,7 @@ def test_no_missing_unit_tests(tmp_path, copy_to_temp_path):
 
 
 def test_lint_without_state_load(tmp_path, copy_to_temp_path, mocker) -> None:
-    """`lint_models` with `load_state=False` runs end-to-end without touching state sync."""
+    """`lint_models` with `load_state=False` runs built-in rules without touching state sync."""
     sushi_paths = copy_to_temp_path("examples/sushi")
     sushi_path = sushi_paths[0]
 
@@ -250,6 +250,23 @@ def test_lint_without_state_load(tmp_path, copy_to_temp_path, mocker) -> None:
     )
     assert 'project="sushi"' in read_file
 
+    # Enable the linter with one built-in rule so `lint_models` actually executes
+    # a rule under `load_state=False`, not just the empty-rule-set path.
+    before = """    linter=LinterConfig(
+        enabled=False,
+        rules=[
+            "ambiguousorinvalidcolumn",
+            "invalidselectstarexpansion",
+            "noselectstar",
+            "nomissingaudits",
+            "nomissingowner",
+            "nomissingexternalmodels",
+        ],
+    ),"""
+    after = 'linter=LinterConfig(enabled=True, rules=["nomissingexternalmodels"]),'
+    read_file = read_file.replace(before, after)
+    assert after in read_file
+
     with open(sushi_path / "config.py", "w") as f:
         f.writelines(read_file)