When a user enables Entire for the first time, we'd like to offer to run import for them to import their agents and ask which agent sessions they'd like to import

Base directory for this skill: /Users/ninawork/.claude/plugins/cache/claude-plugins-official/superpowers/6.1.0/skills/brainstorming

Brainstorming Ideas Into Designs

Help turn ideas into fully formed designs and specs through natural collaborative dialogue.

Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design and get user approval.

Anti-Pattern: "This Is Too Simple To Need A Design"

Every project goes through this process. A todo list, a single-function utility, a config change — all of them. "Simple" projects are where unexamined assumptions cause the most wasted work. The design can be short (a few sentences for truly simple projects), but you MUST present it and get approval.

Checklist

You MUST create a task for each of these items and complete them in order:

1. Explore project context — check files, docs, recent commits
2. Offer the visual companion just-in-time — NOT upfront. The first time a question would genuinely be clearer shown than described, offer it then (its own message); on approval its browser tab opens for you. If no visual question ever arises, never offer it. See the Visual Companion section below.
3. Ask clarifying questions — one at a time, understand purpose/constraints/success criteria
4. Propose 2-3 approaches — with trade-offs and your recommendation
5. Present design — in sections scaled to their complexity, get user approval after each section
6. Write design doc — save to docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md and commit
7. Spec self-review — quick inline check for placeholders, contradictions, ambiguity, scope (see below)
8. User reviews written spec — ask user to review the spec file before proceeding
9. Transition to implementation — invoke writing-plans skill to create implementation plan

Process Flow

The terminal state is invoking writing-plans. Do NOT invoke frontend-design, mcp-builder, or any other implementation skill. The ONLY skill you invoke after brainstorming is writing-plans.

The Process

Understanding the idea:

• Check out the current project state first (files, docs, recent commits)
• Before asking detailed questions, assess scope: if the request describes multiple independent subsystems (e.g., "build a platform with chat, file storage, billing, and analytics"), flag this immediately. Don't spend questions refining details of a project that needs to be decomposed first.
• If the project is too large for a single spec, help the user decompose into sub-projects: what are the independent pieces, how do they relate, what order should they be built? Then brainstorm the first sub-project through the normal design flow. Each sub-project gets its own spec → plan → implementation cycle.
• For appropriately-scoped projects, ask questions one at a time to refine the idea
• Prefer multiple choice questions when possible, but open-ended is fine too
• Only one question per message - if a topic needs more exploration, break it into multiple questions
• Focus on understanding: purpose, constraints, success criteria

Exploring approaches:

• Propose 2-3 different approaches with trade-offs
• Present options conversationally with your recommendation and reasoning
• Lead with your recommended option and explain why

Presenting the design:

• Once you believe you understand what you're building, present the design
• Scale each section to its complexity: a few sentences if straightforward, up to 200-300 words if nuanced
• Ask after each section whether it looks right so far
• Cover: architecture, components, data flow, error handling, testing
• Be ready to go back and clarify if something doesn't make sense

Design for isolation and clarity:

• Break the system into smaller units that each have one clear purpose, communicate through well-defined interfaces, and can be understood and tested independently
• For each unit, you should be able to answer: what does it do, how do you use it, and what does it depend on?
• Can someone understand what a unit does without reading its internals? Can you change the internals without breaking consumers? If not, the boundaries need work.
• Smaller, well-bounded units are also easier for you to work with - you reason better about code you can hold in context at once, and your edits are more reliable when files are focused. When a file grows large, that's often a signal that it's doing too much.

Working in existing codebases:

• Explore the current structure before proposing changes. Follow existing patterns.
• Where existing code has problems that affect the work (e.g., a file that's grown too large, unclear boundaries, tangled responsibilities), include targeted improvements as part of the design - the way a good developer improves code they're working in.
• Don't propose unrelated refactoring. Stay focused on what serves the current goal.

After the Design

Documentation:

• Write the validated design (spec) to docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md
  • (User preferences for spec location override this default)
• Use elements-of-style:writing-clearly-and-concisely skill if available
• Commit the design document to git

Spec Self-Review: After writing the spec document, look at it with fresh eyes:

1. Placeholder scan: Any "TBD", "TODO", incomplete sections, or vague requirements? Fix them.
2. Internal consistency: Do any sections contradict each other? Does the architecture match the feature descriptions?
3. Scope check: Is this focused enough for a single implementation plan, or does it need decomposition?
4. Ambiguity check: Could any requirement be interpreted two different ways? If so, pick one and make it explicit.

Fix any issues inline. No need to re-review — just fix and move on.

User Review Gate: After the spec review loop passes, ask the user to review the written spec before proceeding:

"Spec written and committed to <path>. Please review it and let me know if you want to make any changes before we start writing out the implementation plan."

Wait for the user's response. If they request changes, make them and re-run the spec review loop. Only proceed once the user approves.

Implementation:

• Invoke the writing-plans skill to create a detailed implementation plan
• Do NOT invoke any other skill. writing-plans is the next step.

Key Principles

• One question at a time - Don't overwhelm with multiple questions
• Multiple choice preferred - Easier to answer than open-ended when possible
• YAGNI ruthlessly - Remove unnecessary features from all designs
• Explore alternatives - Always propose 2-3 approaches before settling
• Incremental validation - Present design, get approval before moving on
• Be flexible - Go back and clarify when something doesn't make sense

Visual Companion

A browser-based companion for showing mockups, diagrams, and visual options during brainstorming. Available as a tool — not a mode. Accepting the companion means it's available for questions that benefit from visual treatment; it does NOT mean every question goes through the browser.

Offering the companion (just-in-time): Do NOT offer it upfront. Wait until a question would genuinely be clearer shown than told — a real mockup / layout / diagram question, not merely a UI topic. The first time that happens, offer it then, as its own message:

"This next part might be easier if I show you — I can put together mockups, diagrams, and comparisons in a browser tab as we go. It's still new and can be token-intensive. Want me to? I'll open it for you."

This offer MUST be its own message. Only the offer — no clarifying question, summary, or other content. Wait for the user's response. If they accept, start the server with --open so their browser opens to the first screen automatically. If they decline, continue text-only and don't offer again unless they raise it.

Per-question decision: Even after the user accepts, decide FOR EACH QUESTION whether to use the browser or the terminal. The test: would the user understand this better by seeing it than reading it?

• Use the browser for content that IS visual — mockups, wireframes, layout comparisons, architecture diagrams, side-by-side visual designs
• Use the terminal for content that is text — requirements questions, conceptual choices, tradeoff lists, A/B/C/D text options, scope decisions

A question about a UI topic is not automatically a visual question. "What does personality mean in this context?" is a conceptual question — use the terminal. "Which wizard layout works better?" is a visual question — use the browser.

If they agree to the companion, read the detailed guide before proceeding: skills/brainstorming/visual-companion.md

Yes

Continue

Implement

Create commits and push to a draft PR

Base directory for this skill: /Users/ninawork/.claude/skills/pr

Create Pull Request

1. Understand the Branch

Use origin/main as the comparison base for understanding branch scope. Do not use local main, a local PR target branch, or direct tree diffs such as git diff main or git diff origin/main for scope checks; those can include upstream-only changes and make this branch look like it reverted unrelated work.

Read the commit history to understand the full scope of changes on this branch.

Review the changed file list from the merge base to the current working tree and confirm every changed file belongs to the PR's stated goal:

If unrelated files or commits are present, STOP and report them. Do not create a PR that bundles unrelated work.

2. Discover Project Verification Commands

Inspect the project to determine how to build, lint, and test. Collect candidate commands from these sources, then deduplicate them before running anything:

1. Makefile — look for build, lint, check, test, ci, verify targets. Read the target recipes to understand what they run.
2. mise — check for .mise.toml or .mise/*.toml. Look for [tasks] definitions covering build, lint, test. If found, use mise run <task>.
3. CI workflows — read .github/workflows/*.yml (or .gitlab-ci.yml, etc.) to understand required coverage. CI is the ground truth for what must pass, but CI matrix shards and CI-only wrappers are not automatically local verification commands.
4. README.md — look for "Development", "Contributing", "Building", or "Testing" sections that document how to run checks.
5. Package manager conventions — detect from project files:
   • go.mod → go build ./..., go vet ./..., go test ./...; do NOT infer a lint command from Go alone
   • package.json → check scripts for build, lint, test
   • Cargo.toml → cargo build, cargo clippy, cargo test
   • pyproject.toml / setup.py → check for configured linters, pytest

If no lint command exists after checking all sources, state that explicitly instead of assuming an unavailable linter binary.

Reuse Cached Verification Discovery

Before rediscovering commands from scratch, choose an artifact directory using the AGENTS.md temporary artifact rule with agent name pfleidi-pr:

• Use ./tmp/pfleidi-pr/ only when ./tmp/ already exists and is already ignored.
• If no project-local artifact directory is available, do not use a verification cache by default. Ask before using /tmp/pfleidi-pr/ or modifying ignore files.

When an artifact directory is available, check for a verification cache at <artifact-dir>/verification-<repo-name>.md. The cache is only an input-token optimization; never commit it and never trust it blindly. If no artifact directory is available, perform normal discovery and skip writing the cache.

Reuse the cache only when all of these are true:

• It names the same worktree root and remote.
• It lists the verification source files it was based on, such as Makefile, .mise.toml, .mise/*.toml, CI workflow files, README files, and package manifests.
• Those source files still exist or are still intentionally absent.
• git diff --name-only origin/main -- <source files> shows no branch changes to those source files.

If the cache is missing, stale, or incomplete, perform normal discovery. After discovery, update the cache with:

• Repository root and remote.
• Verification source files inspected.
• Selected command plan grouped by coverage area.
• Commands intentionally skipped as duplicates, aggregate/subtask overlaps, CI-only jobs, or too-slow shard matrices.
• Any assumptions, such as "no documented lint task found."

Deduplicate Verification Commands

Build a command plan by coverage area, not by source. Do not run every command discovered.

• Run at most one command for each coverage area: build/compile, lint/static analysis, unit/core tests, integration tests, e2e/smoke tests.
• Prefer documented local developer tasks over CI-specific commands when they cover the same area.
• Do not run both an aggregate task and its constituent tasks. For example, if mise run check runs lint and tests, either run mise run check alone or run the narrower lint/test tasks, not both.
• Treat CI matrix shards as duplicated slices of one suite. Do not run every *:shard:* command locally when an unsharded local task covers the suite.
• If CI has only sharded commands and no local equivalent, ask before running all shards. Otherwise, run the smallest representative or changed-scope test command and note that the full shard matrix remains for CI.
• Do not run CI-only canary/e2e jobs locally by default. Run them only when the PR changes that surface, when the user asks, or when the project documents them as required local PR verification.

Log which sources you used, which duplicate/CI-only commands you skipped, and what commands you will run. If the deduplication rules require asking before slow CI-only coverage, STOP for confirmation; otherwise immediately proceed to step 3.

3. Run Verification and Auto-Fix

Run the deduplicated command plan in the fewest safe batches. Prefer background processing for independent validation tasks instead of running everything sequentially.

The commands should cover, at minimum:

• Build — the project compiles without errors
• Lint / static analysis — no lint warnings or static analysis failures
• Tests — the selected local test coverage passes without duplicating CI shards or aggregate/subtask combinations

Use the exact commands, flags, and build tags found in step 2 for the commands you selected. Do not invent your own flags.

Parallel Verification Rules

Partition the selected commands into dependency-safe batches before running them:

• Run mutating commands alone and before validators that depend on their output. This includes formatters, generators, codegen, migrations, package installation, or commands known to update snapshots, lockfiles, generated files, caches in the repo, or test fixtures.
• Run dependent commands after their prerequisite batch passes. For example, do not start tests that require generated code until generation succeeds.
• Run independent read-only validation commands concurrently in the same background batch. Build, lint/static analysis, typecheck/vet, and unit tests can usually share a batch when they do not mutate the working tree and do not require the same exclusive service, port, database, or fixture directory.
• Keep integration, e2e, or service-backed commands separate unless the project documents that they are parallel-safe.
• If unsure whether two commands are independent, run them sequentially. Correctness of validation beats speed.

For each background batch:

1. Start every command from the same working-tree state.

2. Run each selected validator directly, for example mise run lint, go test ..., or npm test -- .... Do not wrap validators in sh -c, shell redirection, tee, command separators, or pipelines solely to capture logs; that defeats command-prefix approvals and causes extra permission prompts.

3. Capture each command's stdout, stderr, exit status, and command line from the tool output separately.

4. While the batch is running, do not edit files, start auto-fixes, or treat partial output as a result.

5. Wait for every command in the batch to finish, then show verification as a compact table:

   Command	Exit	Relevant output
   go test ./pkg/foo -run TestBar -count=1	0	Short success excerpt.

6. For failures or short outputs, show complete output in the relevant-output column or immediately below the table. For long successful outputs, show the relevant excerpt and state that the rest was truncated.

7. If any command in the batch fails, treat the whole batch as failed for the fix loop. Results from other commands in that stale batch may help diagnose, but they do not count as passing verification after files change.

On Failure: Fix and Re-verify

If any command fails, do NOT stop. Instead:

1. Read the error output and identify every failure
2. Fix all issues — apply the minimal changes needed to make the failing command pass
3. Re-run the deduplicated verification plan from the top, using the same safe batching rules (not just the previously failing command — fixes can introduce new issues)
4. Show the updated verification table again, including complete failure output for any command that still fails

Repeat this cycle until all commands pass. Cap at 3 fix attempts. If verification still fails after 3 rounds, STOP and present the remaining failures to the user with full failure output — do not keep looping.

4. Prompt for Commit

After all verification passes, check for uncommitted changes:

If there are uncommitted changes (from auto-fixes in step 3):

1. Show the diff of all uncommitted changes
2. Propose a semantically correct commit message using the subject-plus-context style from AGENTS.md. The message must describe the net fix (e.g., "fix lint warnings in config parser" not "fix issues found during PR prep").
3. STOP and wait for user approval. The user may edit the message, split the changes, or commit themselves.

If the user approves the commit, do not rerun the full verification suite before committing unless files changed after step 3. If another sanity check is needed, use the commit-time verification scope from AGENTS.md: lint tasks, a fast compile/build check, and tests directly related to the changed code only.

If there are no uncommitted changes, proceed directly to step 5.

5. Push the Branch

If the branch has no upstream yet, use git push -u origin HEAD.

6. Create the PR

Determine a concise PR title (under 70 characters) from the commit history and diff.

Use the same branch-only comparison from step 1 ($MERGE_BASE to the current working tree) when deriving the title, PR body, changed-file list, and mostly-Markdown detection. Do not use local main or direct git diff origin/main output for PR description decisions.

Write the PR body with:

• What this PR does and why
• How it was implemented (brief, not exhaustive)
• Any migration, deployment, or reviewer notes if applicable
• For mostly Markdown PRs, a Rendered Markdown section linking to the changed Markdown files rendered on GitHub

Create the PR:

Create a ready-for-review PR only when the user explicitly asks for it with wording such as "non-draft", "ready for review", or "publish it as ready". In that case, omit --draft.

Show the PR URL and STOP.

Rules

• Do NOT add "Generated with Claude Code" or any AI attribution anywhere
• Do NOT summarize what you just did after showing the URL
• Treat a PR as "mostly Markdown" when more than half of changed files are Markdown (.md, .mdx, .markdown) or the main review target is Markdown documentation. In that case, include GitHub rendered links for the changed Markdown files using the pushed branch, e.g. https://github.com/<owner>/<repo>/blob/<branch>/<path>.md. Link all changed Markdown files when the list is short; for large docs PRs, link the main entry points or most important changed files.
• If the user provides a title or description, use it verbatim instead of generating one, but append rendered Markdown links for mostly Markdown PRs unless the user explicitly says not to modify the description.
• If the PR description contains checklist items (- [ ]), check them (- [x]) if and only if the corresponding step was actually verified during this workflow (e.g., build passed, tests passed, lint passed). Do NOT check items that were not verified. Do NOT leave items unchecked if they were verified.

ensure import isn't updated. it should still work as a standalone

Apply fixes according to the review comments https://github.com/entireio/cli/pull/1595

Base directory for this skill: /Users/ninawork/.claude/skills/pr-feedback

PR Feedback

1. Identify the PR

If the user provided a PR number or URL, use that. Otherwise, detect from the current branch:

If no PR exists for the current branch, stop and tell the user.

2. Fetch Review Comments

Fetch PR metadata first so comment decisions have intent context:

Also collect branch commits and changed files for context:

Show the PR context as a table before classifying comments:

Fetch unresolved review threads with GraphQL as the primary source of truth. Group work by thread, not by individual REST comment:

Filter to unresolved threads only. If there are no unresolved threads, report that to the user and stop — there is nothing to fix.

If GraphQL pagination indicates more review threads or thread comments are available, paginate before classifying. Do not classify a partial thread set as complete.

Use REST pull-review comments only as a fallback when GraphQL data is incomplete or a thread cannot be mapped to a review comment ID:

When REST fallback is used, deduplicate by GraphQL thread ID first, then by file/line/body/author. Do not present or fix the same review request twice.

3. Parse, Classify, and Group

Use permission-friendly reads while investigating comments. Avoid shell pipelines, command separators, subshells, and output filters for read-only source inspection because they create extra permission prompts and can block background work. Do not run commands like git show HEAD:path | sed -n '10,40p'. Use workspace file range reads, rg with path limits, path-scoped diffs, or one standalone git show <rev>:<path> only when the output is acceptably small.

For each comment, extract:

• Author — who left it
• Author type — bot, automated reviewer, human reviewer, or maintainer
• File and line — where it points
• Body — the actual feedback (verbatim, not paraphrased)
• Thread context — any replies in the same thread (to understand if it was already discussed or resolved conversationally)
• Thread ID and comment ID — the GraphQL review thread ID and original comment ID needed to reply and resolve

Group each unresolved review thread into a single finding. If multiple comments in one thread refine or supersede each other, use the latest unresolved reviewer request as the finding and retain the earlier messages as context.

Classify each finding source:

• Bot — GitHub bot, CI system, or linter/static-analysis account such as github-actions[bot] or codecov[bot]
• Automated reviewer — review-assistant accounts that produce natural-language suggestions, such as Copilot or CodeRabbit
• Human reviewer — non-bot reviewer
• Maintainer — repository owner/member/maintainer when that can be inferred from GitHub metadata

4. Present Findings

Present two separate sections:

Human Comments

Table ordered by:

1. Bugs / correctness issues — reviewer identified broken logic or missing error handling
2. Design / architecture feedback — structural changes, API shape, naming of public interfaces
3. Style / nits — formatting, naming of local variables, minor readability

Use this table format:

For automated reviewers, use the same table and set Reviewer to the tool account, with Priority based on the substance of the request.

Bot Comments (batched)

Table continuing the numbering from above, grouped by tool/bot:

Keep table cells short and scannable. Use the smallest useful verbatim quote, not the full comment body. Escape | characters inside code or text so the table remains valid Markdown.

End with a summary: total human comments, total bot comments, overall assessment of effort.

Do not stop for mode selection. Proceed by default with bot comments and human comments marked Autofix eligible. Mark a human comment Autofix eligible only when the requested change is source-backed, high confidence, minimal, unambiguous, does not require a product/design decision, does not add a dependency, does not change a shared/public interface, and has a clear verification path.

Leave all other human comments unresolved as Needs decision, with the exact decision needed. Do not reject a reviewer comment by default; rejection requires a user-provided public rationale.

Before applying any fixes, record the starting commit:

Choose an artifact directory using the AGENTS.md temporary artifact rule with agent name pfleidi-pr-feedback:

• Use ./tmp/pfleidi-pr-feedback/ only when ./tmp/ already exists and is already ignored.
• If no project-local artifact directory is available, do not create file artifacts by default; keep ledger/log/cache information in the response and mark file paths n/a. Ask before using /tmp/pfleidi-pr-feedback/ or modifying ignore files.

When an artifact directory is available, create a temporary thread ledger at <artifact-dir>/pr-feedback-<pr-number>.md. If no artifact directory is available, keep the same ledger fields in the final summary table instead. Update the ledger after each thread with:

• Thread ID, source category, reviewer, location, and status.
• Files touched.
• What changed and why.
• Related tests or verification commands.
• Planned public reply, if any.
• Resolve decision: yes/no and why.

5. Fix Bot Comments (batched)

Fix all bot comments first — these are mechanical and clearing them reduces noise before the human-comment phase.

1. For each bot finding:
   • Read the relevant code
   • Implement the fix — ONLY the changes needed for that single finding
   • Track the files changed for this finding so the final PR reply can identify the commit that contains the fix
   • If a fix is ambiguous or would conflict with a human-comment fix already applied, mark it Needs decision and continue
2. After all bot fixes are applied, present a summary table. Do NOT show a diff — the Edit tool already showed each change inline.

1. Proceed directly to Step 6.

6. Fix Human Comments (batched)

After bot fixes, work through Autofix eligible human comments in report order:

1. State which finding you are addressing (number and one-line description)
2. Read the relevant code and the full comment thread to understand intent
3. Re-check eligibility before editing; if the fix is no longer clearly eligible, mark it Needs decision and continue
4. Implement the fix — ONLY the changes needed for that single finding
5. Track the files changed for this finding so the final PR reply can identify the commit that contains the fix
6. If a comment needs a product/design decision, shared/public interface change, dependency, broad refactor, or has multiple reasonable fixes, mark it Needs decision and continue
7. If the user rejects the comment instead of fixing it, record the specific rationale to use in the final PR reply

Scope Rules

• Make the MINIMAL change that addresses the reviewer's feedback
• Keep the diff limited to files and lines directly required by the feedback
• First decide whether the feedback points to a local or systemic issue. Fix at the narrowest correct level; do not add a local workaround that hides a shared/root-cause bug.
• If the feedback requires a behavior-changing code fix, add or update the directly related test in the same fix. Prefer TDD, but complete the focused red-to-green cycle before stopping: write/update the failing test, confirm it fails, implement the fix, confirm the focused test passes. Do not stop after only adding the failing test unless the user explicitly asks.
• Do NOT rename variables, reformat code, or touch lines outside the feedback scope
• Do NOT refactor adjacent code, even if it looks related
• If the reviewer's comment is ambiguous, mark it Needs decision and continue with unrelated unambiguous comments
• Do NOT create any git commits during the fix cycle. Commits are handled only in the publish step, and only with explicit user approval when needed.

7. Verify Fixes

After all fixes are applied, run the project's lint and test commands scoped to only the changed files and their directly related tests. If no code changed, skip verification and proceed to Step 8. Use safe background batches for independent validators instead of running every command sequentially.

When selecting verification commands, reuse <artifact-dir>/verification-<repo-name>.md if an artifact directory is available and the cache is fresh under the cache rules from pfleidi:pr; otherwise discover the smallest relevant lint/test/build commands. Update the cache only when an artifact directory is available.

• Lint / static analysis — run the project's documented lint task, scoped to the files that were modified when the task supports scoping. Prefer lint-specific task wrappers such as make lint or mise run lint over invoking linter binaries directly. Do not use aggregate check, ci, or verify tasks unless you have confirmed they only run lint/static analysis. If the documented lint task cannot be scoped, run the smallest relevant project lint task.
• Tests — run only the test files that cover the modified code (same package, same module, co-located test files). Do NOT run the full test suite.

If no project lint task exists, state that explicitly instead of assuming an unavailable linter binary.

Run formatters, generators, snapshot updates, or other mutating commands alone before validators that depend on their output. Run independent read-only validators concurrently when they do not require the same exclusive service, port, database, fixture directory, or generated output. Keep integration/e2e/service-backed commands separate unless the project documents that they are parallel-safe.

For each background batch, start every command from the same working-tree state, capture stdout/stderr/exit status from the tool, do not edit files while the batch is running, and wait for every command to finish. Run each selected validator directly, for example mise run lint, go test ..., or npm test -- .... Do not wrap validators in sh -c, shell redirection, tee, command separators, or pipelines solely to write logs; that defeats command-prefix approvals and causes extra permission prompts. If an artifact directory is available and file logs can be written after the command completes without rerunning through a shell wrapper, save them under <artifact-dir>/logs-<pr-number>-<timestamp>/; otherwise mark the full-log path as n/a. If files change after a failed batch, none of that batch's successful results count as current verification.

Show verification as a compact table:

For failures or short outputs, show complete output in the relevant-output column or immediately below the table. For long successful outputs, show the relevant excerpt and log path.

If lint or tests fail due to issues introduced by the fixes:

1. Read the error output and identify every failure
2. Fix all issues — apply the minimal changes needed
3. Re-run the failing commands using the same safe batching rules
4. Show the complete output again

Cap at 2 fix attempts. If still failing after 2 rounds, present the remaining failures to the user with full output.

Once verification passes, show a summary: how many comments were addressed, rejected, intentionally left unresolved, or still blocked. Do NOT show a diff — the Edit tool already showed each change inline.

Proceed to Step 8 for threads that were addressed or intentionally rejected. Leave Needs decision threads unresolved and do not reply to them unless the user provided a public rejection rationale. Do not block publishing addressed threads just because unrelated threads still need a decision.

8. Publish PR Updates

After addressed/rejected threads are ready to publish:

1. Check branch state:

2. If there are uncommitted fix changes, STOP and ask the user whether to commit them now or let the user commit manually. Do not push until the fixes are committed. If the user approves committing, stage only files changed for the PR feedback fixes and write the commit message from the actual diff using the subject-plus-context style from AGENTS.md.

3. Push the committed changes for the current branch:

   If the branch has no upstream and the push fails for that reason, use:

   Never force-push.

4. Map each addressed finding to the commit or commits that contain its fix. Use the recorded starting commit, changed-file tracking, ledger, and git log / git show to identify the relevant short SHA(s). If one commit fixes multiple comments, reference the same commit in each reply.

5. Build and show a reply plan table before calling the API:

   Thread	Status	Reply body	Resolve
   PRRT_...	Addressed	Addressed in abc1234 by adding the nil check before dereferencing.	Yes
   PRRT_...	Needs decision	n/a	No

   Proceed without asking when every actionable reply row is either addressed or a user-approved rejection. Needs decision rows with Reply = n/a and Resolve = No do not block publishing addressed threads. Stop before API calls if a rejection lacks a public rationale or if any reply body is uncertain.

6. Reply to each original PR review thread:

   • For addressed comments, state what changed and the commit SHA(s), e.g. Addressed in abc1234 by adding the nil check before dereferencing.

   • For rejected comments, state why it was not changed, e.g. Not changed: this path already returns before allocation failure can be observed.

   • Keep replies concise but specific. Do not over-explain or repeat the diff.

   • Do not reply to comments the user explicitly chose to leave unresolved.

   • Prefer replying with the review thread ID:

     If the thread cannot be replied to by GraphQL, use the original review comment ID with the REST reply endpoint.

7. Resolve each thread after replying:

   Do not resolve a thread that was not replied to, is still ambiguous, or still needs user approval.

8. Present a final summary table:

   Thread	Reviewer	Location	Status	Reply	Resolved
   PRRT_...	reviewer	file.go:42	Addressed	Yes	Yes
   PRRT_...	reviewer	file.go:99	Needs decision	No	No

   Include push result, branch, ledger path, rejected comments and rationale, and any comments intentionally left unresolved or not resolvable via API.

9. Post-Publish

• If the user asks for adjustments, apply them
• If the user asks to revert specific fixes, revert ONLY those changes
• Do NOT commit or push additional changes unless explicitly asked

ARGUMENTS: https://github.com/entireio/cli/pull/1595

Push up changes, no replies