Run optional AI code review after each completed task, not only at the end

[Labutin]

Currently ralphex appears to run implementation task-by-task, and then performs the code review phase only after all tasks are completed.

It may be useful to support an optional mode where an AI code review is triggered after each completed task, before moving to the next one.

Why this could be useful

When a plan contains many tasks, problems introduced in early tasks can accumulate and become harder to fix later. By the time the final review runs, the implementation may already contain several layers of changes built on top of an earlier questionable decision.

A per-task review could help catch issues earlier, such as:

• incorrect interpretation of the task requirements
• architectural choices that will make later tasks harder
• missing edge cases
• inconsistent patterns compared to the existing codebase
• incomplete implementation that still passes basic tests
• changes that technically work but do not fit the intended design

This is different from a per-task verification gate such as running tests, lint, or typecheck. Automated verification is good at catching mechanical failures, but it does not always catch design problems, requirement mismatches, or subtle implementation issues. A per-task AI review would complement verification rather than replace it.

Suggested behavior

Add an optional mode, for example:

ralphex --review-after-each-task

or a config option such as:

review:
  after_each_task: true

Possible flow:

1. Execute one task.
2. Commit or stage the task changes as ralphex currently does.
3. Run the configured reviewer on the diff for that task.
4. If the reviewer finds required changes, send the feedback back to the implementation executor.
5. Repeat until the task review passes or reaches a retry limit.
6. Move to the next task.
7. Optionally still run the existing final review after all tasks are done.

Why make it optional

This mode would likely increase token usage and runtime, so it should not be the default behavior for every workflow. But for larger plans, more sensitive codebases, or users who prefer higher confidence over speed, it could significantly improve the quality of the final result.

Relationship to per-task verification

There is already a related idea around per-task verification gates. This proposal is similar in timing but different in purpose:

• verification gate: runs deterministic checks like tests, lint, or typecheck
• per-task AI review: reviews the code diff for correctness, maintainability, design, and task alignment

Both features could work well together. Verification can catch objective failures, while AI review can catch higher-level implementation problems before they propagate into later tasks.

[umputun]

I don't think this should be a built-in mode.

What you describe is useful for some plans, but not universal enough to justify another orchestrator phase. Running the current review stack after every task would be expensive: first review is 5 agents, second review is another loop, and external codex/custom review can run multiple rounds. On larger plans this can multiply runtime and token use by the number of tasks.

There is also a correctness problem: a single task is often intentionally incomplete until later tasks finish. Reviewing it as if it should already be final can create noise or push the agent toward local fixes that don't fit the whole plan.

For cases where this is useful, it can be done today with supported customization points:

• add the task-local review requirement directly to the plan task that needs it
• or customize .ralphex/prompts/task.txt / ~/.config/ralphex/prompts/task.txt and add a review step before completion

For example, copy the default task.txt and insert this after STEP 2 - VALIDATE:

STEP 2.5 - TASK REVIEW:
- Run a short review for the current Task section before marking it done.
- Review only the changes made for this task. Use `git status --short` and `git diff` to inspect the current uncommitted changes.
- Launch both review agents in parallel in one message. Do not continue until both return results.

{{agent:quality}}
{{agent:implementation}}

- Ask both agents to focus only on correctness, critical/major bugs, security issues, races, requirement mismatches, and plan alignment for this task.
- Ignore style-only and minor findings.
- Verify each finding against the actual code.
- Fix only valid issues that apply to this task and do not depend on later tasks.
- Run validation again after fixes.

task.txt supports {{agent:name}} expansion, same as review prompts, so this uses the existing built-in agents and supported prompt customization.

This keeps the choice at the plan/prompt level, where it belongs, without making the default pipeline heavier or more complicated.

[umputun]

Moved to discussion as this is not an actual issue.

[pySilver]

@Labutin I usually do plan refinement with codex during planning (see: https://github.com/pySilver/cc-tools#planning ) Also following this approach nicely integrates with ralphex: https://addyosmani.com/blog/agent-skills/

What I basically do is (for larger features):

1. create an ADR & do adr-review run
2. create a plan based on ADR, run planning review agent, then refine with codex. I that takes more than 3-4 rounds it is useful to run root-cause-investigation skill https://github.com/umputun/cc-thingz to find out why and get immediate recommendations
3. plan is ready, lets work on it
4. run code hygiene skill (my own quality checks)
5. run code simplifier
6. last code review

The agent-skills has some really nice push-back instructions that makes planning sessions better.

Point is: better plan > less troubles during execution & review