Feedback and Edits

Feedback and edits

Three ways to say something about a plan, and they are not interchangeable.

Key	What it is	When it is right
v then f	Feedback on exact lines	This passage is wrong, and here is why
n	A note about the whole plan	A constraint that applies everywhere
e	A direct edit of a line	You already know the right wording

Line feedback

Put the cursor on the first line and press v to start a selection. Extend it with ↑ and ↓, press v again to end it, then press f to write the comment. enter saves it.

The comment is anchored to those exact lines. PlanX stores the text they quote along with the line numbers, which is what makes the anchor survive a revision that moved everything down twelve rows.

f on a line that already carries a note edits that note instead of starting a new one. j walks the feedback on the version, and h folds all of it at once.

The plan-wide note

n adds or edits one note about the whole plan. Use it for something that is not about a passage — a constraint on the approach, a decision that changes several sections at once, a standing instruction for the build.

The agent receives it under #### General, separately from the line comments, and treats it as a constraint on the whole plan rather than a comment on one place in it.

Direct edits

e rewrites the line under the cursor in place. With a selection live, e walks the selected lines one after another.

An edit is not a request. It says this is the wording, I have decided — which is a different act from commenting this sentence is confusing. Reach for it when writing the comment would take longer than writing the line.

Edits apply to the latest version only. An older version is history, and history is not edited.

Deleting a note

Emptying it. f on the note, clear the text, enter. There is no separate delete key, and an empty note is not a note.

What the agent receives

planx revise <id> v<n> and planx execute <id> v<n> return one document, and it is the same document either way — only its closing instruction differs.

The plan itself, fenced and byte-exact, under ### The plan as it stands (v<n>). The agent edits that text rather than its own copy from context, because a plan retyped from memory comes back re-wrapped and fills your next diff with paragraphs nobody touched.

Your edits, under ### Edited by the reviewer, above everything asked for. Each one names the line, what it was and what it now says. They are labelled as settled text to be reproduced exactly, not as work to do — the review already rewrote them in place on the stored version. They are placed first precisely because reading them first is what stops an agent rewriting them.

Your comments, under ### What was asked, one #### block each. Every one carries the section heading it fell under, the line numbers, and the lines it quoted as a blockquote, followed by what you wrote.

The plan-wide note, under #### General.

Anything still unaddressed, under ### Still unaddressed from earlier versions. A comment left on an older version whose quoted text is still present word for word was probably never acted on. It is a heuristic, and it is reported as one — a comment can be satisfied by changing something else entirely — so the agent is told to check each before deciding it does not apply.

An empty review

Pressing s with no comments, no edits and no note means the version was reviewed and there is nothing to change.

PlanX does not create an identical revision for that. The version you read is ready to build, and the hand-off list says so: an agent that picks it up is told reviewed with nothing to change, build the plan as written, do not capture a new version.

That is a different state from no review yet, which is nobody having looked. Both come back with the plan; they close on different instructions. An edit counts as a review, however few records sit beside it.

Comments do not have to be resolved before building

You can hand a plan on with its feedback still open, and doing so says: build it, with these. The execute payload carries every comment, and the agent works them into the code as it implements the plan around them.

A comment that asks a question is answered in the chat, not built. A comment that cannot be satisfied without changing the plan is where the agent stops and says so — that is a planning round, and it goes back through review.