fleet-agents 0.1.0

package/commands/fleet.md

@@ -0,0 +1,78 @@
+---
+description: Spin up / manage parallel Claude Code agents, each in its own git worktree
+argument-hint: <prompt>  |  <repo>: <task>; <repo>: <task>...  |  ls  |  rm <repo> <task>
+allowed-tools: Bash(fleet:*), Bash(fleet add:*), Bash(fleet ls:*), Bash(fleet rm:*), Bash(fleet kill:*), Bash(fleet skill:*)
+---
+
+You are driving the `fleet` CLI (on PATH) — it creates an isolated git worktree per task
+and launches an interactive `claude` for it (a tmux pane on macOS/Linux, or a separate
+terminal window on Windows). Run it via Bash. Do NOT do the worktree/terminal work yourself.
+
+User input: `$ARGUMENTS`
+
+## Routing
+
+- Empty input, or `ls`/`list`/`status` → run `fleet ls`.
+- `rm`/`remove`/`done <repo> <task>` → `fleet rm <repo> <task> --branch`. This removes that
+  worker **and every sub-worker it spawned** (the chain): closes their panes, removes their
+  worktrees, deletes branches.
+- `rm self` / `remove self` / "remove this worker" / "remove me" (no repo/task) → run
+  `fleet rm --self --branch`. From inside a worker this removes that worker + its sub-worker
+  chain (it reads the pane's FLEET_TASK). Only valid inside a worker pane.
+- `kill`/`teardown` → `fleet kill`.
+- `resume …` → `fleet resume …`.
+- Anything else → it's one or more **task launches**. For each, run the **Dispatch decision**.
+
+## Dispatch decision (run for EVERY task launch)
+
+The user gives a task in plain language (often `<repo>: <what to do>`, or just a prompt;
+multiple tasks separated by `;`/newlines, or a `.md` file path). For each task, decide four
+things, THEN issue one `fleet add`:
+
+**1. Repo + slug.** Repo = the name they gave; if none, default to the current repo by
+passing `.`. Only ask if the cwd isn't a git repo or they clearly meant several repos.
+Slug = a short kebab-case name from the description (≤25 chars).
+
+**2. Skill** — *you choose it.* Run `fleet skill ls` to see what's registered, then pick the
+single best-fit skill for THIS task, or none:
+   - Investigate / trace / "why" / "how does" / audit / debug-only (NO code change wanted)
+     → `research` (it's read-only — only pick it when the user wants understanding, NOT a fix).
+   - A user skill whose name/purpose matches the task (e.g. a `refactor` skill for "clean up
+     X") → that skill.
+   - Nothing fits, or it's a normal implement/fix task → no skill.
+   When unsure between a skill and none, prefer none. Briefly say which skill you picked and why.
+
+**3. Mode** — how the worker should run:
+   - **once** (default) — a one-shot task.
+   - **loop** — recurring / polling / monitoring work: "every N min", "keep checking",
+     "watch", "babysit the PR", "until CI is green". Seed the worker to start in loop mode.
+   - **goal** — a long autonomous push to a definite END-STATE ("keep going until X is done/
+     true"). Uses Claude Code's built-in `/goal <condition>`, which sets a Stop hook that
+     blocks the worker from stopping until the CONDITION holds (auto-clears when met). Phrase
+     the task as the end-state/condition to reach, not an action.
+
+**4. Launch** — construct exactly one `fleet add`:
+   - once + skill:  `fleet add <repo> <slug> "<task>" --skill <name>`
+   - once, no skill: `fleet add <repo> <slug> "<task>"`   (or a `.md` file path as the prompt)
+   - loop:          `fleet add <repo> <slug> "/loop <interval-or-blank> <task>"`
+   - goal:          `fleet add <repo> <slug> "/goal <completion-condition>"`  (phrase as end-state)
+   For loop/goal, the worker's FIRST message must be the slash command, so do NOT also pass
+   `--skill` (it would prepend text before the slash); instead fold any skill guidance into
+   the `<task>` text. Append a base branch only if the user named one. Add `--no-worktree`
+   only if they want it to run in the repo itself (e.g. read-only research).
+
+Launch independent tasks in parallel (multiple `fleet add` calls in one message).
+
+## Managing skills
+
+If the user asks to register/list/remove skills, use `fleet skill ls | add <name> <file.md>
+| rm <name> | show <name>`.
+
+## After launching
+
+Report a compact table: `repo/slug` → skill · mode · one-line task. Then remind them:
+- `fleet attach` in a terminal to watch/steer (tmux backend; you can't attach from here).
+- `/fleet ls` for progress, `/fleet rm <repo> <task>` to clean one up when merged.
+
+If a `fleet add` fails (e.g. unknown repo), surface the error and suggest a fix rather than
+retrying blindly.

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "fleet-agents",
+  "version": "0.1.0",
+  "description": "Run multiple Claude Code agents in parallel, each in its own git worktree — tmux on macOS/Linux/WSL, separate terminal windows on Windows.",
+  "bin": {
+    "fleet": "bin/fleet.js"
+  },
+  "type": "commonjs",
+  "files": [
+    "bin/",
+    "commands/",
+    "prompts/",
+    "review/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "tmux",
+    "git-worktree",
+    "agents",
+    "parallel",
+    "ai"
+  ],
+  "homepage": "https://github.com/sanil-23/fleet-agents#readme",
+  "bugs": "https://github.com/sanil-23/fleet-agents/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sanil-23/fleet-agents.git"
+  },
+  "license": "MIT"
+}

package/prompts/fix.md

@@ -0,0 +1,46 @@
+# Review-and-fix skill
+
+You **finish the work**: review the change, apply the fixes, verify, and commit. A response
+that only *lists* what should be done is a failure. Two phases, both required.
+
+## Scope & sanity check
+Work out the change from the task (default: **this branch's diff vs its base**). Check
+`git status` (clean, or only your own work-in-progress), the current branch, and the upstream.
+If the working tree is dirty in a way you didn't expect, **STOP and ask** — never stash or
+discard someone else's work.
+
+## Phase 1 — Review & apply fixes
+1. Get the diff + changed files; **read every changed file in full** (context matters — read
+   siblings for new files, both paths for moves).
+2. Learn the repo's own standards (`CLAUDE.md` / `AGENTS.md` / configs) and review against the
+   axes: correctness, tests, security, design/quality, project standards, docs.
+3. If this is a PR/MR with existing reviewer/bot comments (CodeRabbit, maintainers, inline
+   threads), address **every actionable one** — apply it, don't just describe it.
+4. Classify each finding/comment: `actionable-trivial` (fix now) · `actionable-non-trivial`
+   (fix if the direction is unambiguous, else defer with a reason) · `already-addressed` ·
+   `stale` · `disagree`/`defer-human`/`question` (surface it — never silently dismiss).
+   **Re-read the surrounding code before each edit** — state may have drifted since a comment
+   was written.
+5. Apply every clearly-directed fix. One logical concern per commit. Don't expand scope.
+
+## Phase 2 — Verify & commit
+1. **Detect and run the repo's quality suite** — formatters, typecheck/lint, and tests
+   (infer from `package.json` / `Cargo.toml` / `Makefile` / `pyproject.toml` / etc.). Run
+   independent suites in parallel; always run the formatter + typecheck when code changed.
+2. If a test fails on an apparent flake, rerun it **once**; if it still fails, STOP and report
+   — don't loop.
+3. Commit in **focused commits** (`fix(area): …`, `test(area): …`, `chore: apply formatting`).
+   The working tree must be clean before you finish.
+4. If this is a PR/MR and you have push rights, push to update it — plain `git push` to the
+   already-configured remote; never invent a different remote or push to `main`. Post any
+   deferred / disagree / question items back to the PR so nothing is lost in chat.
+
+## Output
+A final report: what was reviewed; each comment/finding → fixed / deferred / disagree with
+`file:line`; a checks table (typecheck / lint / format / tests → pass·fail); the commits made;
+and any outstanding items that need a human.
+
+## Guardrails
+Never force-push, push to `main`, skip hooks, amend already-published commits, or run
+destructive git without explicit approval. Never commit secrets. Stop on an unexpected dirty
+tree. Rerun a flake once, then report. Be honest — don't pad with invented issues.

package/prompts/research.md

@@ -0,0 +1,38 @@
+# Investigation / debug task — follow this method
+
+You are **investigating and debugging — NOT implementing.** Do not modify code, do not
+commit. Your deliverable is a precise findings report. Be thorough and exact; check
+multiple locations before concluding, and prefer reading the real code over guessing.
+
+## Method — follow in order
+
+1. **Orient by structure first.** `find` the repo tree and `ls` the key directories to
+   understand the layout before reading anything (e.g. Rust core in `src/`, React/Tauri app
+   in `app/src/`, TS/Node backend). Know where things live first.
+
+2. **Locate breadth-first with grep.** Use `grep -rn` (and `-r` / `-n`) across the WHOLE
+   repo for the relevant symbols, type/function names, and — crucially — the exact
+   user-facing strings/error messages. Cast a wide net; don't anchor on the first directory.
+
+3. **Read what grep surfaces and trace the flow END-TO-END.** Open the specific files,
+   then follow the data/control flow from entry point → core logic → UI/output across both
+   the core and the app layers. Don't stop at the first match — map the whole chain.
+
+4. **Pull history + ticket context.** `gh issue view <#>` / `gh pr view <#>` for the
+   ticket and reviewer discussion; `git log` / `git show` to see how the code got here and
+   what recent PRs (often referenced as "introduced by PR #N") changed.
+
+5. **Form a hypothesis, then verify it against the code paths** — not assumptions.
+   Reproduce the logic mentally (or via a read-only check / test run) and confirm the exact
+   mechanism. Check multiple candidate locations before settling.
+
+6. **Report.** Produce a tight findings report:
+   - **Root cause** — precise: `file:line` and the exact mechanism.
+   - **End-to-end flow** — the chain of files/functions involved, in order.
+   - **Evidence** — quote the key code lines.
+   - **Symptom origin** — the exact user-facing symptom and where it's produced.
+   - **Fix proposal** — what to change and where (do NOT make the change).
+   - **Open questions / risks** — anything unverified or worth a second look.
+
+If you delegate sub-investigations, have each return precise findings (file:line + the
+mechanism), then synthesize. Stay read-only throughout.

package/prompts/review.md

@@ -0,0 +1,51 @@
+# Code review skill
+
+You are doing a thorough, CodeRabbit-style code review. This is **READ-ONLY** — do not
+modify code, commit, or push. Produce a precise, honest review with concrete suggested fixes.
+
+## Scope
+Work out what to review from the task. If unspecified, review **this branch's diff against
+its base** (`git merge-base` → `git diff <base>...HEAD`); if a PR/MR is named and `gh`/`glab`
+is available, use its diff. Note the added / modified / deleted files.
+
+## Method
+1. Get the diff and the full list of changed files.
+2. **Read every changed file in full** — not just the hunks. For new files, read siblings in
+   the same directory to learn local conventions; for moves/renames, check both paths.
+   Hunk-only reading produces shallow reviews that miss architectural issues.
+3. **Learn the project's own standards** — read `CLAUDE.md` / `AGENTS.md` / `CONTRIBUTING`,
+   and the repo's linter/formatter configs, and hold the change to *those* conventions.
+   Don't impose external rules the project doesn't follow.
+
+## Review axes
+- **Correctness** — logic bugs, off-by-one, null/undefined, async/await misuse, race
+  conditions, resource leaks, error propagation and handling.
+- **Tests** — new behavior ships with tests; cover branches and error paths; test behavior
+  not implementation; no real network, no time-based flakes.
+- **Security** — credentials/secrets, injection (command / SQL / path traversal / XSS),
+  validation at trust boundaries, accidentally committed secret files (`.env`, keys).
+- **Design / quality** — dead code, commented-out blocks, unexplained TODOs, over-abstraction,
+  duplication, backwards-compat cruft, "what" comments instead of "why".
+- **Project standards** — whatever the repo's own docs/config require.
+- **Docs / UX** — public APIs and user-facing changes documented; for UI changes, check
+  accessibility, keyboard nav, and loading/error/empty states.
+
+## Classify each finding
+- **Severity**: `blocker` (must fix) / `major` (should fix) / `minor` / `nitpick` / `question`.
+- **Confidence**: high / medium / low.
+Drop low-confidence minor items — they're noise. Don't repeat what the linter/compiler
+already catches. Don't invent issues to pad the review.
+
+## Output
+- A short **walkthrough** (2–4 sentences: what the change does + overall assessment).
+- A **changed-files summary** table.
+- **Actionable findings** grouped by severity. EACH must have `file:line` (or a range) and a
+  **concrete before/after suggested fix** — a code block where plausible. "Consider
+  refactoring" is not a suggestion.
+- A **nitpicks** list, **questions for the author**, and a **looks-good** section.
+- If a PR/MR is named and you have the CLI for it, you may post the review + inline comments
+  and approve / request-changes; otherwise just emit the report.
+
+## Guardrails
+Read-only — never edit, commit, or push. Be honest: if it's clean, say so and keep it short.
+Never log secrets or PII in comments.

package/review/README.md

@@ -0,0 +1,60 @@
+# scripts/shortcuts/review
+
+Helpers for working through PRs on this repo. Runnable directly — no zshrc
+integration needed.
+
+| Script       | What it does                                                                      |
+| ------------ | --------------------------------------------------------------------------------- |
+| `sync.sh`    | Fetch PR head, check out as `pr/<num>`, merge `main`, wire push/upstream.         |
+| `review.sh`  | `sync` + hand off to the `pr-reviewer` agent to review, comment, and approve.     |
+| `fix.sh`     | `sync` + `pr-reviewer` (apply fixes) + `pr-manager-lite` (commit & push).         |
+| `coverage.sh`| `sync` + gather coverage CI context + agent to fix coverage, push, babysit checks.|
+| `merge.sh`   | LLM-summarized squash body + filtered Co-authored-by trailers + `gh pr merge`.    |
+
+## LLM flags
+
+- `review` / `fix` / `coverage`: `--agent <tool>` (default `claude`). Picks the
+  CLI that drives the agent prompt. An optional trailing positional
+  `<extra-prompt>` is appended verbatim to the agent's prompt (e.g.
+  `pnpm review fix 123 "focus on the retry logic"`).
+- `merge`: `--summary-llm <tool>` (default `gemini`). The LLM that condenses the PR
+  body + commit messages into a concise squash commit body. Use `--summary-llm none`
+  to skip summarization and keep the raw PR body.
+
+Any tool that accepts `-p "<prompt>"` and prints its response to stdout works.
+
+## Usage
+
+Via pnpm (preferred):
+
+```sh
+pnpm review sync 123
+pnpm review review 123
+pnpm review fix 123
+pnpm review coverage 123
+pnpm review merge 123              # --squash
+pnpm review merge 123 --rebase
+pnpm review --help
+```
+
+Or invoke the scripts directly:
+
+```sh
+scripts/shortcuts/review/sync.sh 123
+scripts/shortcuts/review/review.sh 123
+scripts/shortcuts/review/fix.sh 123
+scripts/shortcuts/review/coverage.sh 123
+scripts/shortcuts/review/merge.sh 123
+```
+
+## Config
+
+- Repo is derived from the `upstream` remote (falls back to `origin`). Override
+  with `REVIEW_REPO=owner/name`.
+- `REVIEW_BANNED_COAUTHOR_RE` overrides the substring regex used to drop
+  `Co-authored-by:` entries (default filters copilot / codex / cursor / claude /
+  anthropic / openai / chatgpt / `[bot]` / `noreply@github` /
+  `users.noreply.github.com`; matched case-insensitively on name or email).
+- Requires `git`, `gh`, `jq`. `review` / `fix` / `coverage` also require the
+  agent CLI (default `claude`); `merge` also requires the summary LLM CLI
+  (default `gemini`) unless `--summary-llm none`.

package/review/cli.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Dispatcher for `pnpm review <cmd> <args…>`.
+# Commands: sync | review | fix | coverage | merge
+
+set -euo pipefail
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+usage() {
+  cat <<EOF
+Usage: pnpm review <command> <pr-number> [args]
+
+Commands:
+  sync    <pr>                            Check out PR as pr/<num>, merge main, wire remotes
+  review  <pr> [--agent <tool>] [extra-prompt]
+                                          Sync + pr-reviewer agent (review, comment, approve)
+                                          Default agent: claude
+                                          Trailing extra-prompt is appended to the agent prompt.
+  fix     <pr> [--agent <tool>] [extra-prompt]
+                                          Sync + pr-reviewer (apply fixes) + pr-manager-lite (push)
+                                          Default agent: claude
+                                          Trailing extra-prompt is appended to the agent prompt.
+  coverage <pr> [--agent <tool>] [extra-prompt]
+                                          Sync + gather coverage CI context + agent to fix coverage
+                                          failures, improve coverage, push, and babysit the PR
+                                          Default agent: claude
+                                          Trailing extra-prompt is appended to the agent prompt.
+  merge   <pr> [--squash|--merge|--rebase] [--dry-run] [--force] [--admin|--auto] [--summary-llm <tool>]
+                                          Merge via gh (default --squash, deletes branch).
+                                          Requires reviewDecision=APPROVED and green required checks
+                                          (mergeStateStatus in CLEAN/UNSTABLE/HAS_HOOKS) — use --force to skip the local gate.
+                                          --admin bypasses branch protection (requires admin rights).
+                                          --auto queues the merge until checks/approvals are satisfied.
+                                          --dry-run prints the squash commit message and exits.
+                                          Default summary LLM: gemini (use 'none' to skip).
+
+Env:
+  REVIEW_REPO=owner/name                  Override target repo (default: upstream remote)
+  REVIEW_BANNED_COAUTHOR_RE=<regex>       Substrings filtered from Co-authored-by lines
+                                          (default includes copilot/codex/cursor/claude/…)
+  REVIEW_AGENT_SAFE=1                     Run the picked agent CLI bare instead of in
+                                          its "yolo" mode. Default 0 — claude / codex /
+                                          cursor are launched with their skip-permissions
+                                          flag so headless runs don't stall on prompts.
+EOF
+}
+
+cmd="${1:-}"
+if [ -z "$cmd" ] || [ "$cmd" = "-h" ] || [ "$cmd" = "--help" ]; then
+  usage
+  exit 0
+fi
+shift
+
+case "$cmd" in
+  sync|review|fix|coverage|merge)
+    exec "$here/${cmd}.sh" "$@"
+    ;;
+  *)
+    echo "[review] unknown command: $cmd" >&2
+    usage >&2
+    exit 1
+    ;;
+esac

package/review/coverage.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# coverage.sh <pr-number> [--agent <tool>] [extra-prompt]
+# Sync the PR locally, gather coverage-related GitHub Actions context, then hand
+# off to an agent to fix coverage gate failures, improve coverage, and babysit
+# the PR until the relevant checks are green or the work is clearly blocked.
+#
+# --agent picks the CLI that drives the work. Default: claude.
+# A trailing positional <extra-prompt> (any free-form text) is appended to the
+# agent's prompt verbatim.
+
+set -euo pipefail
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=lib.sh
+source "$here/lib.sh"
+
+require git gh jq
+require_pr_number "${1:-}"
+
+pr="$1"
+agent="claude"
+extra_prompt=""
+shift
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --agent) agent="${2:?--agent requires a value}"; shift 2 ;;
+    --agent=*) agent="${1#*=}"; shift ;;
+    *)
+      if [ -n "$extra_prompt" ]; then
+        echo "[review] unexpected extra arg: $1 (extra-prompt already set)" >&2
+        exit 1
+      fi
+      extra_prompt="$1"; shift
+      ;;
+  esac
+done
+
+require "$agent"
+sync_pr "$pr"
+
+coverage_checks=$(gh pr checks "$REVIEW_PR" -R "$REVIEW_REPO_RESOLVED" 2>/dev/null \
+  | grep -i 'coverage' || true)
+
+# Name of the coverage CI workflow to inspect. Override per-repo with REVIEW_COVERAGE_WORKFLOW.
+COVERAGE_WORKFLOW="${REVIEW_COVERAGE_WORKFLOW:-Coverage}"
+coverage_runs_json=$(gh run list -R "$REVIEW_REPO_RESOLVED" \
+  --workflow "$COVERAGE_WORKFLOW" \
+  --branch "$REVIEW_HEAD_BRANCH" \
+  --limit 5 \
+  --json databaseId,status,conclusion,url,createdAt,updatedAt,headSha || echo '[]')
+
+coverage_runs_summary=$(printf '%s\n' "$coverage_runs_json" | jq -r '
+  if length == 0 then
+    "No recent coverage workflow runs found for this branch."
+  else
+    .[] | "- run=\(.databaseId) status=\(.status) conclusion=\(.conclusion // "n/a") sha=\(.headSha) updated=\(.updatedAt) url=\(.url)"
+  end
+')
+
+if [ -z "$coverage_checks" ]; then
+  coverage_checks="No current coverage-related checks were returned by gh pr checks."
+fi
+
+prompt="I've already checked out branch pr/$REVIEW_PR with main \
+merged in and upstream tracking set (repo: $REVIEW_REPO_RESOLVED). Focus on the \
+coverage gate for PR #$REVIEW_PR.
+
+Current coverage-related PR checks:
+$coverage_checks
+
+Recent coverage workflow runs for this branch:
+$coverage_runs_summary
+
+Use the GitHub Actions error output for the coverage jobs to identify what is \
+failing. Fix the coverage workflow or scripts if they are broken, improve test \
+coverage as needed to satisfy the gate, run the relevant local checks, and push \
+the fixes back to the PR branch.
+
+After pushing, babysit the PR: monitor the coverage and related required checks, \
+investigate any new failures, and keep iterating until the coverage gate is \
+green or you hit a real blocker. If you are blocked, summarize the blocker \
+clearly with the failing check name, exact error, and what remains to fix."
+
+if [ -n "$extra_prompt" ]; then
+  prompt="${prompt}
+
+Additional instructions from the user:
+${extra_prompt}"
+fi
+
+agent_exec "$agent" "$prompt"

package/review/fix.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# fix.sh <pr-number> [--agent <tool>] [extra-prompt]
+# Sync the PR locally, then hand a fully-inlined "review + fix + push" prompt
+# to the chosen agent. The prompt is loaded from scripts/shortcuts/review/prompts/fix.md
+# so the workflow is agent-agnostic (no reliance on Claude Code's named
+# subagent registry).
+#
+# --agent picks the CLI that drives the work. Default: claude.
+# A trailing positional <extra-prompt> (any free-form text) is appended to the
+# agent's prompt verbatim.
+
+set -euo pipefail
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=lib.sh
+source "$here/lib.sh"
+
+require git gh jq
+require_pr_number "${1:-}"
+
+pr="$1"
+agent="claude"
+extra_prompt=""
+shift
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --agent) agent="${2:?--agent requires a value}"; shift 2 ;;
+    --agent=*) agent="${1#*=}"; shift ;;
+    *)
+      if [ -n "$extra_prompt" ]; then
+        echo "[review] unexpected extra arg: $1 (extra-prompt already set)" >&2
+        exit 1
+      fi
+      extra_prompt="$1"; shift
+      ;;
+  esac
+done
+
+require "$agent"
+sync_pr "$pr"
+
+if [ "${REVIEW_AUTO_ASSIGN:-1}" = "1" ]; then
+  gh_assign_self_pr "$pr" "$REVIEW_REPO_RESOLVED"
+fi
+
+template="$here/prompts/fix.md"
+if [ ! -f "$template" ]; then
+  echo "[review] missing prompt template: $template" >&2
+  exit 1
+fi
+
+if [ "${REVIEW_HAS_CONFLICTS:-0}" = "1" ]; then
+  conflict_block="# ⚠️ Merge conflicts to resolve FIRST
+
+When the PR branch was merged with current \`main\`, the following files were left with unresolved conflict markers (\`<<<<<<<\` / \`=======\` / \`>>>>>>>\`):
+
+$(printf '%s\n' "$REVIEW_CONFLICT_FILES" | sed 's/^/- /')
+
+Before doing anything else:
+
+1. Read each conflicted file and understand both sides — read surrounding code, recent commits on \`main\`, and the PR's intent before resolving.
+2. Resolve the conflicts by choosing the correct combination of both sides (NOT \`--ours\` / \`--theirs\` blanket strategies and NOT \`git rebase --skip\`).
+3. \`git add\` the resolved files and finish the merge with a clear merge commit: \`git commit --no-edit\` (the conflict-resolution merge message is already staged) — or supply a one-line message if you prefer.
+4. Run formatters / typecheck / tests on the resolved files to confirm nothing regressed.
+
+Only after conflicts are cleanly resolved should you proceed to the review/fix workflow below."
+else
+  conflict_block=""
+fi
+
+prompt=$(REVIEW_CONFLICT_BLOCK="$conflict_block" \
+         awk -v pr="$REVIEW_PR" -v repo="$REVIEW_REPO_RESOLVED" \
+             -v head_repo="$REVIEW_HEAD_REPO" -v head_branch="$REVIEW_HEAD_BRANCH" '
+  BEGIN { conflict = ENVIRON["REVIEW_CONFLICT_BLOCK"] }
+  {
+    gsub(/__PR__/, pr);
+    gsub(/__REPO__/, repo);
+    gsub(/__HEAD_REPO__/, head_repo);
+    gsub(/__HEAD_BRANCH__/, head_branch);
+    gsub(/__CONFLICT_BLOCK__/, conflict);
+    print
+  }
+' "$template")
+
+if [ -n "$extra_prompt" ]; then
+  prompt="${prompt}
+
+# Additional instructions from the user
+${extra_prompt}"
+fi
+
+agent_exec "$agent" "$prompt"