Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
59 commits
Select commit Hold shift + click to select a range
641dcaa
sim: keep the world measured and assume league-level robots
isaac0804 Nov 10, 2026
0659239
referee: fix restart rules and the free-kick actions
isaac0804 Nov 10, 2026
03c5697
strategy: fix shared skills, tactics and ball handling
isaac0804 Nov 10, 2026
33defac
evaluation: fixed reference opponents, world and robot settings
isaac0804 Nov 10, 2026
7af415d
strategy: name each strategy after its module
isaac0804 Nov 10, 2026
119e1fd
evaluation: .strategy files, a frozen baseline and one fingerprint fo…
isaac0804 Nov 10, 2026
bcbbe2c
bundle: let a .strategy file drive real robots
isaac0804 Nov 10, 2026
e16649d
tools: one tool per question, stalls in the ledger, a cheap health check
isaac0804 Nov 11, 2026
5b623b0
strategy: skip short open-play passes, keep one attacker upfield in d…
isaac0804 Nov 11, 2026
3b5939f
examples: fix demos broken by the strategy renames
isaac0804 Nov 11, 2026
a3f387e
tools: the screen, on trial; fouls move into triage; moments.py trimmed
isaac0804 Nov 11, 2026
d4d090f
tools: screen in about 4 minutes; first track-record entry
isaac0804 Nov 11, 2026
49568ce
tools: remove the screen, which could not save evaluations
isaac0804 Nov 12, 2026
89c036b
replay: one match results store, reuse automatic
isaac0804 Nov 12, 2026
ea83269
tools: one match set-up in sim_setup for every tool
isaac0804 Nov 12, 2026
c44a34e
tools: rename triage to find_bugs, goal ledger to goal sources
isaac0804 Nov 12, 2026
4bc09bc
strategy: delete the ten retired strategies
isaac0804 Nov 12, 2026
a9aee7b
strategy: name the twelve strategies
isaac0804 Nov 12, 2026
410b5c5
tests: old strategy names load today's strategy
isaac0804 Nov 12, 2026
897ae88
tools: one match tool, evaluate.py, with a round robin as round 1
isaac0804 Nov 12, 2026
89cd19b
tools: evaluate.py plays the core only; the reserve joins with --all
isaac0804 Nov 12, 2026
ce7145a
tools: every evaluate.py round is the same round robin
isaac0804 Nov 12, 2026
2278fca
tools: evaluate.py keeps three flags: candidates, --at, --all
isaac0804 Nov 12, 2026
b5629db
tools: a round folder holds every match of its round
isaac0804 Nov 12, 2026
d4acc2c
skills: explain-result, debug-incident, field-session
isaac0804 Nov 12, 2026
c128d98
cleanup: drop the restart fuzzer and the fixed settings from the envi…
isaac0804 Nov 12, 2026
5e760dd
skills: change-strategy, and pointers from the docs
isaac0804 Nov 12, 2026
3cec922
pixi: upgrade the lock file to format v7
isaac0804 Nov 12, 2026
38c2afc
fix: a match's replay lands in its run dir, however deep
isaac0804 Nov 12, 2026
867a530
fix: evaluate.py before its first real run
isaac0804 Nov 12, 2026
bbd2320
docs: evaluate.py's round folders in usage lines; promotion in its ow…
isaac0804 Nov 12, 2026
c030b4f
evaluate.py: --confirm on fresh seeds, a second estimate, "dropped"
isaac0804 Nov 12, 2026
2da3601
evaluate.py: screen on seeds 1-6, accept only on fresh seeds (paired …
isaac0804 Nov 12, 2026
b9ee10f
docs: a first-strategy tutorial; delete research tools and stale docs
isaac0804 Nov 12, 2026
f0312b2
structure: drop the src/ layer in skills, motion_planning, team_contr…
isaac0804 Nov 12, 2026
5fda003
structure: shared/ and global_utils/ become geometry/
isaac0804 Nov 12, 2026
b60af11
tests: test_mapping_utils next to its module in entities/
isaac0804 Nov 12, 2026
a223b1e
tests: mirror the package names under utama_core/tests
isaac0804 Nov 12, 2026
3e64169
tools: group scripts by who uses them
isaac0804 Nov 12, 2026
4238f90
examples: move the three field-session scripts to tools/field
isaac0804 Nov 12, 2026
8a3e0de
dashboard: run as utama_core.dashboard; pixi tasks for evaluate and d…
isaac0804 Nov 12, 2026
70c2138
tests: the field scripts moved out of examples/ keep their import check
isaac0804 Nov 12, 2026
663ced6
structure: custom_referee/ becomes referee/
isaac0804 Nov 12, 2026
0aee61e
structure: rsoccer_simulator/ becomes simulator/, subpackages lowercase
isaac0804 Nov 12, 2026
e6e517a
docs: stale script references; demo_pendulum_match
isaac0804 Nov 12, 2026
5e3022b
dashboard: the Tournament tab becomes the Strategies tab
isaac0804 Nov 12, 2026
026d9b4
dashboard: runs send each match's stall flag, not its full stats (12 …
isaac0804 Nov 12, 2026
43c70a8
fix: paths one folder off after dropping src/; colours by seed; stale…
isaac0804 Nov 12, 2026
3b31867
docs: regenerate the package graph and data-flow picture after the re…
isaac0804 Nov 12, 2026
5161e40
dashboard: a strategy page with less text
isaac0804 Nov 12, 2026
26681d0
dashboard: runs newest first by date; the frozen reference as 'name (…
isaac0804 Nov 12, 2026
f39f2d0
dashboard: light theme, position and shot maps per strategy, newest m…
isaac0804 Nov 13, 2026
62bb494
dashboard: no test strategy in the list; the release file's matches l…
isaac0804 Nov 13, 2026
c1799af
docs: the tutorial looks around the dashboard first, with the replays…
isaac0804 Nov 13, 2026
7b02b5d
check_strategy_branch: docs/strategies.md is no longer on a strategy …
isaac0804 Nov 13, 2026
e7ff86a
docs: 27 files down to 10; merge what is still used, delete history, …
isaac0804 Nov 13, 2026
6d24055
docs: tutorials/ for step-by-step pages, docs/ for reference; consist…
isaac0804 Nov 13, 2026
e5fbd8b
docs: what was learned, where everyone can read it
isaac0804 Nov 13, 2026
ebbf523
skills: in .agents/skills for any agent; .claude/skills is a symlink
isaac0804 Nov 13, 2026
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
The table of contents is too big for display.
Diff view
Diff view
  •  
  •  
  •  
94 changes: 94 additions & 0 deletions .agents/skills/change-strategy/SKILL.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,94 @@
---
name: change-strategy
description: Write a new strategy or change an existing one, then test it, evaluate it against the champion and promote it if it wins - from branch to pull request. Use when asked to try a strategy idea, improve how a strategy plays, add a tactic for a strategy, or promote a strategy to the core. Not for explaining an existing result (explain-result) or fixing one incident (debug-incident).
---

# Change a strategy

The model behind every step (tactics, partitioners, referee restarts, past tactic bugs) is
`docs/strategy.md`; read its "Writing and evaluating a strategy" and "Strategy
branches" sections first. This skill is the order of the steps and the rules that are easy
to forget.

## 1. Branch

`strategy/<idea>` from `main`. In a git worktree run `tools/dev/setup_worktree.sh`, and symlink
`replays` from the main checkout so the match results store is shared.

## 2. Change one thing

- **New strategy:** a new file `utama_core/strategy/<name>.py` with
`build(outfield_robot_ids, motion_controller)` returning a `Strategy`. The catalog finds it; it
plays as a reserve until it is added to the core. Reuse `strategy/pickers.py`.
- **Changed strategy:** edit exactly one existing strategy module. Never new modules and an
edited one in the same branch.
- **New tactic:** a new module in `tactics/`. Never edit an existing tactic, `pickers.py` or
`catalog.py` on a strategy branch: the opponents run them. To improve a tactic, copy it and
change the copy.
- No module-level state (keep it inside `build`), no import-time effects, no imports of another
strategy. CI checks a `strategy/*` branch touches only `strategy/`, new `tactics/` modules,
`tests/strategy/` (`tools/dev/check_strategy_branch.py`).
- Every change needs a reason in game terms (what the robots will do differently, and why
that wins goals), not a threshold nudged until results move.

## 3. Test

1. Pure partitioner tests in `utama_core/tests/strategy/test_<name>.py` (a hand-built `Game`, no rsim).
2. `pixi run pytest utama_core/tests/engine/test_all_strategy_configs.py --headless`.
3. `git add` new files, then `pixi run test` and `pixi run lint`.

## 4. Evaluate (ask first)

Never start matches without the user's yes. Then:

```
pixi run evaluate NAME [NAME ...]
```

- Read the first line of each round: "N matches, X from the match results store, M to play".
After a change to one strategy, M is its own matches: one against each other player (5 with
today's core, 6 for a new strategy). Much more means shared code changed since the store was
filled (then the whole round robin plays); say so before waiting on it.
- Round 1 is a round robin: a stall reported there is a bug. Fix it (the `debug-incident`
skill) before reading the verdict.
- The verdict is goals only, in two stages of 6 rounds. The screen (seeds 1-6) only drops: a mean
paired diff ≤ 0 is "dropped" (not promising, not "worse"). A survivor plays on fresh seeds 101-106
in the same run: "better" if p ≤ 0.05 there, else "undecided". Every other signal explains the
verdict (the `explain-result` skill), never overrules it.
- On a "better", read the line "against today's <champion>": the reference carries the release's
shared code, so if shared code changed since, that line is the strategy change alone.

## 5. Record and promote

- Write the strategy's one-line description in its module docstring: the dashboard shows it.
- Open a draft pull request into `main` with the result. An agent never merges.
- Better than the champion: promoting is one line in `tools/evaluation/reference/players.json`
(`champion`, and the core if it should play every round), in its own small pull request after
the strategy's is merged: CI rejects a `strategy/*` branch that touches anything outside the
strategy files. It becomes the reference at the next release (evaluate.py reads the champion
from `players.json` as it was at that release).

## Searching (many candidates)

- Every candidate meets the same reference results on seeds 1-6, so a search can fit them; that is
why only seeds 101-106 accept. Those are shared too: the more candidates reach them, the likelier
one "better" is luck.
- Keep a list of every variant tried, with its verdict, stage and mean diff, in the PR, so a reviewer sees
how many tries one winner came from.
- Change one idea per candidate; several candidates go in one `evaluate.py` call.

## Judging a shared-code change

Not on a strategy branch. Batch the changes, then (ask first) `evaluate.py <champion>`: today's
champion on today's shared code against itself frozen at the last release. Its margin is what the
shared code did. Every stored match replays, so it is a full run.

## Rules

- **Shared code is not a strategy change.** A change to `tactics/` (existing modules), `skills/`,
`pickers.py`, the planner or the referee reruns most matches: put it on an ordinary branch,
batch such changes, and evaluate once at the end.
- **Strategy and evaluation in separate commits**, so results stay comparable.
- **`world.json` / `robots.json` changes** replay every stored match: batch them and ask first.
- Keep evaluation at the sim settings in `tools/evaluation/reference/`; don't tune a strategy
to real-robot limits in sim (those are compensated in the control layer).
73 changes: 73 additions & 0 deletions .agents/skills/debug-incident/SKILL.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,73 @@
---
name: debug-incident
description: Take one bad moment in a match (a foul, a stall, a robot thrashing, driving into the ball at a restart, a strange path near an obstacle) from symptom to a fixed cause with a regression test. Use when tools/debug/find_bugs.py or a replay shows a specific incident, or the user points at a time in a match. Not for "why did this strategy lose" in general (that is the explain-result skill).
---

# Debug one incident

A foul or failure is a symptom. The cause may be the robot's tactic, the shared referee
override, the motion planner, the referee itself, or the check that flagged it: of the first
six found this way, two were the referee or the check. The full workflow, with the bugs found
so far, is `docs/strategy.md`, "Debugging a foul or failure"; read it for anything
below that is unclear.

Inputs: a replay `REPLAY` (`replays/eval_<id>/round_<k>/<a>_vs_<b>.npz`, or any `.npz`) and a
time `S` in seconds. In a parallel worktree, run `tools/dev/setup_worktree.sh` first.

## 1. Find it

`pixi run python tools/debug/find_bugs.py ROUND_DIR --strategy NAME` → `find_bugs/index.md`, then
filter `find_bugs/findings.jsonl` on the kind you care about. Open the finding's picture,
then confirm with the numbers in its message. Only the friendly side (config_a) is checked.

## 2. Look at it

Pick the tool by the question. `tools/debug/match_timeline.py`, `tools/debug/restart_picture.py` and `tools/debug/plan_trace.py` take
`--findings` to write their flags as JSON.

| Question | Command |
|---|---|
| What happened in this window, in text? | `tools/debug/replay_trace.py REPLAY T0 T1` (`--events`: kicks, possession, referee changes, fouls) |
| Which tactic was each robot in, and what was it aiming at? | `tools/debug/repro_from_replay.py REPLAY --t S --summary IDS` (replays the state with tracing on, prints tactic, position, target every 0.25 s) |
| Swimlanes: referee, each robot's tactic, distance to ball | `tools/debug/match_timeline.py REPLAY T0 T1 --side friendly` |
| Where did the referee override send everyone at this restart? Legal? | `tools/debug/restart_picture.py REPLAY --t S` (`--all-restarts`, `--side enemy`) |
| What did the planner decide on this tick? | `tools/debug/plan_snapshot.py REPLAY --t S --robot ID --target X Y` (`--side enemy`) |
| How did the plan evolve over a few seconds? | `tools/debug/plan_trace.py REPLAY --t0 S --t1 S --robot ID [--target X Y]` |
| Run a fresh short match with my own traces | `tools/debug/debug_match.py --strategy A --opponent B --duration 60 --stop-on-goal`, with `ctx.match_log.trace(...)` calls added in the tactic |

All run as `pixi run python tools/<tool>.py ...`. Never conclude from a picture alone.

## 3. Find the cause in the code

From the trace: which tactic or override sent the robot there, with which target, waypoint
and obstacles. Then ask whether the rule was really broken (`docs/referee.md ("Design decisions")`)
and whether the check reads it right. Frame trap: rsim stores y negated; anything written into
the sim negates y and heading.

## 4. Fix it, with a unit test at the boundary

The fix is not done without a test that fails before and passes after, pinning the exact
boundary (a tolerance, a tie, a target off the field). Prefer a pure unit test over an rsim
fixture. Add a row to the bug table in `docs/strategy.md` if it is a new kind.

## 5. Optionally keep a moment

Only when a field state alone decides the behaviour (restart and placement geometry under the
referee override); open-play fouls almost never reproduce from a captured state.

```
pixi run python tools/debug/moments.py capture REPLAY --t S --name NAME --check CHECK --note "..."
pixi run python tools/debug/moments.py play utama_core/tests/moments/NAME.json --seeds 0-4
```

It must fail on at least 4 of 5 seeds before the fix. If the fix is not in the same change,
set `"known_failure": "<cause>"` (a strict xfail). Moments pin shared-code bugs; they are not a
gate on strategies.

## Rules

- A shared-code fix (skills, tactics, planner, referee) changes every strategy: batch such
fixes and evaluate once at the end, and ask before starting any `evaluate.py` run.
- Determinism: replaying the same fixture gives the same match. If a rerun differs, suspect
module-level state in a tactic or skill not keyed by team and cleared at match start.
- Don't chase rsim-only dribble failures as kernel bugs.
63 changes: 63 additions & 0 deletions .agents/skills/explain-result/SKILL.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,63 @@
---
name: explain-result
description: Explain how a strategy plays and why it won, lost or came out undecided, from the replays of an evaluate.py run (or an older round robin). Use after an evaluation, when asked "why did it lose?", "how does X play?", "where do its goals come from?", or before changing a strategy to see what to change. Never use it to rank strategies; goals in evaluate.py's verdict are the only ranking.
---

# Explain a result

Every tool here reads a **round folder**: `replays/eval_<id>/round_<k>/` (older round robins:
`replays/tournament_<id>/`). A round folder holds all of its matches as `<a>_vs_<b>.*`: those
the run played, and links to those it reused from the match results store. `config_a` (the
name before `_vs_`) is the friendly side, the only side with an intentions log.

Nothing here judges. A signal explains a result; fewer ball losses or more shots is not
"better" on its own (`docs/signals.md`, "Ranking"). Report what the numbers show and what
they suggest changing, never a new ranking.

## Steps, cheapest first

1. **Read the run's own report** (no tool to run).
`replays/eval_<id>/report.json`: per candidate the verdict, the stage that decided it
with its mean diff ± SE and p (`screen`, `confirm`), and
`per_opponent` (candidate's and reference's goal difference against each opponent, same seed
and colour). Which opponents moved the margin? `round_1/summary.json` has every signal and
the stall coverage. Look up any signal in `docs/signals.md`: where it lives, its reference
range, and what an off value usually means.

2. **Is something broken?** `pixi run python tools/debug/find_bugs.py ROUND_DIR --strategy NAME`
(about 20 s a match; `--restarts` adds restart geometry, a minute a match). Open
`find_bugs/index.md` first: the worst matches, findings by kind, a picture each. Our fouls by
rule: `--fouls --by strategy,rule`. A stall, thrash or foul is a bug, not a style: hand it to
the `debug-incident` skill.

3. **Where do goals come from?**
`pixi run python -m utama_core.analysis.goal_sources ROUND_DIR --out ROUND_DIR/goal_sources.json`.
Goals per match = Σ over situation types (restart or ball won, by third) of situations per
match × P(goal). Tells whether a change should create more situations, convert better, or
allow fewer. Situation names: AGENTS.md glossary and `docs/signals.md`, "Where do goals come
from?".

4. **How does it play, on the pitch?**
- One strategy against the field: `pixi run python tools/debug/pitch_maps.py ROUND_DIR --out DIR`
(positions with and without the ball, shots, fouls; every panel turned so the strategy
attacks right).
- A candidate against the champion, side by side on one scale:
`pixi run python tools/evaluation/explain.py ROUND_DIR CANDIDATE REFERENCE --out DIR`
(`positions.png`, `shots.png`, `fouls.png`, `summary.json`). REFERENCE is the name as
`report.json` gives it (a frozen file is named by its stem, e.g. `split_shape@cffe3a28`).
Zones: use the names in `docs/signals.md ("Pitch zones")` (defensive / middle / attacking third, wings, box).

5. **Write it up** in a few lines: the verdict and margin; which opponents decided it; the
two or three signals or pictures that explain it, with numbers; any bug found (handed to
`debug-incident`); what to try next. Look at every picture before citing it.

## Traps

- A round has 15 matches (more with `--all`); one strategy is config_a in only some of them, so
friendly-side analyses (intentions, stalls) cover those only. `summary.json`'s
`stalls_checked` says how many.
- Matches from before 2026-11-12, or whose original run folder was deleted, have no replay to
link: tools then see fewer matches than the round lists. Say so when numbers look thin.
- Catch rate moves ±4–8 points between identical runs: never a reason on its own.
- `ball_travel` is not a quality signal.
- Don't start new matches to explain a result; if more data is needed, ask first.
63 changes: 63 additions & 0 deletions .agents/skills/field-session/SKILL.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,63 @@
---
name: field-session
description: Run a test day on the real robots, and process what it recorded - checking vision and radio, pairing robots with lids, calibrating a robot, then trimming, measuring and packaging the field logs. Use when the user is at the field, sets up real robots, sees dropouts or a robot misbehaving on the pitch, or brings back field logs. Not for simulated matches.
---

# A field session

Setup and the meaning of each check: `tutorials/field_day.md`. Log format and readers:
`docs/real_robots.md ("Field logs")`. On the field, time is short: run the one command, read its "!!" lines,
fix only those.

## At the start

1. `pixi run field-check` (radios 0-7; `--radios 0 1` for fewer). It checks vision for 2 s
(cameras, packets per second, field size, ball, lids), then finds the robots: each radio
turns ~70° on the spot (keep 15 cm clear), the lid that turned is its, with the share of
commands answered and whether its profile was calibrated on that lid. Every line is "ok" or
"!!". It cannot see batteries or kicker charge.
2. On a "!!":
- **Vision quiet or dropping**: check the network link before any code. Multicast over a
2.4 GHz phone hotspot dropped frames on 2026-10-29. `pixi run python tools/field/vision_check.py
--seconds 5` listens alone; `--guided ball` checks cameras against 9 known spots.
- **Under 80% of commands answered**: range, interference or a flat battery.
- **Lid swapped**: `pixi run find-robots`, and calibrate again (the profile's tag offset
belongs to the lid).

## Measuring a robot

`pixi run calibrate --radio N` (65 s of driving, then the robot fetches a ball for the carry
ladder and kicks). It writes `config/robots/radio_<N>.json`; `--check` compares with the
committed profile, `--ball-only` redoes the ball part. Commit a new profile only when it
repeats. Known numbers: ~79 ms loop delay, sideways acceleration well below forward; carry
caps are 0.3 m/s and 0.6 rad/s on real robots (balls are lost turning faster).

## Things not to chase on the day

- Kick strength varies (battery, charge, many causes). The kicker is fixed power and holds its
charge ~30 s; `team_controller/controllers/real/kicker_charge.py` keeps it up in play.
- Kick bend comes from the ball's offset on the dribbler (fitted per radio).
- The sim does not model a robot's shortfalls: robot capability is assumed league-level in sim,
and real robots' gaps are compensated in the control layer, not in sim settings.

## After the session

1. **Keep the raw logs.** `replays/field/<YYYYMMDD_HHMMSS>_real_<name>.log.gz`. Never delete
an untrimmed log or archive; ask before deleting anything under `replays/`.
2. **Trim dead time** to new files: `pixi run python tools/field/trim_idle_log.py
replays/field/<run>.log.gz --dry-run`, then without `--dry-run` (`--in-place` only on copies).
3. **Register the session** in `tools/field/field_sessions.json`: its setup, and which measurements
(`loop_delay`, `ball_roll`, `ball_noise`, `robot_noise`) it may be used for. Only registered
sessions are read.
4. **Measure the world**: `pixi run python tools/field/field_physics.py [--json OUT]` prints each
measurement per (day, radio) with its spread and whether the days agree. Stop rule: a number
enters the sim (`tools/evaluation/reference/world.json`) only if it repeats across days, or
its spread is deliberately used as the range. Changing `world.json` changes every match's
environment: every stored result plays again, so batch it and ask first.
5. **One robot's numbers from a log**: `pixi run python tools/field/robot_calibration.py
replays/field/<run>.log [--json OUT]`.
6. **Share**: `pixi run python tools/field/package_logs.py field [DIR] [--dry-run]` compresses the
logs and bundles calibration and hardware config.
7. **Write down** what broke and what was measured (a dated note; open follow-ups listed).
Bugs seen on the pitch go through the `debug-incident` skill with the field log as the
replay.
1 change: 1 addition & 0 deletions .claude/skills
2 changes: 1 addition & 1 deletion .github/CODEOWNERS
Original file line number Diff line number Diff line change
@@ -1,3 +1,3 @@
# Changes here decide what a strategy branch may touch and how it is scored.
/.github/ @isaac0804
/tools/check_strategy_branch.py @isaac0804
/tools/dev/check_strategy_branch.py @isaac0804
4 changes: 2 additions & 2 deletions .github/workflows/ci.yml
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ concurrency:
cancel-in-progress: true

jobs:
# A strategy branch may change only strategy code, not its opponents (tools/check_strategy_branch.py).
# A strategy branch may change only strategy code, not its opponents (tools/dev/check_strategy_branch.py).
# Runs the base branch's copy of the checker, so the branch under test can't loosen it.
strategy-branch:
if: github.event_name == 'pull_request' && startsWith(github.head_ref, 'strategy/')
Expand All @@ -21,7 +21,7 @@ jobs:
fetch-depth: 0
- name: Only strategy code changed
run: |
git show "origin/${{ github.base_ref }}:tools/check_strategy_branch.py" > "$RUNNER_TEMP/check_strategy_branch.py"
git show "origin/${{ github.base_ref }}:tools/dev/check_strategy_branch.py" > "$RUNNER_TEMP/check_strategy_branch.py"
python3 "$RUNNER_TEMP/check_strategy_branch.py" --base "origin/${{ github.base_ref }}"

test:
Expand Down
6 changes: 4 additions & 2 deletions .gitignore
Original file line number Diff line number Diff line change
Expand Up @@ -208,8 +208,10 @@ benchmark_results/

# local agent-tool config dirs
.codex/
.agents/
.claude/
.agents/*
!.agents/skills/
.claude/*
!.claude/skills

.vscode

Expand Down
Loading
Loading