Review

Review is where you decide. Nothing the model wrote reaches your files until you have looked at it here, hunk by hunk, with the model's reason for each beside it.

Review opens when the model says it is done and the gates have passed, or when you interrupt a turn that changed something. The status bar says review, and a notification goes out if you are not looking.

The brief

Whatever tool you review in, the review begins with the brief, heph's own summary of the change:

┌ review ─────────────────────────────────────────────────────────────────────┐
│Review: 01a0c63 on main, round 1 -- 2 files, 3 hunks                          │
│                                                                              │
│src/auth.rs                                                                   │
│hunk 1 (23-31)   edit #4                                                      │
│Read the JWT secret from the environment so the key never lands in the        │
│binary.                                                                       │
│hunk 2 (58-70)   edit #5, shell #6 (cargo fmt)                                │
│Return anyhow::Result from validate_token so callers surface the error        │
│instead of panicking.                                                         │
│                                                                              │
│src/main.rs                                                                   │
│hunk 1 (10-25)   edit #7                                                      │
│Thread the Result through main and exit non-zero on a bad token.              │
│                                                                              │
│Enter: review each hunk    q: reject all    Esc: later                        │
└──────────────────────────────────────────────────────────────────────────────┘

Each hunk shows its line range in the new file, the tool calls that produced it, and the rationale: the sentence the model wrote before making the change. A hunk touched by several calls lists all of them, and joins their reasons. A hunk from a shell command shows the command. Heph finds the calls behind a hunk with git blame over the private chain of per-call commits, so the attribution is exact, not guessed.

The header names the turn, the conversation, and the round: a review that follows a rejection is round 2 of the same turn, and shows only what changed since round 1.

Three things can follow the brief:

• Enter starts reviewing. Where that happens depends on [review] interactive: heph's own screen (The Built-in Review), or lazygit or another tool (Reviewing in lazygit and Other Tools).

• q rejects everything and ends the turn. The model is told every hunk was refused, so it does not build on code that is gone, but it gets no round to guess why: a wholesale "no" without words is not an instruction. Say what you wanted in your next prompt.

• Esc puts it off. The change stays in the worktree, nothing reaches your tree, and the review is offered again before your next prompt starts a turn, or when you type /review, or when the conversation next opens (Picking Up Where You Left Off).

The rules that hold everywhere

Only the change is reviewed. The diff is from the snapshot heph took when the turn began to what the model made, so your own uncommitted work is not in it and is never at risk.

Each hunk is accepted or rejected whole. To take part of a hunk, reject it with a comment saying which part, or edit it to exactly what you want (The Built-in Review); in an external tool, stage and unstage lines as the tool allows.

Rejected hunks come back as words, not as retries. A rejection, with or without a comment, tells the model in your words what was refused and why, and bars it from proposing the same change again in this turn. The details are in Rejections, Comments, and the Next Round.

Gates run again on what you kept. If you rejected some hunks and accepted others, the accepted state is gated before it lands: what passed the tests with all of the model's changes may not pass with half of them. A failure goes back to the model, and nothing is written to your tree.

Applying is a merge, not a copy. Accepted hunks are three-way merged onto your current files against the turn's starting snapshot. A file you have since edited by hand elsewhere merges. A hunk that overlaps something you changed by hand is set aside, your text stands, and the model is told to redo it against the current text.

Nothing undecided is ever taken as decided. A review you put off, or stop partway through, leaves the hunks you did not decide in the worktree, on top of what you accepted. They are not accepted, not rejected, and not forgotten: the next review shows exactly them, with their reasons. A new prompt does not absorb them either; its turn carries them along and reviews them with its own work.

After review

When the turn ends with accepted changes and no hunks left waiting, heph offers to commit. It prepares the publication candidate and passes its final gates before showing a dedicated dialog. y publishes the shown message immediately; e chooses Yes, but edit the message, using the manual /commit editor handoff. n or Esc leaves the accepted state private. The publication lock is held while you answer, so an unchanged candidate needs no gate rerun on Yes. A partial or empty review does not offer a commit.

Reviewing on demand: /review

/review opens a review now, with no prompt and no model round. It shows whatever the conversation's worktree holds beyond its accepted state: the review a turn left waiting, with each hunk's reason; or, when nothing waits, files changed in the worktree that no review has seen, whether a turn was interrupted before its review or you edited them there yourself. It is your pass, so gates do not run first and nothing is auto-rejected as a re-proposal. What you accept becomes the conversation's private state, ready for /commit; what you reject is removed from the worktree; the model is told the result and the turn ends.

/review --skip-gates is an explicit alias for the same gate-free manual review. Both spellings require the active turn to have ended; unknown flags or extra arguments are refused. It does not disable gates on a later publication. For intentionally failing tests, follow acceptance with /commit --skip-gates.

/commit refuses while the worktree holds anything a review has not decided, and says so; /review is the answer. --skip-gates does not waive review.

The single-hunk case

There is no shortcut yet for a change of one hunk: it goes through the brief and the review like any other.