fix(t2-4): address review feedback — move warning to load_config, fix edge cases

- Warning moved from load_project() to load_config() and switched to
  Rich console helper, so it renders in-band and does not appear on
  fresh projects or on tycoon init --upgrade (neither goes through
  load_config)
- load_project() now raises ValueError for schema_version > SCHEMA_VERSION,
  mirroring migrate_project's three-way split
- save_project() stamps schema_version on every write so a load+save
  round-trip (sources add/remove) silently upgrades the stamp
- scaffold_blank_project() and scaffold_from_template() write
  schema_version on new projects, eliminating the false-alarm on init
- migrate_project() checks isinstance(existing, bool) before int to
  catch schema_version: true
- tycoon init --upgrade wraps migrate_project in try/except ValueError
  for clean error output instead of a typer traceback

Author: JesuFemi-O

src/tycoon/commands/init.py

@@ -519,7 +519,11 @@ def init_cmd(
         if not (target / "tycoon.yml").exists():
             error("No tycoon.yml found in the current directory. Run 'tycoon init' to create one.")
             raise typer.Exit(1)
-        changed = migrate_project(target)
+        try:
+            changed = migrate_project(target)
+        except ValueError as exc:
+            error(str(exc))
+            raise typer.Exit(1) from exc
         if changed:
             success("tycoon.yml migrated to the current schema version.")
         else:

src/tycoon/config.py

@@ -8,7 +8,8 @@
 
 from pathlib import Path
 
-from tycoon.project import PROJECT_FILENAME, TycoonProject, load_project
+from tycoon.project import PROJECT_FILENAME, SCHEMA_VERSION, TycoonProject, load_project
+from tycoon.utils.console import warn as _warn_console
 
 # v0.1 defaults (used when no tycoon.yml exists)
 _DEFAULT_RAW_DB = "data/raw.duckdb"
@@ -124,8 +125,18 @@ def load_config() -> TycoonConfig:
     """Return a TycoonConfig rooted at the nearest project directory.
 
     Prefer this over importing _find_project_root across module boundaries.
+    Emits a console warning when tycoon.yml is at an older schema version.
     """
-    return TycoonConfig(project_root=_find_project_root())
+    cfg = TycoonConfig(project_root=_find_project_root())
+    if cfg.project is not None:
+        sv = cfg.project.schema_version
+        if sv is None or sv < SCHEMA_VERSION:
+            current = sv if sv is not None else "none"
+            _warn_console(
+                f"tycoon.yml is at schema version {current}, current is {SCHEMA_VERSION}. "
+                "Run 'tycoon init --upgrade' to migrate."
+            )
+    return cfg
 
 
 # Singleton (used by modules not yet migrated to load_config)

src/tycoon/project.py

@@ -398,8 +398,6 @@ def _check_path_field(cls, v: str | None) -> str | None:
 
 def load_project(project_root: Path) -> TycoonProject | None:
     """Load and validate tycoon.yml from the given root. Returns None if not found."""
-    import warnings
-
     path = project_root / PROJECT_FILENAME
     if not path.exists():
         return None
@@ -408,12 +406,10 @@ def load_project(project_root: Path) -> TycoonProject | None:
         return TycoonProject()
     raw = _interpolate_allowed_fields(raw)
     project = TycoonProject.model_validate(raw)
-    if project.schema_version is None or project.schema_version < SCHEMA_VERSION:
-        current = project.schema_version if project.schema_version is not None else "none"
-        warnings.warn(
-            f"tycoon.yml is at schema version {current}, current is {SCHEMA_VERSION}. "
-            "Run 'tycoon init --upgrade' to migrate.",
-            stacklevel=2,
+    if project.schema_version is not None and project.schema_version > SCHEMA_VERSION:
+        raise ValueError(
+            f"tycoon.yml schema_version {project.schema_version} is newer than this tycoon supports "
+            f"({SCHEMA_VERSION}). Upgrade tycoon-cli to use this project."
         )
     return project
 
@@ -431,6 +427,7 @@ def save_project(project: TycoonProject, project_root: Path) -> None:
     """
     path = project_root / PROJECT_FILENAME
     data = project.model_dump(by_alias=True, exclude_none=True, mode="json")
+    data["schema_version"] = SCHEMA_VERSION
     if path.exists():
         existing = yaml.safe_load(path.read_text())
         if isinstance(existing, dict):
@@ -466,7 +463,7 @@ def migrate_project(project_root: Path) -> bool:
         return False
 
     existing = raw.get("schema_version")
-    if existing is not None and not isinstance(existing, int):
+    if existing is not None and (isinstance(existing, bool) or not isinstance(existing, int)):
         raise ValueError(f"tycoon.yml schema_version must be an integer, got {type(existing).__name__}: {existing!r}")
     if existing is not None and existing > SCHEMA_VERSION:
         raise ValueError(

src/tycoon/scaffolding/templates.py

@@ -14,7 +14,7 @@
 import typer
 import yaml
 
-from tycoon.project import StackConfig
+from tycoon.project import SCHEMA_VERSION, StackConfig
 from tycoon.utils.console import info, success, warn
 
 
@@ -159,6 +159,7 @@ def scaffold_blank_project(
     project_data: dict = {
         "name": name,
         "version": "0.1.0",
+        "schema_version": SCHEMA_VERSION,
         "database": {
             "raw": raw_db_path,
             "warehouse": warehouse_db_path,
@@ -537,6 +538,9 @@ def scaffold_from_template(
         warn("tycoon.yml already exists, skipping")
     else:
         shutil.copy2(src_yml, dst_yml)
+        _raw = yaml.safe_load(dst_yml.read_text()) or {}
+        _raw["schema_version"] = SCHEMA_VERSION
+        dst_yml.write_text(yaml.dump(_raw, default_flow_style=False, sort_keys=False))
         success(f"Created tycoon.yml from template '{template_name}'")
 
     # Copy any subdirectories from the template (e.g. dbt_project/, rill/)

tests/test_config.py

@@ -4,7 +4,8 @@
 
 from pathlib import Path
 
-from tycoon.config import TycoonConfig
+from tycoon.config import TycoonConfig, load_config
+from tycoon.project import SCHEMA_VERSION
 
 
 class TestTycoonConfig:
@@ -36,3 +37,52 @@ def test_paths_relative_to_project_root(self, tmp_config):
         assert tmp_config.data_dir == tmp_config.root / "data"
         assert tmp_config.dbt_project_dir == tmp_config.root / "dbt_project"
         assert tmp_config.rill_dir == tmp_config.root / "rill"
+
+
+class TestLoadConfigSchemaWarning:
+    """T2-4: load_config warns via console when tycoon.yml schema_version is stale."""
+
+    def test_warns_when_schema_version_absent(self, tmp_path, monkeypatch):
+        (tmp_path / "tycoon.yml").write_text("name: old-project\n")
+        monkeypatch.chdir(tmp_path)
+
+        calls = []
+        monkeypatch.setattr("tycoon.config._warn_console", lambda msg: calls.append(msg))
+
+        load_config()
+
+        assert len(calls) == 1
+        assert "tycoon init --upgrade" in calls[0]
+
+    def test_warns_when_schema_version_old(self, tmp_path, monkeypatch):
+        (tmp_path / "tycoon.yml").write_text(f"name: old\nschema_version: {SCHEMA_VERSION - 1}\n")
+        monkeypatch.chdir(tmp_path)
+
+        calls = []
+        monkeypatch.setattr("tycoon.config._warn_console", lambda msg: calls.append(msg))
+
+        load_config()
+
+        assert len(calls) == 1
+
+    def test_no_warning_when_current(self, tmp_path, monkeypatch):
+        (tmp_path / "tycoon.yml").write_text(f"name: current\nschema_version: {SCHEMA_VERSION}\n")
+        monkeypatch.chdir(tmp_path)
+
+        calls = []
+        monkeypatch.setattr("tycoon.config._warn_console", lambda msg: calls.append(msg))
+
+        load_config()
+
+        assert calls == []
+
+    def test_no_warning_without_tycoon_yml(self, tmp_path, monkeypatch):
+        (tmp_path / "pyproject.toml").write_text('[project]\nname = "x"\n')
+        monkeypatch.chdir(tmp_path)
+
+        calls = []
+        monkeypatch.setattr("tycoon.config._warn_console", lambda msg: calls.append(msg))
+
+        load_config()
+
+        assert calls == []

tests/test_init.py

@@ -327,3 +327,12 @@ def test_upgrade_already_current_reports_up_to_date(self, cli_runner, tmp_path,
 
         assert result.exit_code == 0
         assert "up to date" in result.stdout
+
+    def test_upgrade_future_schema_version_exits_nonzero_cleanly(self, cli_runner, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / "tycoon.yml").write_text(f"name: future\nschema_version: {SCHEMA_VERSION + 1}\n")
+
+        result = cli_runner.invoke(app, ["init", "--upgrade"])
+
+        assert result.exit_code != 0
+        assert "newer than this tycoon supports" in result.output

tests/test_project.py

@@ -195,36 +195,25 @@ def test_metadata_field_parses(self, tmp_path):
         assert p.metadata.path == ".tycoon/custom_meta.duckdb"
 
 
-class TestSchemaVersionWarning:
-    """T2-4: load_project emits a warning when schema_version is absent or old."""
+class TestSchemaVersionEnforcement:
+    """T2-4: load_project raises on future schema_version; save_project stamps it."""
 
-    def test_warns_when_schema_version_absent(self, tmp_path):
+    def test_future_schema_version_raises_in_load(self, tmp_path):
         import pytest
 
-        (tmp_path / "tycoon.yml").write_text("name: old-project\n")
-
-        with pytest.warns(UserWarning, match="Run 'tycoon init --upgrade'"):
-            load_project(tmp_path)
+        (tmp_path / "tycoon.yml").write_text(f"name: future\nschema_version: {SCHEMA_VERSION + 1}\n")
 
-    def test_warns_when_schema_version_old(self, tmp_path):
-        import pytest
-
-        (tmp_path / "tycoon.yml").write_text(f"name: old-project\nschema_version: {SCHEMA_VERSION - 1}\n")
-
-        with pytest.warns(UserWarning, match="Run 'tycoon init --upgrade'"):
+        with pytest.raises(ValueError, match="newer than this tycoon supports"):
             load_project(tmp_path)
 
-    def test_no_warning_when_current(self, tmp_path):
-        import warnings
-
-        (tmp_path / "tycoon.yml").write_text(f"name: current\nschema_version: {SCHEMA_VERSION}\n")
-
-        with warnings.catch_warnings():
-            warnings.filterwarnings("error", category=UserWarning)
-            p = load_project(tmp_path)
-
+    def test_save_project_stamps_schema_version(self, tmp_path):
+        (tmp_path / "tycoon.yml").write_text("name: old-project\n")
+        p = load_project(tmp_path)
         assert p is not None
-        assert p.schema_version == SCHEMA_VERSION
+        save_project(p, tmp_path)
+        reloaded = load_project(tmp_path)
+        assert reloaded is not None
+        assert reloaded.schema_version == SCHEMA_VERSION
 
 
 class TestMigrateProject: