Add bounded cache and sccache diagnostics to setup-rust

[leynos]

Scope

Add actionable, bounded workflow diagnostics for setup-rust cache and sccache outcomes.

The diagnostics should include:

• runner OS;
• cache category;
• hit or miss state where available; and
• a non-sensitive failure category.

Add tests and developer documentation. Do not emit cache keys, paths, tokens, or unbounded command output.

Rationale

PR #396 updates third-party action pins and preserves the existing cache configuration. Cache and sccache observability is an independent operational enhancement.

Review context: PR #396 review comment.

Acceptance criteria

• Diagnostics expose only bounded runner OS, cache category, hit or miss state where available, and non-sensitive failure-category fields.
• Diagnostics do not expose cache keys, filesystem paths, tokens, secrets, or unbounded command output.
• Automated tests cover the bounded field set, successful outcomes, unavailable hit or miss state, and representative non-sensitive failure categories.
• Developer documentation describes the emitted fields, their bounds, and the privacy constraints.

[coderabbitai]

🔗 Related PRs

leynos/ddlint#287 - Wire the CodeScene coverage gate into CI [merged]
leynos/monotony#25 - Wire CodeScene coverage upload into CI [merged]
#375 - Reference setup-rust remotely so its post hook survives relocation (#365) [open]
leynos/netsuke#473 - Adopt cargo-nextest as the default test runner (#463) [merged]
#396 - Update setup-rust dependencies for Node.js 24 (#81) [open]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[leynos]

@CodeRabbit plan

[coderabbitai]

Coding Plan

Summary

Add id: values to the cargo cache step and both sccache steps, then add an always() diagnostics step that passes only bounded signals through an env: block.

Implement a Cyclopts script that models each field as a closed StrEnum, reads sccache statistics safely and boundedly, and emits only runner OS, cache category, hit or miss state, and failure category to the step summary and a single annotation.

Prove the bounded contract and the privacy constraints with manifest tests and cmd_mox-stubbed script tests, then document the fields, bounds, and privacy constraints for maintainers.

Design Choices

Design Choice 1: Surface for exposing the bounded diagnostics fields

Options Considered:

1. Write the fields to GITHUB_STEP_SUMMARY and emit a ::notice:: / ::warning:: annotation for the human-readable summary.
2. Add an outputs: section to action.yml and expose each field as a step output for downstream consumption.
3. Do both: step outputs plus a step-summary and annotation surface.

Chosen Option: 1

Rationale: The diagnostics are operational troubleshooting aids for humans reading the run, so a bounded step summary plus a single annotation matches the intent without expanding the action's public contract.

Design Choice 2: Method for deriving the sccache hit or miss state

Options Considered:

1. Run sccache --show-stats through plumbum, extract only the aggregate cache-hits and cache-misses counters, and bound them.
2. Report the sccache hit or miss state as unavailable and only report the step outcome.

Chosen Option: 1

Rationale: Aggregate counters from --show-stats are non-sensitive integers, they satisfy the requirement for a hit or miss state where available, and the script falls back to unavailable when the counters cannot be read.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Expose step signals in the action manifest

This phase makes the cache and sccache outcomes referenceable and adds the invocation point for the diagnostics. Group these changes together because they all edit action.yml and define the data contract the diagnostics script consumes.

Task 1: Add step identifiers to the cache and sccache steps

Give the cache and sccache steps stable identifiers so later steps can read their results.

• Add an id: to the Cache cargo registry step in .github/actions/setup-rust/action.yml so steps.<id>.outputs.cache-hit and steps.<id>.outcome become available.
• Add an id: to each of the Run sccache (x86_64 macOS) and Run sccache steps so steps.<id>.outcome becomes available.
• Follow the existing openbsd-stdlib-cache identifier convention already used in this file.
• Do not change any cache keys, paths, or if: conditions.

Task 2: Add the diagnostics invocation step

Add a step that collects the signals and runs the diagnostics script.

• Add a new step named Report cache diagnostics immediately after the Run sccache step and before Install system dependencies.
• Run the step with if: ${{ always() }} so the diagnostics report even when a prior step fails.
• Invoke the script with uv run --script "${{ github.action_path }}/scripts/report_cache_diagnostics.py", following the copy_openbsd_stdlib.py invocation pattern already in the file.
• Pass the bounded signals through an env: block only: INPUT_RUNNER_OS: ${{ runner.os }}, INPUT_USE_SCCACHE: ${{ inputs.use-sccache }}, INPUT_CARGO_CACHE_HIT: ${{ steps.<cargo-id>.outputs.cache-hit }}, INPUT_CARGO_CACHE_OUTCOME: ${{ steps.<cargo-id>.outcome }}, and the two sccache step outcomes.
• Do not pass cache keys, paths, tokens, or the SCCACHE_PATH value into any field that the script prints.

🤖 Prompt for AI agents

Implement Phase 1: edit `.github/actions/setup-rust/action.yml` to expose step
signals and add the diagnostics invocation point.

- Add an `id:` to the `Cache cargo registry` step, so
`steps.<id>.outputs.cache-hit` and `steps.<id>.outcome` become readable. Add an
`id:` to each of the `Run sccache (x86_64 macOS)` and `Run sccache` steps, so
`steps.<id>.outcome` becomes readable. Follow the existing
`openbsd-stdlib-cache` identifier naming convention. Do not change any cache
keys, paths, or `if:` conditions.
- Add a new step named `Report cache diagnostics` immediately after the `Run
sccache` step and before the `Install system dependencies` step. Set `if: ${{
always() }}` on this step, so the diagnostics run even when a prior step fails.
- Invoke the script with `uv run --script "${{ github.action_path
}}/scripts/report_cache_diagnostics.py"`, following the `copy_openbsd_stdlib.py`
invocation pattern already present in the file.
- Pass signals only through an `env:` block: `INPUT_RUNNER_OS: ${{ runner.os
}}`, `INPUT_USE_SCCACHE: ${{ inputs.use-sccache }}`, `INPUT_CARGO_CACHE_HIT: ${{
steps.<cargo-id>.outputs.cache-hit }}`, `INPUT_CARGO_CACHE_OUTCOME: ${{
steps.<cargo-id>.outcome }}`, and the two sccache step outcomes.
- Do not pass cache keys, paths, tokens, or the `SCCACHE_PATH` value into any
field the script prints.

Phase 2: Implement the bounded diagnostics script

This phase builds the script that classifies the signals into bounded categories, reads sccache statistics safely, and emits only the permitted fields.

Task 1: Define the bounded category model

Model each reported field as a closed enumeration.

• Create .github/actions/setup-rust/scripts/report_cache_diagnostics.py with a PEP 723 header declaring cyclopts and plumbum dependencies.
• Define enum.StrEnum types for the bounded fields: RunnerOs (linux, windows, macos, unknown), CacheCategory (cargo-registry, sccache), HitState (hit, miss, unavailable), and FailureCategory (none, restore-failed, save-failed, sccache-unavailable, sccache-stats-failed, unknown).
• Add _parse_* guard functions that normalise input with .strip().lower(), construct the enum, catch ValueError, list the valid values dynamically, and exit non-zero with an actionable stderr message.
• Follow the StrEnum plus _parse_* pattern in generate-coverage/scripts/detect.py.

Task 2: Collect sccache statistics safely

Read only non-sensitive aggregate counters from sccache.

• Resolve the sccache binary through the SCCACHE_PATH environment variable, or fall back to sccache on the path.
• Run --show-stats through plumbum, with a fixed timeout and retcode=None, following the plumbum convention in docs/scripting-standards.md.
• Extract only the numeric cache-hits and cache-misses counters. Convert them into a bounded HitState (hit when hits are present, miss when only misses are present, unavailable otherwise).
• Suppress all collection errors defensively and map them to FailureCategory.sccache_stats_failed or FailureCategory.sccache_unavailable, following the _collect_diagnostics_safely precedent in validate_sandbox_diagnostics.py.
• Never print the raw --show-stats output. Never print SCCACHE_PATH.

Task 3: Classify outcomes and emit the bounded report

Convert the input signals into the four bounded fields and write the report.

• Read the input signals through Cyclopts INPUT_* parameters (runner_os, use_sccache, cargo_cache_hit, cargo_cache_outcome, and the sccache outcomes).
• Map cargo_cache_hit to HitState (hit when "true", miss when empty, unavailable when the value is absent) and map a failed cargo cache outcome to the correct FailureCategory.
• Build one report row per CacheCategory, each row containing exactly the runner OS, the cache category, the hit or miss state, and the failure category.
• Write the rows to GITHUB_STEP_SUMMARY as a compact Markdown table, and emit a single ::notice:: (or ::warning:: when any failure category is not none) annotation with the same bounded fields.
• Add a module-level escaping helper that applies the %→%25, \r→%0D, \n→%0A replacements before writing annotations, following read_manifest.py.
• Skip writing silently when GITHUB_STEP_SUMMARY is unset, so local and test runs do not fail.
• Use UNIX exit-code conventions: exit 0 on success, non-zero only for an unparseable bounded input.

🤖 Prompt for AI agents

Implement Phase 2: build
`.github/actions/setup-rust/scripts/report_cache_diagnostics.py`, the bounded
diagnostics script, following `docs/scripting-standards.md` (Cyclopts CLI,
`cyclopts.config.Env("INPUT_", command=False)`, `plumbum` for external commands,
PEP 723 header, `uv run --script` invocation).

Define the bounded category model:
- Declare `cyclopts` and `plumbum` as dependencies in the PEP 723 header.
- Define `enum.StrEnum` types: `RunnerOs` (`linux`, `windows`, `macos`,
`unknown`), `CacheCategory` (`cargo-registry`, `sccache`), `HitState` (`hit`,
`miss`, `unavailable`), `FailureCategory` (`none`, `restore-failed`,
`save-failed`, `sccache-unavailable`, `sccache-stats-failed`, `unknown`).
- Add `_parse_*` guard functions that normalise input with `.strip().lower()`,
construct the matching enum, catch `ValueError`, list the valid values
dynamically, and exit non-zero with an actionable stderr message. Follow the
`StrEnum` plus `_parse_*` pattern in `generate-coverage/scripts/detect.py`.

Collect sccache statistics safely:
- Resolve the sccache binary through the `SCCACHE_PATH` environment variable,
falling back to `sccache` on the path.
- Run `--show-stats` through `plumbum` with a fixed timeout and `retcode=None`.
- Extract only the numeric cache-hits and cache-misses counters, and convert
them into a bounded `HitState` (`hit` when hits are present, `miss` when only
misses are present, `unavailable` otherwise).
- Suppress all collection errors defensively, mapping them to
`FailureCategory.sccache_stats_failed` or `FailureCategory.sccache_unavailable`,
following the `_collect_diagnostics_safely` precedent in
`validate_sandbox_diagnostics.py`.
- Never print the raw `--show-stats` output or the `SCCACHE_PATH` value.

Classify outcomes and emit the bounded report:
- Read the input signals through Cyclopts `INPUT_*` parameters (`runner_os`,
`use_sccache`, `cargo_cache_hit`, `cargo_cache_outcome`, and the sccache
outcomes).
- Map `cargo_cache_hit` to `HitState` (`hit` when `"true"`, `miss` when empty,
`unavailable` when absent), and map a failed cargo cache outcome to the correct
`FailureCategory`.
- Build one report row per `CacheCategory`, each row containing exactly the
runner OS, the cache category, the hit or miss state, and the failure category.
- Write the rows to `GITHUB_STEP_SUMMARY` as a compact Markdown table, and emit
a single `::notice::` annotation (or `::warning::` when any failure category is
not `none`) with the same bounded fields.
- Add a module-level escaping helper applying the `%`→`%25`, `\r`→`%0D`,
`\n`→`%0A` replacements before writing annotations, following
`read_manifest.py`.
- Skip writing silently when `GITHUB_STEP_SUMMARY` is unset, so local and test
runs do not fail.
- Use UNIX exit-code conventions: exit `0` on success, non-zero only for an
unparseable bounded input.

Phase 3: Tests and documentation

This phase proves the bounded contract and privacy constraints, and it records the field semantics for maintainers.

Task 1: Add manifest tests

Prove the manifest wiring is correct and passes only bounded values.

• Extend .github/actions/setup-rust/tests/test_setup_rust_manifest.py using get_step and load_steps.
• Assert the cargo cache and both sccache steps carry id: values.
• Assert the Report cache diagnostics step exists, runs with if: always(), and follows the sccache steps.
• Assert the step's env: block passes only the bounded signals and passes no cache key, path, or token.

Task 2: Add script unit tests

Cover the bounded field set, success, unavailable hit or miss state, and failure categories.

• Add .github/actions/setup-rust/tests/test_report_cache_diagnostics.py.
• Stub the sccache binary through the existing shell_stubs fixture, following the cargo stub pattern in generate-coverage/tests/test_scripts.py.
• Cover: a successful outcome with a cargo cache hit and sccache hits; an unavailable hit or miss state when the cargo cache-hit input is absent and --show-stats fails; and representative non-sensitive failure categories (restore-failed, sccache-unavailable, sccache-stats-failed).
• Assert the emitted step summary and annotation contain only the four bounded fields.
• Add an explicit privacy assertion: the emitted text contains no cache key, no filesystem path, no SCCACHE_PATH value, and no raw --show-stats output.
• Assert an unparseable bounded input exits non-zero with an actionable message.

Task 3: Update documentation and changelog

Record the emitted fields, their bounds, and the privacy constraints.

• Add a ## Cache and sccache diagnostics subsection to .github/actions/setup-rust/README.md describing the diagnostics surface (step summary and annotation) and the four bounded fields.
• Add an ### Observability section to docs/developers-guide.md under a ## setup-rust heading. Enumerate each bounded field, its closed value set, the bounding of the sccache counters, and the explicit list of values that the diagnostics never emit (cache keys, paths, tokens, secrets, raw command output), following the RUSTFLAGS non-leakage precedent.
• Add a new top entry to .github/actions/setup-rust/CHANGELOG.md in ## vX.Y.Z - YYYY-MM-DD form describing the diagnostics feature.
• Do not repeat the stale Swatinem/rust-cache and workspaces claims found in the current README and CHANGELOG; describe the actual actions/cache and sccache-action ground truth.

🤖 Prompt for AI agents

Implement Phase 3: add tests proving the bounded contract and privacy
constraints, and update documentation for maintainers.

Manifest tests:
- Extend `.github/actions/setup-rust/tests/test_setup_rust_manifest.py`, using
`get_step` and `load_steps`.
- Assert the cargo cache step and both sccache steps carry `id:` values.
- Assert the `Report cache diagnostics` step exists, runs with `if: always()`,
and follows the sccache steps.
- Assert the step's `env:` block passes only the bounded signals, and passes no
cache key, path, or token.

Script unit tests:
- Add `.github/actions/setup-rust/tests/test_report_cache_diagnostics.py`.
- Stub the `sccache` binary through the existing `shell_stubs` fixture,
following the `cargo` stub pattern in `generate-coverage/tests/test_scripts.py`.
- Cover a successful outcome with a cargo cache hit and sccache hits; an
unavailable hit or miss state when the cargo `cache-hit` input is absent and
`--show-stats` fails; and representative non-sensitive failure categories
(`restore-failed`, `sccache-unavailable`, `sccache-stats-failed`).
- Assert the emitted step summary and annotation contain only the four bounded
fields.
- Add an explicit privacy assertion confirming the emitted text contains no
cache key, no filesystem path, no `SCCACHE_PATH` value, and no raw
`--show-stats` output.
- Assert an unparseable bounded input exits non-zero with an actionable message.

Documentation and changelog:
- Add a `## Cache and sccache diagnostics` subsection to
`.github/actions/setup-rust/README.md`, describing the diagnostics surface (step
summary and annotation) and the four bounded fields.
- Add an `### Observability` section to `docs/developers-guide.md` under a `##
setup-rust` heading. Enumerate each bounded field, its closed value set, the
bounding of the sccache counters, and the explicit list of values the
diagnostics never emit (cache keys, paths, tokens, secrets, raw command output),
following the RUSTFLAGS non-leakage precedent.
- Add a new top entry to `.github/actions/setup-rust/CHANGELOG.md` in `## vX.Y.Z
- YYYY-MM-DD` form, describing the diagnostics feature.
- Remove the stale `Swatinem/rust-cache` and `workspaces` claims from the
current README and CHANGELOG; describe the actual `actions/cache` and
`sccache-action` configuration instead.

Research

setup-rust is a composite action defined in .github/actions/setup-rust/action.yml. It caches the cargo registry with actions/cache in the step named Cache cargo registry, and it enables sccache with two mutually exclusive mozilla-actions/sccache-action steps (Run sccache (x86_64 macOS) and Run sccache). Only the Cache OpenBSD stdlib step currently carries an id:; the cargo cache and sccache steps carry no id:, and the action declares no outputs: section.

New scripts follow docs/scripting-standards.md: Cyclopts CLI with cyclopts.config.Env("INPUT_", command=False), plumbum for external commands, uv run --script invocation, and PEP 723 headers. Bounded diagnostics precedent lives in .github/actions/validate-linux-packages/scripts/validate_sandbox_diagnostics.py (_trim_output, defensive exception suppression, a fixed set of diagnostic categories). Bounded category enums follow the enum.StrEnum plus _parse_* guard pattern in .github/actions/generate-coverage/scripts/detect.py. GitHub Actions annotation and output escaping (%→%25, \r→%0D, \n→%0A) is shown in stage_common/output.py and read_manifest.py. Tests are pytest-based: they parse action.yml with helpers in tests/setup_rust_test_helpers.py, and they stub external binaries through the shell_stubs fixture (StubManager over cmd_mox) in tests/conftest.py.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement Phase 1: edit `.github/actions/setup-rust/action.yml` to expose step
signals and add the diagnostics invocation point.

- Add an `id:` to the `Cache cargo registry` step, so
`steps.<id>.outputs.cache-hit` and `steps.<id>.outcome` become readable. Add an
`id:` to each of the `Run sccache (x86_64 macOS)` and `Run sccache` steps, so
`steps.<id>.outcome` becomes readable. Follow the existing
`openbsd-stdlib-cache` identifier naming convention. Do not change any cache
keys, paths, or `if:` conditions.
- Add a new step named `Report cache diagnostics` immediately after the `Run
sccache` step and before the `Install system dependencies` step. Set `if: ${{
always() }}` on this step, so the diagnostics run even when a prior step fails.
- Invoke the script with `uv run --script "${{ github.action_path
}}/scripts/report_cache_diagnostics.py"`, following the `copy_openbsd_stdlib.py`
invocation pattern already present in the file.
- Pass signals only through an `env:` block: `INPUT_RUNNER_OS: ${{ runner.os
}}`, `INPUT_USE_SCCACHE: ${{ inputs.use-sccache }}`, `INPUT_CARGO_CACHE_HIT: ${{
steps.<cargo-id>.outputs.cache-hit }}`, `INPUT_CARGO_CACHE_OUTCOME: ${{
steps.<cargo-id>.outcome }}`, and the two sccache step outcomes.
- Do not pass cache keys, paths, tokens, or the `SCCACHE_PATH` value into any
field the script prints.
===============================================================================

Task: 2

Implement Phase 2: build
`.github/actions/setup-rust/scripts/report_cache_diagnostics.py`, the bounded
diagnostics script, following `docs/scripting-standards.md` (Cyclopts CLI,
`cyclopts.config.Env("INPUT_", command=False)`, `plumbum` for external commands,
PEP 723 header, `uv run --script` invocation).

Define the bounded category model:
- Declare `cyclopts` and `plumbum` as dependencies in the PEP 723 header.
- Define `enum.StrEnum` types: `RunnerOs` (`linux`, `windows`, `macos`,
`unknown`), `CacheCategory` (`cargo-registry`, `sccache`), `HitState` (`hit`,
`miss`, `unavailable`), `FailureCategory` (`none`, `restore-failed`,
`save-failed`, `sccache-unavailable`, `sccache-stats-failed`, `unknown`).
- Add `_parse_*` guard functions that normalise input with `.strip().lower()`,
construct the matching enum, catch `ValueError`, list the valid values
dynamically, and exit non-zero with an actionable stderr message. Follow the
`StrEnum` plus `_parse_*` pattern in `generate-coverage/scripts/detect.py`.

Collect sccache statistics safely:
- Resolve the sccache binary through the `SCCACHE_PATH` environment variable,
falling back to `sccache` on the path.
- Run `--show-stats` through `plumbum` with a fixed timeout and `retcode=None`.
- Extract only the numeric cache-hits and cache-misses counters, and convert
them into a bounded `HitState` (`hit` when hits are present, `miss` when only
misses are present, `unavailable` otherwise).
- Suppress all collection errors defensively, mapping them to
`FailureCategory.sccache_stats_failed` or `FailureCategory.sccache_unavailable`,
following the `_collect_diagnostics_safely` precedent in
`validate_sandbox_diagnostics.py`.
- Never print the raw `--show-stats` output or the `SCCACHE_PATH` value.

Classify outcomes and emit the bounded report:
- Read the input signals through Cyclopts `INPUT_*` parameters (`runner_os`,
`use_sccache`, `cargo_cache_hit`, `cargo_cache_outcome`, and the sccache
outcomes).
- Map `cargo_cache_hit` to `HitState` (`hit` when `"true"`, `miss` when empty,
`unavailable` when absent), and map a failed cargo cache outcome to the correct
`FailureCategory`.
- Build one report row per `CacheCategory`, each row containing exactly the
runner OS, the cache category, the hit or miss state, and the failure category.
- Write the rows to `GITHUB_STEP_SUMMARY` as a compact Markdown table, and emit
a single `::notice::` annotation (or `::warning::` when any failure category is
not `none`) with the same bounded fields.
- Add a module-level escaping helper applying the `%`→`%25`, `\r`→`%0D`,
`\n`→`%0A` replacements before writing annotations, following
`read_manifest.py`.
- Skip writing silently when `GITHUB_STEP_SUMMARY` is unset, so local and test
runs do not fail.
- Use UNIX exit-code conventions: exit `0` on success, non-zero only for an
unparseable bounded input.
===============================================================================

Task: 3

Implement Phase 3: add tests proving the bounded contract and privacy
constraints, and update documentation for maintainers.

Manifest tests:
- Extend `.github/actions/setup-rust/tests/test_setup_rust_manifest.py`, using
`get_step` and `load_steps`.
- Assert the cargo cache step and both sccache steps carry `id:` values.
- Assert the `Report cache diagnostics` step exists, runs with `if: always()`,
and follows the sccache steps.
- Assert the step's `env:` block passes only the bounded signals, and passes no
cache key, path, or token.

Script unit tests:
- Add `.github/actions/setup-rust/tests/test_report_cache_diagnostics.py`.
- Stub the `sccache` binary through the existing `shell_stubs` fixture,
following the `cargo` stub pattern in `generate-coverage/tests/test_scripts.py`.
- Cover a successful outcome with a cargo cache hit and sccache hits; an
unavailable hit or miss state when the cargo `cache-hit` input is absent and
`--show-stats` fails; and representative non-sensitive failure categories
(`restore-failed`, `sccache-unavailable`, `sccache-stats-failed`).
- Assert the emitted step summary and annotation contain only the four bounded
fields.
- Add an explicit privacy assertion confirming the emitted text contains no
cache key, no filesystem path, no `SCCACHE_PATH` value, and no raw
`--show-stats` output.
- Assert an unparseable bounded input exits non-zero with an actionable message.

Documentation and changelog:
- Add a `## Cache and sccache diagnostics` subsection to
`.github/actions/setup-rust/README.md`, describing the diagnostics surface (step
summary and annotation) and the four bounded fields.
- Add an `### Observability` section to `docs/developers-guide.md` under a `##
setup-rust` heading. Enumerate each bounded field, its closed value set, the
bounding of the sccache counters, and the explicit list of values the
diagnostics never emit (cache keys, paths, tokens, secrets, raw command output),
following the RUSTFLAGS non-leakage precedent.
- Add a new top entry to `.github/actions/setup-rust/CHANGELOG.md` in `## vX.Y.Z
- YYYY-MM-DD` form, describing the diagnostics feature.
- Remove the stale `Swatinem/rust-cache` and `workspaces` claims from the
current README and CHANGELOG; describe the actual `actions/cache` and
`sccache-action` configuration instead.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!