How I get reviewer comments back into Codex after sharing HTML

Putting a local HTML file online is mostly solved. There are small CLIs for it, plus the usual hosting platforms if you don't mind setting up a repo and a deploy.

The part that kept breaking for me came after I sent the link.

Someone would reply with a screenshot, or write something like "the total here is confusing." I still had to work out which version they saw, where "here" was, and how to turn that message into enough context for Codex to make a useful edit.

For a Markdown report, the same thing happened with page numbers and copied text. The file was easy to share. The feedback had lost its address.

I made a small CLI and Codex skill to test a different handoff. The basic flow looks like this:

Codex publishes -> reviewer comments in context -> Codex pulls the feedback -> I choose what to apply -> Codex publishes v2

Publishing from a Codex task

Install the CLI and Codex skill:

curl -fsSL https://preapp.app/install.sh | sh -s -- --harness codex
preapp login <agent-token>

Then publish an HTML directory or Markdown file from the workspace:

preapp publish ./dist \
  --title "Checkout review" \
  --slug checkout-review \
  --format json

The response includes separate view and feedback links. The reviewer doesn't need an account. They can select text, click an image or diagram, or leave a note on the whole document.

The separate links ended up mattering more than I expected. I can send a clean reading link to someone who only needs the report, and a feedback link to the person doing the review.

Pulling comments back into Codex

After the review, Codex can run:

preapp feedback get checkout-review --format markdown

The result includes a feedback ID, source version, and locator for each item. A text comment carries the selected quote and its surrounding context. Image and diagram comments carry their target reference. Markdown feedback also maps back to the source file and line.

Publishing the same slug creates v2 while the shared link stays the same. Old comments stay attached to the version they were written against.

I deliberately didn't make the skill auto-apply everything it reads. Reviewer text is untrusted data. Codex first relays the feedback, then stops. I choose the feedback IDs it may use before it edits anything.

That sounds a little fussy until someone writes a comment that looks like an instruction to the agent. In the production test, I included one of those on purpose. It stayed in the source feedback and never became a change instruction.

Interactive HTML needs a little more context

Static reports are handled by the command above. For an HTML prototype with buttons, routes, or client-side state, I publish it with a review profile:

preapp publish ./dist \
  --slug checkout-review \
  --review-profile prototype \
  --format json

The reviewer can use the page normally, switch into feedback mode, and click the exact element they mean. The locator includes the page hash, viewport, scroll position, element rectangle, and optional data-preapp-* labels from the source.

The owner can then turn selected feedback into a revision brief. Codex reads that brief instead of treating every raw comment as an edit request:

preapp revision get checkout-review --version 1 --format markdown

What the first real run caught

I ran the full flow on a checkout prototype in production. It went through four versions, two review loops, six feedback items, and two applied revision briefs.

The useful part wasn't the count. One reviewer caught a missing loading state on the submit button. Another asked for the total amount and item count to stay visible. A later review found that the total didn't say whether shipping was included.

There was also a real bug in the review interface itself: after rewriting or merging an item, focus moved to a hidden pane. Dogfooding the feedback loop exposed that too.

The same share link kept working through v1 to v4, while each comment stayed on the version and HTML state where it was made.

I recorded the full loop in a 41-second demo.

Trying it on real work

The CLI, Codex skill, MCP server, protocol docs, and examples are in an MIT-licensed repo:

https://github.com/serrendypity/preapp-agent

The hosted share and review service is PreApp. That part isn't open source, and it's free during early access.

I'm looking for 10 people who already use Codex, Claude Code, or another shell-capable agent for reports, HTML presentations, or prototypes. The useful test is one real, non-sensitive HTML or Markdown artifact, not a canned example. I'll help with the first publish if the setup gets in the way.

If you have one, reply with the artifact type and your OS. I'm mainly trying to find where the handoff still breaks.