bathos 0.3.1__tar.gz → 0.4.0__tar.gz

{bathos-0.3.1 → bathos-0.4.0}/CLAUDE.md

@@ -10,9 +10,9 @@ bathos is a standalone experiment tracking CLI for a single researcher across 10
 
 ---
 
-## Current Status (as of 2026-05-20)
+## Current Status (as of 2026-05-21)
 
-**v0.3.0: complete and merged to main.** 254 tests passing.
+**v0.4.0: complete and merged to main.** 333 tests passing.
 
 - Full design spec: `.praxia/specs/bathos-design.md`
 - v0.1 implementation plan: `.praxia/specs/bathos-v01-plan.md`
@@ -22,6 +22,8 @@ bathos is a standalone experiment tracking CLI for a single researcher across 10
 
 **Shipped in v0.3:** Agentic integrity gate (`--agent-mode`, `--no-sidecar`, `--derived-from`), lineage tracking (`bth lineage`), campaigns (`bth campaign` subcommands + MCP tools), sprint audit (`bth sprint-audit`), Tier-2 lint checks, schema v3 with campaign/lineage/integrity fields, `--campaign` flag on `bth run`.
 
+**Shipped in v0.4:** Per-project sync filtering — `bth sync` now pushes/pulls only the current project's runs (no cross-project contamination). Cool-tier layout changed to `runs/<slug>/run_<uuid>.parquet`. New command `bth migrate-to-project-subdirs` migrates flat catalogs. `sync_filter` config knob; `--no-project-filter` opt-out planned.
+
 **Remaining backlog:** #136 (bth-migrate praxia workflow), #137 (global instruction portability), #142 (results management design).
 
 ---
@@ -34,7 +36,7 @@ bathos is a standalone experiment tracking CLI for a single researcher across 10
 SLURM job / bth run
       │
       ▼  atomic write-then-rename
- cool/   ~/.bth/catalog/runs/run_<uuid>.parquet   ← minimal schema, SLURM-safe
+ cool/   ~/.bth/catalog/runs/<slug>/run_<uuid>.parquet   ← minimal schema, SLURM-safe
       │
  bth compact  (lazy on query or explicit)
       │

{bathos-0.3.1 → bathos-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bathos
-Version: 0.3.1
+Version: 0.4.0
 Summary: Local-first, zero-server experiment tracking for researchers
 Project-URL: Homepage, https://github.com/mariellerossi/bathos
 Project-URL: Documentation, https://bathos.readthedocs.io
@@ -96,8 +96,15 @@ bth sql "SELECT project_slug, count(*) FROM runs GROUP BY 1"
 - `bth lint [--project-root PATH]` — check scripts/ for naming conventions and missing sidecars
 - `bth new-experiment <name>` — scaffold a new experiment script and sidecar
 - `bth migrate` — upgrade cool-tier Parquet fragments to current schema version
+- `bth migrate-to-project-subdirs [--dry-run]` — move flat catalog runs into `runs/<slug>/` subdirs (v0.4+)
 - `bth export` — export the using-bathos skill and register MCP server
 
+**`bth sync`** — Sync cool-tier catalog to/from cluster (v0.4+: per-project filtered)
+- `bth sync [<remote>]` — push only this project's runs to the remote (filtered by `project_slug`)
+- `bth sync [<remote>] --pull` — pull only this project's runs from the remote
+- Output: `Pushed 47 runs (filtered 275 from other projects) to 'engaging' in 1.2s`
+- Config: `sync_filter = "none"` in `.bth.toml` disables filtering (pushes all projects)
+
 **`bth remote`** — Manage sync remotes
 - `bth remote add <name> <url>` — add an SSH remote for catalog sync
 - `bth remote list` — list configured remotes

{bathos-0.3.1 → bathos-0.4.0}/README.md

@@ -60,8 +60,15 @@ bth sql "SELECT project_slug, count(*) FROM runs GROUP BY 1"
 - `bth lint [--project-root PATH]` — check scripts/ for naming conventions and missing sidecars
 - `bth new-experiment <name>` — scaffold a new experiment script and sidecar
 - `bth migrate` — upgrade cool-tier Parquet fragments to current schema version
+- `bth migrate-to-project-subdirs [--dry-run]` — move flat catalog runs into `runs/<slug>/` subdirs (v0.4+)
 - `bth export` — export the using-bathos skill and register MCP server
 
+**`bth sync`** — Sync cool-tier catalog to/from cluster (v0.4+: per-project filtered)
+- `bth sync [<remote>]` — push only this project's runs to the remote (filtered by `project_slug`)
+- `bth sync [<remote>] --pull` — pull only this project's runs from the remote
+- Output: `Pushed 47 runs (filtered 275 from other projects) to 'engaging' in 1.2s`
+- Config: `sync_filter = "none"` in `.bth.toml` disables filtering (pushes all projects)
+
 **`bth remote`** — Manage sync remotes
 - `bth remote add <name> <url>` — add an SSH remote for catalog sync
 - `bth remote list` — list configured remotes

{bathos-0.3.1 → bathos-0.4.0}/agent_assets/using_bathos/SKILL.md

@@ -13,7 +13,7 @@ description: "Use when working in any bathos-tracked research project — experi
 
 **Scope:** Single researcher, 10+ projects, SLURM cluster integration.
 
-**Status:** ✅ v0.3.0 shipped — 254 tests passing. Full CLI + MCP server available, including campaigns and agentic integrity gates.
+**Status:** ✅ v0.4.0 shipped — 333 tests passing. Full CLI + MCP server available, including campaigns, agentic integrity gates, and per-project sync filtering.
 
 ---
 

{bathos-0.3.1 → bathos-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bathos"
-version = "0.3.1"
+version = "0.4.0"
 description = "Local-first, zero-server experiment tracking for researchers"
 readme = "README.md"
 requires-python = ">=3.12"

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 from bathos.decorators import experiment
 

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/catalog.py

@@ -15,7 +15,7 @@ def init_catalog(catalog_dir: Path) -> None:
 
 def write_run(run: Run, catalog_dir: Path) -> None:
     """Write (or overwrite) a run record atomically."""
-    runs_dir = catalog_dir / "runs"
+    runs_dir = catalog_dir / "runs" / run.project_slug
     runs_dir.mkdir(parents=True, exist_ok=True)
     target = runs_dir / f"run_{run.id}.parquet"
     tmp = runs_dir / f"run_{run.id}.tmp.parquet"
@@ -28,7 +28,7 @@ def read_runs(catalog_dir: Path) -> list[Run]:
     runs_dir = catalog_dir / "runs"
     if not runs_dir.exists():
         return []
-    parquet_files = list(runs_dir.glob("run_*.parquet"))
+    parquet_files = list(runs_dir.rglob("run_*.parquet"))
     if not parquet_files:
         return []
     tables = [pq.read_table(f) for f in parquet_files]

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/cli.py

@@ -595,9 +595,10 @@ def sync(
 
     try:
         result = sync_catalog(remote, config, catalog_dir, pull=pull)
-        direction = "pulled" if pull else "pushed"
+        direction = "Pulled" if pull else "Pushed"
+        filter_msg = f" (filtered {result.filtered} from other projects)" if result.filtered > 0 else ""
         typer.echo(
-            f"{direction.capitalize()} {result.transferred} runs to/from '{result.remote}' in {result.duration_s:.1f}s"
+            f"{direction} {result.transferred} runs{filter_msg} to/from '{result.remote}' in {result.duration_s:.1f}s"
         )
     except ValueError as e:
         typer.echo(str(e), err=True)
@@ -624,6 +625,27 @@ def migrate(
         typer.echo("  Nothing to migrate.")
 
 
+@app.command("migrate-to-project-subdirs")
+def migrate_to_subdirs_cmd(
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be moved without writing"),
+):
+    """Move flat cool-tier run parquets into per-project subdirectories.
+
+    Reads each run's project_slug and moves it to runs/<slug>/run_<uuid>.parquet.
+    Run this on both local and remote before using per-project sync filtering.
+    """
+    from bathos.migrate import migrate_to_project_subdirs
+
+    result = migrate_to_project_subdirs(_catalog_dir(), dry_run=dry_run)
+    action = "Would move" if dry_run else "Moved"
+    typer.echo(f"{action} {result.moved} run(s) into per-project subdirectories.")
+    if result.skipped:
+        typer.echo(f"  {result.skipped} already in place (skipped).")
+    if result.by_slug:
+        for slug, count in sorted(result.by_slug.items()):
+            typer.echo(f"  {slug}: {count}")
+
+
 @app.command("sprint-audit")
 def sprint_audit_cmd(
     hours: int = typer.Option(24, "--hours", help="Lookback window in hours"),

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/compact.py

@@ -180,7 +180,7 @@ def _fragment_count(catalog_dir: Path) -> int:
     runs_dir = catalog_dir / "runs"
     if not runs_dir.exists():
         return 0
-    return len(list(runs_dir.glob("run_*.parquet")))
+    return len(list(runs_dir.rglob("run_*.parquet")))
 
 
 def should_compact(catalog_dir: Path) -> bool:

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/config.py

@@ -14,6 +14,7 @@ class ProjectConfig:
     catalog_dir: Path = field(default_factory=lambda: Path.home() / ".bth" / "catalog")
     remotes: dict[str, dict] = field(default_factory=dict)
     slurm: dict = field(default_factory=dict)
+    sync_filter: str = "project_slug"
 
 
 def default_catalog_dir() -> Path:
@@ -38,6 +39,7 @@ def load_project_config(path: Path) -> ProjectConfig:
         catalog_dir=Path(project["catalog_dir"]) if "catalog_dir" in project else default_catalog_dir(),
         remotes=data.get("remotes", {}),
         slurm=data.get("slurm", {}),
+        sync_filter=project.get("sync_filter", "project_slug"),
     )
 
 

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/mcp.py

@@ -316,6 +316,7 @@ def sync_tool(
             "transferred": result.transferred,
             "duration_s": result.duration_s,
             "remote": result.remote,
+            "filtered": result.filtered,
         }
         return json.dumps(result_dict, indent=2)
     except Exception as e:

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/migrate.py

@@ -24,7 +24,7 @@ def migrate_catalog(catalog_dir: Path, dry_run: bool = False) -> MigrateResult:
     if not runs_dir.exists():
         return MigrateResult(scanned=0, already_current=0, migrated=0, dry_run=dry_run)
 
-    fragments = list(runs_dir.glob("run_*.parquet"))
+    fragments = list(runs_dir.rglob("run_*.parquet"))
     current_names = {f.name for f in COOL_SCHEMA}
     migrated = 0
 
@@ -62,6 +62,61 @@ def migrate_catalog(catalog_dir: Path, dry_run: bool = False) -> MigrateResult:
     )
 
 
+@dataclass
+class MigrateToSubdirsResult:
+    moved: int
+    skipped: int
+    by_slug: dict
+    dry_run: bool
+
+
+def migrate_to_project_subdirs(catalog_dir: Path, dry_run: bool = False) -> MigrateToSubdirsResult:
+    """Move flat cool-tier run parquets into per-project subdirectories.
+
+    Reads project_slug from each parquet and moves it to runs/<slug>/run_<uuid>.parquet.
+    Files already in a subdir are skipped. Idempotent.
+    Falls back to 'default' for parquets without a readable project_slug.
+    """
+    from collections import Counter
+
+    runs_dir = catalog_dir / "runs"
+    if not runs_dir.exists():
+        return MigrateToSubdirsResult(moved=0, skipped=0, by_slug={}, dry_run=dry_run)
+
+    # Only consider directly-nested parquets (flat layout), not already-subdir'd ones
+    flat_files = [f for f in runs_dir.glob("run_*.parquet")]
+
+    moves = []
+    for parquet in flat_files:
+        slug = _read_project_slug(parquet) or "default"
+        dst = runs_dir / slug / parquet.name
+        moves.append((parquet, dst))
+
+    if not dry_run:
+        for src, dst in moves:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            src.rename(dst)
+
+    by_slug = dict(Counter(dst.parent.name for _, dst in moves))
+    return MigrateToSubdirsResult(
+        moved=len(moves),
+        skipped=len(flat_files) - len(moves),
+        by_slug=by_slug,
+        dry_run=dry_run,
+    )
+
+
+def _read_project_slug(parquet: Path) -> str | None:
+    """Read project_slug from the first row of a parquet file."""
+    try:
+        tbl = pq.read_table(parquet, columns=["project_slug"])
+        if tbl.num_rows > 0:
+            return tbl["project_slug"][0].as_py()
+    except Exception:
+        pass
+    return None
+
+
 def _default_array(arrow_type: pa.DataType, n: int) -> pa.Array:
     if pa.types.is_string(arrow_type) or pa.types.is_large_string(arrow_type):
         return pa.array([""] * n, type=arrow_type)

{bathos-0.3.1 → bathos-0.4.0}/src/bathos/sync.py

@@ -17,6 +17,7 @@ class SyncResult:
     transferred: int
     duration_s: float
     remote: str
+    filtered: int = 0
 
 
 def sync_catalog(
@@ -45,8 +46,27 @@ def sync_catalog(
     host = remote_config["host"]
     remote_root = remote_config["remote_root"]
 
-    local_runs = catalog_dir / "runs"
-    remote_runs = f"{host}:{remote_root}/.bth/catalog/runs/"
+    project_slug = config.slug
+    sync_filter = getattr(config, "sync_filter", "project_slug")
+
+    if sync_filter == "project_slug":
+        local_runs = catalog_dir / "runs" / project_slug
+        remote_runs = f"{host}:{remote_root}/.bth/catalog/runs/{project_slug}/"
+        # Count filtered runs (total in catalog minus this project's runs)
+        runs_root = catalog_dir / "runs"
+        if not pull and runs_root.exists():
+            total = len(list(runs_root.rglob("run_*.parquet")))
+            project_count = len(list(local_runs.glob("run_*.parquet"))) if local_runs.exists() else 0
+            filtered = total - project_count
+        else:
+            filtered = 0
+    else:
+        local_runs = catalog_dir / "runs"
+        remote_runs = f"{host}:{remote_root}/.bth/catalog/runs/"
+        filtered = 0
+
+    if not pull:
+        local_runs.mkdir(parents=True, exist_ok=True)
 
     if pull:
         src = remote_runs
@@ -88,7 +108,7 @@ def sync_catalog(
     # rsync outputs something like "Number of regular files transferred: 42"
     transferred = _parse_transferred_count(result.stdout)
 
-    return SyncResult(transferred=transferred, duration_s=duration_s, remote=remote_name)
+    return SyncResult(transferred=transferred, duration_s=duration_s, remote=remote_name, filtered=filtered)
 
 
 def _parse_transferred_count(rsync_output: str) -> int:

{bathos-0.3.1 → bathos-0.4.0}/tests/test_catalog.py

@@ -24,7 +24,7 @@ def test_write_and_read_single_run(tmp_catalog: Path, sample_run: Run):
 def test_write_creates_parquet_file(tmp_catalog: Path, sample_run: Run):
     init_catalog(tmp_catalog)
     write_run(sample_run, tmp_catalog)
-    files = list((tmp_catalog / "runs").glob("*.parquet"))
+    files = list((tmp_catalog / "runs").rglob("*.parquet"))
     assert len(files) == 1
     assert sample_run.id in files[0].name
 

{bathos-0.3.1 → bathos-0.4.0}/tests/test_cli.py

@@ -186,8 +186,8 @@ def test_sql_allows_arbitrary_queries(tmp_path: Path, monkeypatch):
     # Create a run to have Parquet files
     runner.invoke(app, ["run", sys.executable, "--", "-c", "pass"])
 
-    # Query using read_parquet should work without warm DB
-    glob = str(catalog / "runs" / "run_*.parquet")
+    # Query using read_parquet should work without warm DB (runs are in per-project subdir)
+    glob = str(catalog / "runs" / "testproj" / "run_*.parquet")
     result = runner.invoke(app, ["sql", f"SELECT COUNT(*) FROM read_parquet('{glob}')"])
     assert result.exit_code == 0
     assert "1" in result.output

{bathos-0.3.1 → bathos-0.4.0}/tests/test_cluster_workflow.py

@@ -119,7 +119,7 @@ remote_root = "~/projects/testproj"
     write_run(run2, catalog)
 
     # Verify we have 2 cool fragments
-    run_files = list((catalog / "runs").glob("run_*.parquet"))
+    run_files = list((catalog / "runs").rglob("run_*.parquet"))
     assert len(run_files) == 2, f"Expected 2 run files, got {len(run_files)}"
 
     # Step 3: Compact cool fragments → warm DuckDB
@@ -238,7 +238,7 @@ def test_cluster_workflow_with_slurm_job_id(git_repo: Path, monkeypatch):
     write_run(run, catalog)
 
     # Verify SLURM_JOB_ID is in the written fragment
-    run_files = list((catalog / "runs").glob("run_*.parquet"))
+    run_files = list((catalog / "runs").rglob("run_*.parquet"))
     assert len(run_files) == 1
 
     # Compact and verify slurm_job_id is preserved in warm tier

{bathos-0.3.1 → bathos-0.4.0}/tests/test_integration.py

@@ -61,8 +61,8 @@ def test_full_workflow(tmp_path: Path, monkeypatch):
     assert run_id in r.output
     assert "intproj" in r.output
 
-    # 7. sql escape hatch (cool tier)
-    glob = str(catalog / "runs" / "run_*.parquet")
+    # 7. sql escape hatch (cool tier; runs are in per-project subdirs)
+    glob = str(catalog / "runs" / "intproj" / "run_*.parquet")
     r = runner.invoke(app, ["sql", f"SELECT count(*) FROM read_parquet('{glob}')"])
     assert r.exit_code == 0
     assert "2" in r.output

{bathos-0.3.1 → bathos-0.4.0}/tests/test_query.py

@@ -71,7 +71,7 @@ def test_find_runs_since(populated_catalog: Path):
 
 
 def test_run_sql_returns_rows(populated_catalog: Path):
-    glob = str(populated_catalog / "runs" / "run_*.parquet")
+    glob = str(populated_catalog / "runs" / "**" / "run_*.parquet")
     rows = run_sql(
         f"SELECT project_slug, count(*) as n FROM read_parquet('{glob}') GROUP BY 1 ORDER BY 1"
     )

{bathos-0.3.1 → bathos-0.4.0}/tests/test_remote.py

@@ -615,7 +615,7 @@ class TestSyncAutoSelection:
                 mock_load.return_value = config
 
                 with patch("bathos.cli.sync_catalog") as mock_sync:
-                    mock_sync.return_value = MagicMock(transferred=3, remote="engaging", duration_s=0.8)
+                    mock_sync.return_value = MagicMock(transferred=3, remote="engaging", duration_s=0.8, filtered=0)
 
                     result = cli_runner.invoke(app, ["sync"])
 

bathos-0.4.0/tests/test_sync_project_filter.py

@@ -0,0 +1,212 @@
+"""Tests for per-project sync filtering and migration to project subdirectories."""
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+
+from bathos.catalog import write_run
+from bathos.config import ProjectConfig
+from bathos.migrate import migrate_to_project_subdirs
+from bathos.schema import Run
+from bathos.sync import SyncResult, sync_catalog
+
+
+def _make_run(slug: str, suffix: str = "") -> Run:
+    return Run(
+        project_slug=slug,
+        command=f"python {slug}{suffix}.py",
+        argv=["python", f"{slug}{suffix}.py"],
+        git_hash="abc123",
+        git_branch="main",
+        git_dirty=False,
+    )
+
+
+def _write_flat(runs_dir: Path, slug: str, suffix: str = "") -> Path:
+    """Write a parquet with project_slug directly in the flat runs/ dir (pre-migration layout)."""
+    run = _make_run(slug, suffix)
+    tbl = run.to_arrow()
+    path = runs_dir / f"run_{run.id}.parquet"
+    pq.write_table(tbl, path)
+    return path
+
+
+def _config(tmp_path: Path, slug: str, sync_filter: str = "project_slug") -> ProjectConfig:
+    return ProjectConfig(
+        slug=slug,
+        root=tmp_path,
+        remotes={"engaging": {"host": "engaging", "remote_root": f"~/projects/{slug}"}},
+        sync_filter=sync_filter,
+    )
+
+
+# ---------------------------------------------------------------------------
+# 1. Sync filters by slug: only this project's subdir is pushed
+# ---------------------------------------------------------------------------
+
+def test_sync_filters_by_slug(tmp_path: Path):
+    catalog = tmp_path / "catalog"
+    config = _config(tmp_path, "asr")
+
+    # Write runs for two projects into their respective subdirs via write_run
+    write_run(_make_run("asr"), catalog)
+    write_run(_make_run("asr", "_2"), catalog)
+    write_run(_make_run("prolix"), catalog)
+
+    with patch("bathos.sync.subprocess.run") as mock_run:
+        mock_run.return_value.returncode = 0
+        mock_run.return_value.stdout = "Number of regular files transferred: 2"
+
+        result = sync_catalog("engaging", config, catalog, pull=False)
+
+        cmd = mock_run.call_args[0][0]
+        # Source should be the project-slug subdir
+        assert any(f"runs/asr/" in str(a) for a in cmd), f"Expected runs/asr/ in cmd: {cmd}"
+        # Should NOT reference prolix
+        assert not any("prolix" in str(a) for a in cmd)
+        # Filtered count: 1 prolix run
+        assert result.filtered == 1
+
+
+# ---------------------------------------------------------------------------
+# 2. sync_filter="none" preserves current flat behavior
+# ---------------------------------------------------------------------------
+
+def test_sync_no_filter_mode_preserves_current_behavior(tmp_path: Path):
+    catalog = tmp_path / "catalog"
+    config = _config(tmp_path, "asr", sync_filter="none")
+
+    write_run(_make_run("asr"), catalog)
+    write_run(_make_run("prolix"), catalog)
+
+    with patch("bathos.sync.subprocess.run") as mock_run:
+        mock_run.return_value.returncode = 0
+        mock_run.return_value.stdout = ""
+
+        result = sync_catalog("engaging", config, catalog, pull=False)
+
+        cmd = mock_run.call_args[0][0]
+        # Source should be the flat runs/ dir (no slug subdir)
+        assert any(str(catalog / "runs") + "/" in str(a) for a in cmd), f"Expected flat runs/ in cmd: {cmd}"
+        assert not any("asr" in str(a) and "runs/asr" in str(a) for a in cmd)
+        assert result.filtered == 0
+
+
+# ---------------------------------------------------------------------------
+# 3. Pull uses project-slug subdir as destination
+# ---------------------------------------------------------------------------
+
+def test_sync_pull_targets_project_subdir(tmp_path: Path):
+    catalog = tmp_path / "catalog"
+    config = _config(tmp_path, "asr")
+
+    with patch("bathos.sync.subprocess.run") as mock_run:
+        mock_run.return_value.returncode = 0
+        mock_run.return_value.stdout = ""
+
+        sync_catalog("engaging", config, catalog, pull=True)
+
+        cmd = mock_run.call_args[0][0]
+        # Remote source should include the slug subdir
+        assert any("runs/asr/" in str(a) for a in cmd), f"Expected runs/asr/ in cmd: {cmd}"
+        # Local destination should also include the slug subdir
+        assert any(str(catalog / "runs" / "asr") in str(a) for a in cmd)
+
+
+# ---------------------------------------------------------------------------
+# 4. migrate_to_project_subdirs --dry-run reports counts but doesn't move
+# ---------------------------------------------------------------------------
+
+def test_migrate_to_project_subdirs_dry_run(tmp_path: Path):
+    runs_dir = tmp_path / "runs"
+    runs_dir.mkdir()
+    _write_flat(runs_dir, "asr")
+    _write_flat(runs_dir, "prolix")
+
+    result = migrate_to_project_subdirs(tmp_path, dry_run=True)
+
+    assert result.moved == 2
+    assert result.dry_run is True
+    # Files should still be in the flat dir
+    assert len(list(runs_dir.glob("run_*.parquet"))) == 2
+    assert not (runs_dir / "asr").exists()
+    assert not (runs_dir / "prolix").exists()
+
+
+# ---------------------------------------------------------------------------
+# 5. migrate_to_project_subdirs is idempotent
+# ---------------------------------------------------------------------------
+
+def test_migrate_to_project_subdirs_idempotent(tmp_path: Path):
+    runs_dir = tmp_path / "runs"
+    runs_dir.mkdir()
+    _write_flat(runs_dir, "asr")
+    _write_flat(runs_dir, "prolix")
+
+    result1 = migrate_to_project_subdirs(tmp_path, dry_run=False)
+    assert result1.moved == 2
+
+    # Second call: no flat files left → nothing to move
+    result2 = migrate_to_project_subdirs(tmp_path, dry_run=False)
+    assert result2.moved == 0
+
+    # Files are in the right places
+    assert len(list((runs_dir / "asr").glob("run_*.parquet"))) == 1
+    assert len(list((runs_dir / "prolix").glob("run_*.parquet"))) == 1
+
+
+# ---------------------------------------------------------------------------
+# 6. Migration fallback for parquets without a project_slug
+# ---------------------------------------------------------------------------
+
+def test_migrate_fallback_for_runs_without_slug(tmp_path: Path):
+    runs_dir = tmp_path / "runs"
+    runs_dir.mkdir()
+
+    # Write a parquet with no project_slug column
+    tbl = pa.table({"id": ["abc-123"], "command": ["python test.py"]})
+    path = runs_dir / "run_abc-123.parquet"
+    pq.write_table(tbl, path)
+
+    result = migrate_to_project_subdirs(tmp_path, dry_run=False)
+
+    assert result.moved == 1
+    assert result.by_slug == {"default": 1}
+    assert (runs_dir / "default" / "run_abc-123.parquet").exists()
+
+
+# ---------------------------------------------------------------------------
+# 7. bth ls finds runs after migration (read_runs uses rglob)
+# ---------------------------------------------------------------------------
+
+def test_ls_finds_runs_in_subdirs(tmp_path: Path):
+    from bathos.catalog import read_runs
+
+    catalog = tmp_path / "catalog"
+    run = _make_run("asr")
+    write_run(run, catalog)  # now writes to catalog/runs/asr/
+
+    runs = read_runs(catalog)
+    assert len(runs) == 1
+    assert runs[0].project_slug == "asr"
+    assert runs[0].id == run.id
+
+
+# ---------------------------------------------------------------------------
+# 8. bth run writes new runs under runs/<slug>/
+# ---------------------------------------------------------------------------
+
+def test_run_writes_to_project_subdir(tmp_path: Path):
+    from bathos.catalog import write_run
+
+    catalog = tmp_path / "catalog"
+    run = _make_run("myproject")
+    write_run(run, catalog)
+
+    # Should be under runs/myproject/, NOT in runs/ directly
+    assert (catalog / "runs" / "myproject" / f"run_{run.id}.parquet").exists()
+    assert not (catalog / "runs" / f"run_{run.id}.parquet").exists()

{bathos-0.3.1 → bathos-0.4.0}/uv.lock

@@ -57,7 +57,7 @@ wheels = [
 
 [[package]]
 name = "bathos"
-version = "0.3.1"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "duckdb" },