Review, Deliver, Verify, Close

The back half of the pipeline is where trust is earned: what changed against what was promised, the app running locally, then the delivery read off the repository and the feature driven for real.

Review

The card reopens with the plan as approved, snapshotted the moment you approved it, each step marked held or changed. Review runs on the planning model rather than the build model, because judging work is closer to planning than to typing. The agent that built the card stays in the session and is told the card is waiting on you and to stop there. The exception is the difficulties that carry an adversarial round, Hard and Very hard by default: there the arrow into Review hands the card to a genuinely fresh reviewer that reads the diff cold.

Below the plan sit the review's own rows, each with a severity icon and one line, the rest on click: NEEDS YOUR EYES (what the agent could not settle), ASSUMPTIONS and WHAT WAS DONE. One block of findings per stage: the plan's own Requires your attention is not drawn again here, because at Review the review's list is the one to read; it goes into ALSO IN THE PLAN with the rest of the plan. The RUN panel starts the apps the project declares in grid.toml and gives you the port; a root Makefile is read only while the project has no grid.toml.

ALSO IN THE PLAN is the catch-all, drawn last on every stage: one shut row per heading the agent wrote that Grid's own prompts do not name, opened by a click. Nothing an agent writes into the card is invisible from the panel. And every file path an agent writes (in a section, a finding, a task row, a gate's reason, the review stepper or a check's log) is a chip that opens that file in the Code view.

The Doing to Review arrow is gated. The bundled SDLC plugin refuses a card whose body is missing the Review sections and says which. Approve waits while the plan's clarifying questions are still open.

Per change

The file list is the edit journal, classified: every file the session wrote, grouped by repository, with the ones outside any repo named as such rather than reported as unchanged. Grid's own card store is left out. An agent edits its card on every stage move, and that file is Grid's bookkeeping rather than the work under review.

The journal is not only the editing tool's. At the end of every turn Grid asks git what the card's branch changed and journals whatever has no row yet, so a file written with sed or a heredoc is in the roster too, its note ending that it was found on the branch by git. Such rows land when the turn ends rather than when the command runs, and a card working in the shared checkout is not scanned at all, because its branch carries other people's commits too.

The stepper walks the diff file by file with three buttons: Approve & next, Send back and Skip. Send back either posts a Revise note to the live session or records a ROLLED BACK verdict on the file. No file is walked back here; the way back is the undo ledger in history.

All at once

Approve, Request changes (back to Doing with your note), Reject to Inbox, or Reject and close. The reject dialog carries an UNDO THE CODE WORK toggle that reverts the card's ledger entries before the move: on by default when you close the card, off when you park it.

Over an adversarial round every finding carries one three-way decision, taken once on the panel's list: FIX returns it to Doing as a task row, LATER files it on a follow-up card, DROP records it as accepted and files nothing. A critical starts on FIX and everything else on DROP, so approving over a reproduced critical costs a click. While any finding is on FIX the footer's primary is the send-back and Approve is not drawn at all; the reject dialog's FINDINGS TO SEND BACK list only reports what those picks decided and cannot be changed there.

What approval hands over

Where the card goes next is set per project (deliverAfter): Deliver first, which is the default, Verify first, or no Deliver stage at all. Into Deliver or into Verify, a fresh agent takes over and inherits only the card body. Approving a research card's review closes it, because it has no Verify.

Deliver

A fresh agent takes the card into Deliver, and Grid tracks the work itself as a live step list: commit, tests, land, push, pull or merge request, CI, merged, deploy, cleanup. Grid fills each step in from the repository and the forge as it happens. Tests is the project's own check, run by Grid on the card's branch before it lands.

The mode is per project with per-repo overrides, and ask-first is on unless you turn it off. The panel reads the repository (the branch, the commits since the card began, ahead and behind its upstream, the dirty count) and asks GitHub or GitLab for the pipeline's own verdict, refreshed on a timer while the card sits in Deliver. Moving on from Deliver is refused while a step has actually failed, naming which one. A step that is merely still waiting never holds the card, because a step nothing can settle would otherwise strand it. "Ship it anyway" on the panel moves it on regardless, with your reason recorded on the card. What guarantees a card does not close unlanded is Close's own landing, which runs whatever Deliver managed to do.

Verify

Verify is an agent session with one brief: restart the affected service so it picks up the change, drive the changed feature end to end for real, and record the outcome under a Verification section. It does not run the project's check itself. Grid ran that on the branch in Deliver and the row is already on the card, so Verify re-runs that row only with grid verify run <id>, when the branch has moved since. The panel draws UNIT, BROWSER and BY HAND rows. A check can pass, fail or be skipped; skipped means this machine cannot run it, which is neither a pass nor a failure, and Grid probes for the Claude in Chrome pairing on disk before a browser row can count. Your BY HAND tick is stored with the file verdicts. Re-run all asks the live session to run the checks again.

A red Verify does not send the card back to Doing. The card stays in Verify with the command, exit code and output on it, and asks you what happens next.

Close

Close removes the worktree and prunes the branch if it was merged. The gate refuses a card whose work cannot land and says why. There is no documentation step and no regression sweep; the worktrees chapter has the cleanup rules.