xarray-spatial 0.9.7__tar.gz → 0.9.8__tar.gz

{xarray_spatial-0.9.7 → xarray_spatial-0.9.8}/.claude/commands/bench.md

@@ -1,6 +1,6 @@
 # Bench: Local Performance Comparison
 
-Run ASV benchmarks for the current branch against master and report regressions
+Run ASV benchmarks for the current branch against main and report regressions
 and improvements. The prompt is: $ARGUMENTS
 
 ---
@@ -9,7 +9,7 @@ and improvements. The prompt is: $ARGUMENTS
 
 1. If $ARGUMENTS names specific benchmark classes or functions (e.g. `Slope`,
    `flow_accumulation`), use those directly.
-2. If $ARGUMENTS is empty or says "auto", run `git diff origin/master --name-only`
+2. If $ARGUMENTS is empty or says "auto", run `git diff origin/main --name-only`
    to find changed source files under `xrspatial/`. Map each changed file to the
    corresponding benchmark module in `benchmarks/benchmarks/`. Use the filename
    and imports to match (e.g. changes to `slope.py` map to `benchmarks/benchmarks/slope.py`).
@@ -30,7 +30,7 @@ and improvements. The prompt is: $ARGUMENTS
 Run ASV in continuous-comparison mode from the `benchmarks/` directory:
 
 ```bash
-cd benchmarks && asv continuous origin/master HEAD -b "<regex>" -e
+cd benchmarks && asv continuous origin/main HEAD -b "<regex>" -e
 ```
 
 Where `<regex>` is a pattern matching the benchmark classes identified in Step 1
@@ -64,7 +64,7 @@ Parse the output and classify each result:
 ## Step 5 -- Generate the report
 
 ```
-## Benchmark Report: <branch> vs master
+## Benchmark Report: <branch> vs main
 
 ### Changed files
 - <list of changed source files>
@@ -74,7 +74,7 @@ Parse the output and classify each result:
 
 ### Results
 
-| Benchmark                          | master    | HEAD      | Ratio | Status     |
+| Benchmark                          | main    | HEAD      | Ratio | Status     |
 |------------------------------------|-----------|-----------|-------|------------|
 | slope.Slope.time_numpy             | 3.45 ms   | 3.51 ms   | 1.02x | UNCHANGED  |
 | slope.Slope.time_dask_numpy        | 8.12 ms   | 4.23 ms   | 0.52x | IMPROVED   |
@@ -124,4 +124,4 @@ Do NOT write benchmark files automatically. Report the gap and propose, then wai
   analysis (unless the user explicitly asks for a benchmark to be written in
   response to Step 6).
 - If $ARGUMENTS says "compare <branch1> <branch2>", run
-  `asv continuous <branch1> <branch2>` instead of the default origin/master vs HEAD.
+  `asv continuous <branch1> <branch2>` instead of the default origin/main vs HEAD.

{xarray_spatial-0.9.7 → xarray_spatial-0.9.8}/.claude/commands/efficiency-audit.md

@@ -267,7 +267,7 @@ Thresholds: IMPROVED < 0.8x, REGRESSION > 1.2x, else UNCHANGED.
 - If $ARGUMENTS includes a severity filter (e.g. "high only"), only report
   findings at that severity level.
 - If $ARGUMENTS includes "diff" or "changed", restrict the audit to files
-  changed on the current branch vs origin/master.
+  changed on the current branch vs origin/main.
 - Baseline benchmark scripts are disposable. Clean up `/tmp/` scripts after
   capturing results.
 - The 512x512 array size is a default. If $ARGUMENTS includes a size like

{xarray_spatial-0.9.7 → xarray_spatial-0.9.8}/.claude/commands/release-major.md

@@ -16,7 +16,7 @@ $ARGUMENTS
 ## Step 2 -- Create a release branch
 
 ```bash
-git checkout master && git pull
+git checkout main && git pull
 git checkout -b release/vX.Y.Z
 ```
 
@@ -49,7 +49,7 @@ git push -u origin release/vX.Y.Z
 
 ## Step 5 -- Verify CI
 
-1. Run `gh pr create --title "Release vX.Y.Z" --body "Changelog update for vX.Y.Z major release."` to open a PR against master.
+1. Run `gh pr create --title "Release vX.Y.Z" --body "Changelog update for vX.Y.Z major release."` to open a PR against main.
 2. Wait for CI:
    ```bash
    gh pr checks <PR_NUMBER> --watch
@@ -65,7 +65,7 @@ gh pr merge <PR_NUMBER> --merge --delete-branch
 ## Step 7 -- Tag the release
 
 ```bash
-git checkout master && git pull
+git checkout main && git pull
 git tag -a vX.Y.Z -m "Version X.Y.Z"
 git push origin vX.Y.Z
 ```

{xarray_spatial-0.9.7 → xarray_spatial-0.9.8}/.claude/commands/release-minor.md

@@ -16,7 +16,7 @@ $ARGUMENTS
 ## Step 2 -- Create a release branch
 
 ```bash
-git checkout master && git pull
+git checkout main && git pull
 git checkout -b release/vX.Y.Z
 ```
 
@@ -49,7 +49,7 @@ git push -u origin release/vX.Y.Z
 
 ## Step 5 -- Verify CI
 
-1. Run `gh pr create --title "Release vX.Y.Z" --body "Changelog update for vX.Y.Z minor release."` to open a PR against master.
+1. Run `gh pr create --title "Release vX.Y.Z" --body "Changelog update for vX.Y.Z minor release."` to open a PR against main.
 2. Wait for CI:
    ```bash
    gh pr checks <PR_NUMBER> --watch
@@ -65,7 +65,7 @@ gh pr merge <PR_NUMBER> --merge --delete-branch
 ## Step 7 -- Tag the release
 
 ```bash
-git checkout master && git pull
+git checkout main && git pull
 git tag -a vX.Y.Z -m "Version X.Y.Z"
 git push origin vX.Y.Z
 ```

{xarray_spatial-0.9.7 → xarray_spatial-0.9.8}/.claude/commands/release-patch.md

@@ -16,7 +16,7 @@ $ARGUMENTS
 ## Step 2 -- Create a release branch
 
 ```bash
-git checkout master && git pull
+git checkout main && git pull
 git checkout -b release/vX.Y.Z
 ```
 
@@ -46,7 +46,7 @@ git push -u origin release/vX.Y.Z
 
 ## Step 5 -- Verify CI
 
-1. Run `gh pr create --title "Release vX.Y.Z" --body "Changelog update for vX.Y.Z patch release."` to open a PR against master.
+1. Run `gh pr create --title "Release vX.Y.Z" --body "Changelog update for vX.Y.Z patch release."` to open a PR against main.
 2. Wait for CI:
    ```bash
    gh pr checks <PR_NUMBER> --watch
@@ -62,7 +62,7 @@ gh pr merge <PR_NUMBER> --merge --delete-branch
 ## Step 7 -- Tag the release
 
 ```bash
-git checkout master && git pull
+git checkout main && git pull
 git tag -a vX.Y.Z -m "Version X.Y.Z"
 git push origin vX.Y.Z
 ```

{xarray_spatial-0.9.7 → xarray_spatial-0.9.8}/.claude/commands/sweep-accuracy.md

@@ -36,28 +36,30 @@ Store results in memory -- do NOT write intermediate files.
 
 ## Step 2 -- Load inspection state
 
-Read `.claude/sweep-accuracy-state.json`.
+Read `.claude/sweep-accuracy-state.csv`.
 
 If it does not exist, treat every module as never-inspected.
 
 If `$ARGUMENTS` contains `--reset-state`, delete the file and treat
 everything as never-inspected.
 
-State file schema:
-
-```json
-{
-  "inspections": {
-    "slope": {
-      "last_inspected": "2026-03-28T14:00:00Z",
-      "issue": 1042,
-      "severity_max": "HIGH",
-      "categories_found": [1, 3]
-    }
-  }
-}
+State file schema (one row per module):
+
+```
+module,last_inspected,issue,severity_max,categories_found,notes
+slope,2026-03-28,1042,HIGH,1;3,"optional single-line notes"
 ```
 
+- `categories_found` is a semicolon-separated integer list (empty when null).
+- `notes` is CSV-quoted; newlines must be flattened to spaces on write so
+  every module stays exactly one line.
+
+The file is registered with `merge=union` in `.gitattributes`, so two
+parallel sweeps touching different modules auto-merge without conflict.
+A transient duplicate-row state can occur after a merge if both branches
+modified the same module; the read-update-write cycle in step 5 keys rows
+by `module` and last-write-wins, so the next write cleans up.
+
 ## Step 3 -- Score each module
 
 ```
@@ -196,14 +198,49 @@ xrspatial/tests/general_checks.py for the cross-backend comparison helpers.
    For MEDIUM/LOW issues, document them but do not fix.
 
 5. After finishing (whether you found issues or not), update the inspection
-   state file .claude/sweep-accuracy-state.json by reading its current
-   contents and adding/updating the entry for "{module}" with:
-   - "last_inspected": today's ISO date
-   - "issue": the issue number from rockout (or null if clean / MEDIUM-only)
-   - "severity_max": highest severity found (or null if clean)
-   - "categories_found": list of category numbers that had findings (e.g. [1, 3])
-
-   Then `git add .claude/sweep-accuracy-state.json` and commit it to the
+   state file .claude/sweep-accuracy-state.csv. The file is row-per-module
+   CSV with header:
+
+   `module,last_inspected,issue,severity_max,categories_found,notes`
+
+   Use this Python pattern to read, update, and write it (do NOT hand-edit
+   the file -- always go through csv.DictReader / csv.DictWriter so quoting
+   stays consistent):
+
+   ```python
+   import csv
+   from pathlib import Path
+
+   path = Path(".claude/sweep-accuracy-state.csv")
+   header = ["module", "last_inspected", "issue", "severity_max",
+             "categories_found", "notes"]
+
+   rows = {}
+   if path.exists():
+       with path.open() as f:
+           for r in csv.DictReader(f):
+               rows[r["module"]] = r  # last write wins on dupes
+
+   rows["{module}"] = {
+       "module": "{module}",
+       "last_inspected": "<today's ISO date, e.g. 2026-04-27>",
+       "issue": "<issue number from rockout, or empty string>",
+       "severity_max": "<HIGH|MEDIUM|LOW, or empty>",
+       "categories_found": "<semicolon-joined ints, e.g. 1;3, or empty>",
+       "notes": "<single-line notes (replace any newlines with spaces), or empty>",
+   }
+
+   with path.open("w", newline="") as f:
+       w = csv.DictWriter(f, fieldnames=header, quoting=csv.QUOTE_MINIMAL)
+       w.writeheader()
+       for m in sorted(rows):
+           w.writerow(rows[m])
+   ```
+
+   Use empty strings (not `null`) for missing values. Set `issue` to the
+   issue number when one was filed, otherwise leave it empty.
+
+   Then `git add .claude/sweep-accuracy-state.csv` and commit it to the
    worktree branch so the state update is included in the PR.
 
 Important:
@@ -236,7 +273,7 @@ State is updated by the subagents themselves (see agent prompt step 5).
 After completion, verify state with:
 
 ```
-cat .claude/sweep-accuracy-state.json
+column -t -s, .claude/sweep-accuracy-state.csv | less
 ```
 
 To reset all tracking: `/sweep-accuracy --reset-state`
@@ -248,8 +285,10 @@ To reset all tracking: `/sweep-accuracy --reset-state`
 - Do NOT modify any source files directly. Subagents handle fixes via /rockout.
 - Keep the output concise -- the table and agent dispatch are the deliverables.
 - If $ARGUMENTS is empty, use defaults: top 3, no category filter, no exclusions.
-- State file (`.claude/sweep-accuracy-state.json`) is tracked in git.
-  Subagents must `git add` and commit it so the state update lands in the PR.
+- State file (`.claude/sweep-accuracy-state.csv`) is tracked in git, with
+  `merge=union` set in `.gitattributes` so parallel sweeps touching
+  different modules auto-merge. Subagents must `git add` and commit it so
+  the state update lands in the PR.
 - For subpackage modules (geotiff, reproject, hydro), the subagent should read
   ALL `.py` files in the subpackage directory, not just `__init__.py`.
 - Only flag patterns that are ACTUALLY present in the code. Do not report

xarray_spatial-0.9.8/.claude/commands/sweep-performance.md

@@ -0,0 +1,325 @@
+# Performance Sweep: Dispatch subagents to audit and fix performance issues
+
+Audit xrspatial modules for performance bottlenecks, OOM risk under 30TB dask
+workloads, and backend-specific anti-patterns. Subagents fix HIGH-severity
+findings via /rockout in the same agent that did the audit, in parallel.
+
+Optional arguments: $ARGUMENTS
+(e.g. `--top 5`, `--exclude slope,aspect`, `--only-io`, `--reset-state`)
+
+---
+
+## Step 0 -- Parse arguments
+
+Parse $ARGUMENTS for these flags (multiple may combine):
+
+| Flag | Effect |
+|------|--------|
+| `--top N` | Audit only the top N scored modules (default: 3) |
+| `--exclude mod1,mod2` | Remove named modules from scope |
+| `--only-terrain` | Restrict to: slope, aspect, curvature, terrain, terrain_metrics, hillshade, sky_view_factor |
+| `--only-focal` | Restrict to: focal, convolution, morphology, bilateral, edge_detection, glcm |
+| `--only-hydro` | Restrict to: flood, cost_distance, geodesic, surface_distance, viewshed, erosion, diffusion |
+| `--only-io` | Restrict to: geotiff, reproject, rasterize, polygonize |
+| `--reset-state` | Delete `.claude/sweep-performance-state.csv` and treat all modules as never-inspected |
+| `--no-fix` | Audit only; subagents do not run /rockout. Useful for re-triage without producing PRs. |
+| `--high-only` | Drop modules whose state row shows zero HIGH findings from the last triage within the past 30 days. |
+
+## Step 1 -- Discover modules in scope
+
+Enumerate all candidate modules. For each, record its file path(s):
+
+**Single-file modules:** Every `.py` file directly under `xrspatial/`, excluding
+`__init__.py`, `_version.py`, `__main__.py`, `utils.py`, `accessor.py`,
+`preview.py`, `dataset_support.py`, `diagnostics.py`, `analytics.py`.
+
+**Subpackage modules:** The `geotiff/`, `reproject/`, and `hydro/` directories
+under `xrspatial/`. Treat each subpackage as a single audit unit. List all
+`.py` files within each (excluding `__init__.py`).
+
+Apply `--only-*` and `--exclude` filters from Step 0 to narrow the list.
+
+Store the filtered module list in memory (do NOT write intermediate files).
+
+## Step 2 -- Gather metadata and score each module
+
+For every module in scope, collect:
+
+| Field | How |
+|-------|-----|
+| **last_modified** | `git log -1 --format=%aI -- <path>` (for subpackages, use the most recent file) |
+| **total_commits** | `git log --oneline -- <path> \| wc -l` |
+| **loc** | `wc -l < <path>` (for subpackages, sum all files) |
+| **has_dask_backend** | grep the file(s) for `_run_dask`, `map_overlap`, `map_blocks` |
+| **has_cuda_backend** | grep the file(s) for `@cuda.jit`, `import cupy` |
+| **is_io_module** | module is geotiff or reproject |
+| **has_existing_bench** | a file matching the module name exists in `benchmarks/benchmarks/` |
+
+### Load inspection state
+
+Read `.claude/sweep-performance-state.csv`. If it does not exist, treat every
+module as never-inspected. If `--reset-state` was set, delete the file first.
+
+State file schema (one row per module):
+
+```
+module,last_inspected,oom_verdict,bottleneck,high_count,issue,notes
+slope,2026-04-15,SAFE,compute-bound,0,,"optional single-line notes"
+```
+
+- `oom_verdict` is one of `SAFE`, `RISKY`, `WILL OOM`, or `N/A`.
+- `bottleneck` is one of `IO-bound`, `memory-bound`, `compute-bound`, `graph-bound`.
+- `issue` is normally an integer, but may be a string token like
+  `false-positive`, `fixed-in-tree`, or empty.
+- `notes` is CSV-quoted; newlines must be flattened to spaces on write so
+  every module stays exactly one line.
+
+The file is registered with `merge=union` in `.gitattributes`, so two
+parallel sweeps touching different modules auto-merge without conflict.
+A transient duplicate-row state can occur after a merge if both branches
+modified the same module; the read-update-write cycle in the agent prompt
+keys rows by `module` and last-write-wins, so the next write cleans up.
+
+### Compute scores
+
+```
+days_since_inspected = (today - last_inspected).days   # 9999 if never
+days_since_modified  = (today - last_modified).days
+
+score = (days_since_inspected * 3)
+      + (loc * 0.1)
+      + (total_commits * 0.5)
+      + (has_dask_backend * 200)
+      + (has_cuda_backend * 150)
+      + (is_io_module * 300)
+      - (days_since_modified * 0.2)
+      - (has_existing_bench * 100)
+```
+
+Sort modules by score descending. Apply `--top N` (default 3).
+
+If `--high-only` is set, drop any module whose state row shows
+`high_count == 0` AND `last_inspected` is within the last 30 days. The
+filter only looks at past triage results — it cannot predict findings on a
+never-inspected module.
+
+## Step 3 -- Print the ranked table and launch subagents
+
+### 3a. Print the ranked table
+
+Print a markdown table showing ALL scored modules (not just selected ones),
+sorted by score descending:
+
+```
+| Rank | Module          | Score  | Last Inspected | Dask | CUDA | IO  | LOC  |
+|------|-----------------|--------|----------------|------|------|-----|------|
+| 1    | geotiff         | 30600  | never          | yes  | no   | yes | 1400 |
+| 2    | viewshed        | 30050  | never          | yes  | yes  | no  | 800  |
+| ...  | ...             | ...    | ...            | ...  | ...  | ... | ...  |
+```
+
+### 3b. Launch subagents for the top N modules
+
+For each of the top N modules (default 3), launch an Agent in parallel using
+`isolation: "worktree"` and `mode: "auto"`. All N agents must be dispatched
+in a single message so they run concurrently.
+
+Each agent's prompt must be self-contained and follow this template (adapt
+the module name, paths, and metadata):
+
+~~~
+You are auditing the xrspatial module "{module}" for performance issues.
+
+This module has {commits} commits and {loc} lines of code.
+
+Read these files: {module_files}
+
+Also read xrspatial/utils.py for _validate_raster() behavior, and
+xrspatial/tests/general_checks.py for cross-backend test helpers.
+
+**Your task:**
+
+1. Read all listed files thoroughly, including the matching test file(s)
+   under xrspatial/tests/.
+
+2. Audit for these 6 categories. For each, look for the specific patterns
+   described. Only flag issues ACTUALLY present in the code.
+
+   **Cat 1 — Dask materialization**
+   - HIGH: `.values` on a dask-backed DataArray or CuPy array
+   - HIGH: `.compute()` inside a loop
+   - HIGH: `np.array()` or `np.asarray()` wrapping a dask or CuPy array
+   - MEDIUM: `da.stack()` without a following `.rechunk()`
+
+   **Cat 2 — Dask chunking and overlap**
+   - MEDIUM: `map_overlap` with depth >= chunk_size / 4
+   - MEDIUM: Missing `boundary` argument in `map_overlap`
+   - MEDIUM: Same function called twice on same input without caching
+   - MEDIUM: Python `for` loop iterating over dask chunks
+
+   **Cat 3 — GPU transfer**
+   - HIGH: `.data.get()` followed by CuPy operations (GPU→CPU→GPU round-trip)
+   - HIGH: `cupy.asarray()` inside a loop
+   - MEDIUM: Mixing NumPy and CuPy ops in same function without clear reason
+   - MEDIUM: Register pressure — count float64 local variables in `@cuda.jit`
+     kernels; flag if >20
+   - MEDIUM: Thread blocks >16x16 on kernels with >20 float64 locals
+
+   **Cat 4 — Memory allocation**
+   - MEDIUM: Unnecessary `.copy()` on arrays never mutated downstream
+   - MEDIUM: Large temporary arrays that could be fused into the kernel
+   - LOW: `np.zeros_like()` + fill loop where `np.empty()` would suffice
+
+   **Cat 5 — Numba anti-patterns**
+   - MEDIUM: Missing `@ngjit` on nested for-loops over `.data` arrays
+   - MEDIUM: `@jit` without `nopython=True`
+   - LOW: Type instability — initializing with int then assigning float
+   - LOW: Column-major iteration on row-major arrays (inner loop should be
+     last axis)
+
+   **Cat 6 — 30TB / 16GB OOM verdict**
+   For each dask code path, follow it end-to-end. Decide whether peak memory
+   scales with chunk size or with the full array. Optionally write a small
+   script under `/tmp/` (with a unique name including the module name) that
+   constructs the dask task graph and reports task count and fan-in:
+
+   ```python
+   import dask.array as da
+   import xarray as xr
+   import json
+
+   arr = da.zeros((2560, 2560), chunks=(256, 256), dtype='float64')
+   raster = xr.DataArray(arr, dims=['y', 'x'])
+   # add coords if needed
+   try:
+       result = MODULE_FUNCTION(raster, **DEFAULT_ARGS)
+       graph = result.__dask_graph__()
+       task_count = len(graph)
+       print(json.dumps({
+           "success": True,
+           "task_count": task_count,
+           "tasks_per_chunk": round(task_count / 100.0, 2),
+       }))
+   except Exception as e:
+       print(json.dumps({"success": False, "error": str(e)}))
+   ```
+
+   The script must NEVER call `.compute()` — graph construction only.
+
+   Verdict: one of `SAFE`, `RISKY`, `WILL OOM`, or `N/A` (no dask backend).
+
+3. Classify the module's bottleneck as ONE of:
+   `IO-bound`, `memory-bound`, `compute-bound`, `graph-bound`.
+
+4. For each real issue found, assign a severity (CRITICAL/HIGH/MEDIUM/LOW)
+   and note the exact file and line number.
+
+5. If any CRITICAL or HIGH issue is found, run /rockout to fix it end-to-end
+   (GitHub issue, worktree branch, fix, tests, and PR). Include the OOM
+   verdict, bottleneck classification, and affected backends in the rockout
+   prompt so it has full performance context.
+
+   Skip step 5 entirely if `--no-fix` was passed to the parent sweep.
+
+6. After finishing (whether you found issues or not), update the inspection
+   state file `.claude/sweep-performance-state.csv`. Header:
+
+   `module,last_inspected,oom_verdict,bottleneck,high_count,issue,notes`
+
+   Use this Python pattern to read, update, and write it (do NOT hand-edit
+   the file -- always go through csv.DictReader / csv.DictWriter so quoting
+   stays consistent):
+
+   ```python
+   import csv
+   from pathlib import Path
+
+   path = Path(".claude/sweep-performance-state.csv")
+   header = ["module", "last_inspected", "oom_verdict", "bottleneck",
+             "high_count", "issue", "notes"]
+
+   rows = {}
+   if path.exists():
+       with path.open() as f:
+           for r in csv.DictReader(f):
+               rows[r["module"]] = r  # last write wins on dupes
+
+   rows["{module}"] = {
+       "module": "{module}",
+       "last_inspected": "<today's ISO date, e.g. 2026-04-29>",
+       "oom_verdict": "<SAFE|RISKY|WILL OOM|N/A>",
+       "bottleneck": "<IO-bound|memory-bound|compute-bound|graph-bound>",
+       "high_count": "<integer, count of HIGH findings>",
+       "issue": "<issue number from rockout, or empty string>",
+       "notes": "<single-line notes (replace any newlines with spaces), or empty>",
+   }
+
+   with path.open("w", newline="") as f:
+       w = csv.DictWriter(f, fieldnames=header, quoting=csv.QUOTE_MINIMAL)
+       w.writeheader()
+       for m in sorted(rows):
+           w.writerow(rows[m])
+   ```
+
+   Use empty strings (not `null`) for missing values. Set `issue` to the
+   issue number when one was filed, otherwise leave it empty.
+
+   Then `git add .claude/sweep-performance-state.csv` and commit it to the
+   worktree branch so the state update is included in the PR.
+
+Important:
+- Only flag patterns ACTUALLY present in the code. False positives are worse
+  than missed issues.
+- Read the tests for this module before flagging a pattern as harmful — the
+  test may codify the current behavior intentionally.
+- For CUDA code, verify register pressure and bounds before flagging.
+- Do NOT flag the use of numba @jit itself as a performance issue. Focus on
+  what the JIT code does, not that it uses JIT.
+- For the hydro subpackage: focus on one representative variant (d8) in
+  detail, then note which dinf/mfd files share the same pattern. Do not read
+  all 29 files line by line.
+- This repo uses ArrayTypeFunctionMapping to dispatch across numpy/cupy/dask
+  backends. Check all backend paths, not just numpy.
+- Do NOT call `.compute()` in any analysis script. Graph construction only.
+~~~
+
+### 3c. Print a status line
+
+After dispatching, print:
+
+```
+Launched {N} performance audit agents: {module1}, {module2}, {module3}
+```
+
+## Step 4 -- State updates
+
+State is updated by the subagents themselves (see agent prompt step 6).
+After completion, verify state with:
+
+```
+column -t -s, .claude/sweep-performance-state.csv | less
+```
+
+To reset all tracking: `/sweep-performance --reset-state`
+
+---
+
+## General Rules
+
+- Do NOT modify any source files from the parent. Subagents handle fixes via
+  /rockout.
+- Keep the parent output concise — the ranked table and dispatch line are
+  the deliverables.
+- If $ARGUMENTS is empty, use defaults: top 3, no category filter, no
+  exclusions.
+- State file (`.claude/sweep-performance-state.csv`) is tracked in git, with
+  `merge=union` set in `.gitattributes` so parallel sweeps touching
+  different modules auto-merge. Subagents must `git add` and commit it so
+  the state update lands in the PR.
+- For subpackage modules (geotiff, reproject, hydro), the subagent reads ALL
+  `.py` files in the subpackage directory, not just `__init__.py`.
+- Only flag patterns that are ACTUALLY present in the code. Do not report
+  hypothetical issues or patterns that "could" occur with imaginary inputs.
+- False positives are worse than missed issues. When in doubt, skip.
+- The 30TB graph simulation NEVER calls `.compute()` — it constructs the
+  dask graph and inspects it.