resolve-human-reviews · @pbakaus

Automatically resolve human review comments on the current PR. Fetches unanswered human feedback, evaluates each comment, applies fixes where appropriate, and replies to every comment with the outcome.

Prerequisites

All commands below use npx agent-reviews. If the project uses a different package manager, substitute the appropriate runner (e.g., pnpm dlx agent-reviews for pnpm, yarn dlx agent-reviews for Yarn, bunx agent-reviews for Bun). Honor the user's package manager preference throughout.

Cloud environments only (e.g., Codespaces, remote agents): verify git author identity so CI checks can map commits to the user. Run git config --global --get user.email and if empty or a placeholder, set it manually. Skip this check in local environments.

Phase 1: FETCH & FIX (synchronous)

Step 1: Fetch All Human Comments (Expanded)

Run npx agent-reviews --humans-only --unanswered --expanded

The CLI auto-detects the current branch, finds the associated PR, and authenticates via gh CLI or environment variables. If anything fails (no token, no PR, CLI not installed), it exits with a clear error message.

This shows only unanswered human comments with full detail: complete comment body (no truncation), diff hunk (code context), and all replies. Each comment shows its ID in brackets (e.g., [12345678]).

If zero comments are returned, print "No unanswered human comments found" and skip to Phase 2.

Step 3: Process Each Unanswered Comment

For each comment from the expanded output:

A. Evaluate the Feedback

Read the referenced code and the reviewer's comment. Human reviewers are generally more accurate and context-aware than bots. Treat their feedback with appropriate weight. Determine:

ACTIONABLE - The reviewer identified a real issue or requested a concrete change
DISCUSSION - The comment raises a valid point but the right approach is unclear
ALREADY ADDRESSED - The concern has already been fixed or is no longer relevant

Likely ACTIONABLE:

Reviewer points out a bug or logic error
Reviewer requests a specific code change
Reviewer identifies missing edge cases or error handling
Reviewer flags a naming, API, or architectural concern with a clear fix
Reviewer suggests a better approach with justification

Likely DISCUSSION -- ask the user:

Reviewer suggests an architectural change you're unsure about
Comment involves a tradeoff (performance vs readability, etc.)
Reviewer's suggestion conflicts with patterns used elsewhere in the codebase
The feedback is subjective (style, naming preferences) without team consensus
You disagree with the feedback and want the author to weigh in

Likely ALREADY ADDRESSED:

The code has been changed since the review was posted
Another commit already fixed the issue
The comment refers to code that no longer exists

B. Act on Evaluation

If ACTIONABLE: Fix the code. Track the comment ID and a brief description of the fix.

If DISCUSSION: Ask the user to consult the PR author. Apply their decision and track it.

If ALREADY ADDRESSED: Track the comment ID and note why.

Do NOT reply to comments yet. Replies happen after the commit (Step 5).

Step 4: Commit and Push

After evaluating and fixing ALL unanswered comments:

Run your project's lint and type-check

Stage, commit, and push:

git add -A
git commit -m "fix: address PR review feedback

{List of changes made, grouped by reviewer}"
git push

Capture the commit hash from the output.

Step 5: Reply to All Comments

Before posting to an inline review comment, fetch npx agent-reviews --detail <comment_id> and inspect the latest replies. PR-level issue comments and review summaries have no threaded reply list; an empty list for these types is not evidence that no outcome was recorded. The CLI skips replies to those types. Record that skip and do not create a replacement top-level comment or use another tool to bypass it. If the same outcome is already recorded, do not post it again. On a resumed session, use the fresh unanswered list instead of replaying a prior session's work queue. Revisit a decision only when new discussion or a user request calls for it.

For multiline or complex replies, write the exact reply text to a uniquely named UTF-8 file in a temporary directory outside the repository and use npx agent-reviews --reply <comment_id> --body-file <path_to_reply_file> (adding --resolve only where appropriate below). The CLI accepts absolute and relative paths; prefer an absolute path for the outside-repository temporary file. Use the file path directly, without shell command substitution. Do not also pass a positional message. Remove the temporary file after the reply succeeds; keep reply files outside the repository even if posting fails so later git add -A commands cannot commit them.

Now that the commit hash exists, reply to every processed comment. The --resolve flag marks the review thread as resolved on GitHub. Use it only when closing the conversation (discussions concluded, already-addressed), not for fresh fixes that the reviewer should still verify.

For each ACTIONABLE (we fixed it; leave the thread open so the reviewer can verify):

Run npx agent-reviews --reply <comment_id> "Fixed in {hash}. {Brief description of the fix}"

For each DISCUSSION (after user decision) (the decision concludes the thread):

Run npx agent-reviews --reply <comment_id> "{Outcome}. {Explanation of the decision and any changes made}" --resolve

For each ALREADY ADDRESSED (nothing more to do):

Run npx agent-reviews --reply <comment_id> "Already addressed. {Explanation of when/how this was fixed}" --resolve

Non-threadable comments: If a comment was posted as a PR-level issue comment (not an inline review comment on a specific line), the CLI cannot post a threaded reply and will print ⊘ Skipped reply: comment is not part of a review thread. That's expected. Record the outcome in the summary and move on; do not retry.

DO NOT start Phase 2 until all replies are posted.

Phase 2: POLL FOR FOLLOW-UP COMMENTS (loop until quiet)

The watcher exits immediately when new comments are found (after a 5s grace period to catch batch posts). This means you run it in a loop: start watcher, process any comments it returns, restart watcher, repeat until the watcher times out with no new comments.

Step 6: Start Watcher Loop

Repeat the following until the watcher exits with no new comments:

6a. Launch the watcher in the background:

Run npx agent-reviews --watch --humans-only --unanswered as a background task.

At startup, reconcile EXISTING COMMENTS against IDs already handled in this run and the latest replies from --detail; do not replay an already recorded outcome. The baseline can include genuinely unhandled findings submitted between Phase 1 and watcher startup. If it does, stop the watcher, process those findings through Steps 3-5, and restart it. Track non-threadable comments already skipped in this run so they do not cause a restart loop. Once the baseline is reconciled, process the IDs reported as new when the watcher exits with EXITING WITH NEW COMMENTS.

6b. Wait for the background command to complete (default 10 minutes; override with --timeout).

6c. Check the output:

If new comments were found (output contains EXITING WITH NEW COMMENTS):
1. Use --detail <id> to read each new comment's full detail
2. Process them exactly as in Phase 1, Steps 3-5 (evaluate, fix, commit, push, reply)
3. Go back to Step 6a to restart the watcher
If no new comments (output contains WATCH COMPLETE): Stop looping and move to the Summary Report.

Summary Report

After both phases complete, provide a summary:

## PR Review Resolution Summary

### Results
- Fixed: X issues
- Already addressed: X
- Discussion resolved: X
- Skipped per user: X

### By Reviewer
#### @reviewer-name
- {description} - Fixed in {commit}
- {description} - Already addressed

### Status
All review comments addressed. Watch completed.

Important Notes

Response Policy

Every comment gets a response - No silent ignores
Replies keep reviewers informed and unblock approvals
Even "already addressed" comments deserve acknowledgement

User Interaction

Ask the user when the right approach is unclear
Human reviewers often have context you don't - defer to the author when unsure
It's better to ask than to make a change the author wouldn't approve

Best Practices

Human reviewers are generally more accurate than bots - default to trusting their feedback
Keep fixes minimal and focused - don't refactor unrelated code
Ensure type-check and lint pass before committing
Group related fixes into a single commit
If a reviewer suggests a specific code change, prefer their version unless it introduces issues