{
  "1": "Read the entire codebase and understand its architecture and coding standards",
  "2": "List all of the improvements you can think of for this project",
  "3": "Are these improvements actually adding value to the application and worth implementing?",
  "4": "Implement all of the changes worth implementing",
  "5": "Take a look at the git status and git diff to validate that the changes you intended to make are the same as the changes you actually did, and that nothing unintended was touched",
  "6": "Take a closer look at all of the changes another agent made in this codebase. You can see the changes via 'git diff --staged'",
  "7": "If your review found any issues with the staged changes, fix them now",
  "8": "Summarize all of the changes made since the last commit, grouping them by area and noting anything a reviewer should know",
  "9": "Look through the codebase for code that can be removed or collapsed without changing any behavior. Duplicated logic: the same pattern repeated three or more times, or two substantial structurally identical blocks, that should be extracted into shared helpers. Dead code: unused exports, unreachable branches, redundant guards, and leftover scaffolding. Unnecessary complexity: over-engineered abstractions, redundant layers, and verbose constructs that have a shorter equivalent. For each finding, note the file, the exact code, and what it shrinks to. The goal is less code with identical functionality and no more complexity than before",
  "10": "Are these code reductions actually worth implementing? Check that each one preserves every observable behavior and the public API, removes real code instead of moving it around, and leaves the code at least as simple and readable as before. Skip a reduction when it trades clarity, tests, or debuggability for a smaller diff, and skip anything that needs a new dependency, abstraction, or configuration just to remove code",
  "11": "Implement all of the code reductions worth implementing. Keep the functionality and the public interfaces exactly as they are, delete code instead of relocating it, and do not add dependencies, abstractions, configuration, or features. Do not fix unrelated bugs. Run the project's existing tests if there are any and confirm they still pass. The result must be strictly less code and no more complex than before",
  "12": "Take a closer look at all of the changes another agent made in this codebase. You can see the changes via 'git diff --staged'. Verify that every removal preserves the previous behavior, that nothing reachable was deleted, that public interfaces, output, error messages, and exit behavior did not change, and that the result is genuinely simpler rather than merely shorter. Run the project's existing tests if there are any and check that they still pass",
  "13": "If your review found any issues with the staged changes, fix them now by restoring the correct behavior or simplifying the change further, never by re-adding code with more complexity",
  "14": "Take a look at the git status and git diff to validate that you removed exactly the code you intended to remove, that the functionality is unchanged, and that nothing unrelated was touched",
  "15": "Summarize this workflow run: inspect the commits and diffs produced by its rounds, then report what was reviewed, what changed, what was skipped as not worth doing, and what still needs attention",
  "16": "Search the web for similar projects with similar features and identify improvements that could be applied to this codebase",
  "17": "Reply with only a commit message for all changes made since the last commit: an imperative subject line, a blank line, and a body that groups the changes by area and notes anything a reviewer should know. Never reply with only a subject line. Your entire next response is used verbatim as the literal commit message",
  "18": "Look through the codebase for test coverage gaps: untested modules and functions, missing edge cases, tests that only assert happy paths, and critical paths without tests. Focus on behavior that would break silently without a test, especially around data transformations, error handling, and boundary conditions. For each gap, note the file and the specific behavior that is missing a test",
  "19": "Are these test coverage gaps actually worth closing? Consider the risk if the behavior broke, the cost of writing and maintaining the test, and whether the behavior is already covered indirectly. Only gaps where a test would catch a real regression are worth closing",
  "20": "Implement tests for all of the coverage gaps worth closing. Follow the existing test conventions of this project, keep each test focused on one behavior, and make sure each test would fail if the implementation were broken and pass on good inputs. Do not modify production code",
  "21": "Take a closer look at the tests another agent wrote in this codebase. You can see the changes via 'git diff --staged'. Check that each test isolates one behavior, asserts the right outcome, would fail on bad inputs, and does not rely on overly broad mocks or flaky patterns. Look for missing assertions and tests that do not actually verify the behavior they claim to",
  "22": "If your review found any issues with the staged changes that another agent made to write a test, fix them now",
  "23": "Take a look at the git status and git diff to validate that the tests you wanted to write are the same as the tests you actually did",
  "24": "Look through the codebase for bugs: incorrect logic, off-by-one errors, missing error handling, null and undefined handling, race conditions, resource leaks, unhandled edge cases, and type mismatches. For each finding, note the file, the specific location, and why it would actually fail in production",
  "25": "Are these bugs actually real and worth fixing? Check whether each bug is reproducible, whether it impacts real usage, whether it is a false positive or theoretical edge case that cannot happen, and whether the fix risk outweighs the bug. Only bugs that are real, reachable, and worth the change are worth fixing",
  "26": "Fix all of the bugs worth fixing. Keep each fix minimal and focused on the bug itself, do not refactor unrelated code, and preserve existing behavior for correct inputs",
  "27": "Take a closer look at the bug fixes another agent made in this codebase. You can see the changes via 'git diff --staged'. Check that each fix actually addresses a bug, does not introduce new bugs, handles edge cases correctly, and does not change behavior for correct inputs. Look for incomplete fixes and regressions",
  "28": "If your review found any issues with the staged changes that another agent made to fix a bug, fix them now"
}