Manage queues of small, reviewable PRs on GitHub

Creates the next branch of the queue at the current branch's tip (or at --base <branch>'s tip). In a namespaced queue you give the short name and the branch is created as queue/<name>/<short>, exactly like edit's sections; names containing / are used as-is, and plain-named queues stay plain. Extending inherits the queue name; starting a new one asks (or takes --queue). Branch arguments elsewhere (--base, track --parent, checkout) accept the same short names.

Opens a ratatui interface over the current queue line: the commits and their branches on the left, with optional message and diff panes on the right (each toggleable; drag the dividers to resize). Reorder by picking a commit up with Space, moving the insertion cursor with j/k, and placing it with Enter — the rebase runs once, on place, not per keystroke. Reword, split, squash, add branches and open PR links inline; every change mutates the queue immediately with full undo/redo (u/Ctrl-r). Press ? for the in-app help.

Opens the whole queue in an editor: every branch is a [name] section header, with its commits listed beneath — the first section is the front of the queue (merges first). The commit sequence is fixed: commits cannot be reordered or deleted, only assigned to branches. Move, rename, add, or remove the header lines: add one to split a branch in two, remove one to dissolve a branch into its neighbours, move one to shift commits between adjacent branches. Branch refs simply move to the new section boundaries; no commit is rewritten, so PRs keep their history. Removed branches are deleted (their commits are covered by the remaining branches). Short header names resolve within the queue; new ones are created as queue/<name>/<short> in namespaced queues. Also works on an untracked branch: it becomes one section over trunk, ready to divide

Adopts an existing branch into a queue: records its parent (trunk by default, or --parent), asks for a queue name when starting a new one, and offers to stamp Stable-Commit-Ids onto the adopted commits — asking first because stamping rewrites them (hashes change; an already-pushed branch will be force-pushed with lease on the next sync). --stamp-ids/--no-stamp-ids decide non-interactively, and --edit continues straight into the queue editor to divide the adopted commits into multiple branches.

Forgets the current branch's queue metadata (parent, anchor, cached PR number, descriptions, membership). The branch and its commits are untouched — this only removes it from the queue's structure.

Read-only view of the current line: one row per branch, front of the queue at the bottom, with PR number and state, a left-margin marker on the checked-out branch, and — when a branch holds persisted conflict markers — a warning listing the conflicting files. Markers are detected live, so the warning can never be stale. Output is colourised on a terminal, and PR numbers are clickable links in terminals that render hyperlinks.

status with one more level of depth: each branch's commits are listed beneath it, newest first, prefixed with the abbreviated Stable-Commit-Id ((no id) for unstamped commits). Those abbreviations are accepted by every command that takes a commit, so log is the natural way to find the argument for move, checkout or reword.

Checks out the child branch — one step toward the back of the queue. Errors helpfully at the top or at a fork (listing the children so you can pick one).

Checks out the parent branch — one step toward the front of the queue.

Detaches HEAD on a commit of the current queue — named by SHA or Stable-Commit-Id — after validating membership and a clean stage. From there, edit and git add, then: plain git commit INSERTS a new commit right after it, while git commit --amend REVISES it (the message carries over, so its Stable-Commit-Id is preserved). Either way everything that followed rebases onto the new commit, automatically with hooks installed or via git queue requeue. HEAD stays detached at the edited commit so you can keep going; git queue checkout <branch> reattaches and ends the session.

Rewrites a commit's message — HEAD by default, or any queue commit named by SHA or Stable-Commit-Id — and updates every descendant (engine: git history reword; atomic, aborts cleanly on conflict). Content is untouched.

Relocates a commit, or an inclusive <first>..<last> range of consecutive commits, to directly follow --new-parent — reordering within one PR or moving work to a different PR (the commits join the branch segment their new parent belongs to). All arguments accept SHAs or Stable-Commit-Ids. The whole line is rewritten in one git rebase --update-refs pass: branch refs ride along, conflicts are persisted as markers and flagged, and passing the base branch's tip as --new-parent moves commits to the very front of the queue.

Sets the QUEUE's description — the "About this queue" section rendered into every PR of the queue on the next submit/sync. Use it for the narrative that spans the whole queue: what the series achieves and how the pieces fit. Opens $EDITOR without -m; an empty message clears it.

Sets the current BRANCH's description — the "About this branch" section of its PR. Use it for what this one slice does. A hand-written body on a PR adopted from before the queue existed is imported here automatically rather than overwritten. Opens $EDITOR without -m; an empty message clears it.

Shows the current queue's name, or (re)names it. Every queue is named: the name appears in each PR's header, namespaces the queue's branches (queue/<name>/<branch>), and keys the queue-level description and activity time. Naming records membership on every branch of the line, so branches that don't follow the queue/<name>/… convention still resolve.

Lists every queue in the repository, most recently touched first — each with its branch roster, the first line of its description, and a marker for the queue you're on. Activity timestamps update whenever a queue operation runs, so the top entry is what you worked on last. Unnamed queues are listed with instructions to name them.

Commits like git commit, then requeues every descendant branch onto the new tip in one atomic pass (engine: git replay), so the branches behind yours never go stale. Stamps a Stable-Commit-Id if the commit-msg hook didn't. With hooks installed, plain git commit behaves the same — this command exists for hookless repositories and for scripting.

Folds the STAGED changes into the current branch's tip commit and updates every descendant, atomically (engine: git history fixup): if propagating would conflict with a descendant, it aborts and changes nothing — it cannot leave conflict markers. This is the everyday tool for addressing review feedback on a PR that has others queued behind it. The commit message, and with it the Stable-Commit-Id, is preserved.

The repair primitive: makes every descendant of the current branch consistent with its tip — nothing else. No network, no PR edits, no pruning. It is what the hooks run after a plain git commit/--amend (--auto stays silent when there is nothing to do), and the only command that reintegrates a git queue checkout editing session when hooks aren't installed. Reach for it manually after hand-made history surgery (cherry-picks, resets) leaves the branches above you stale.

The converge-with-reality command. Fetches with --prune, fast-forwards each queue's base branch, stamps Stable-Commit-Ids onto any queue commits missing them, drops branches whose work has landed (merged PRs, and squash-merges detected by Stable-Commit-Id), pulls genuinely new teammate commits (id correspondence guarantees your own rewrites are never re-applied over themselves), requeues the whole forest onto its bases, pushes everything back with --force-with-lease, and reconciles the PRs of every published queue — opening missing ones, reviving closed ones, refreshing bases, titles and queue maps. --no-push stops after the local requeue. It never pushes a branch that would make GitHub mislabel an open child PR as merged.

Publishes the current line: pushes every branch (front first, so bases exist), opens or revives its numbered PRs, and rewrites each PR's base, [k/n] title and body (queue map + About sections). Adopted PRs keep their hand-written titles (renumbered) and bodies. With the status gate enabled it also posts the red/green merge-order statuses. --draft opens new PRs as drafts.

Closes every open PR of the current queue without merging — for abandoning or restarting a published queue. Merged PRs, local branches and metadata are all left untouched.

Walks through git-queue's optional integrations, asking permission for each: hooks (auto-requeue after plain commits + Stable-Commit-Id stamping), the advisory merge-order gate, the Claude Code skill (when ~/.claude exists), and a marker-delimited git-queue section in this repo's AGENTS.md when other agent CLIs (Codex, Cursor, Gemini, Windsurf, Copilot) are detected — AGENTS.md being the cross-agent convention they all read. --yes accepts the two repo-local steps for scripts; --undo removes hooks, gate, skill and the AGENTS.md section.

Read-only diagnosis of merge-order signalling: whether the status gate is enabled, and whether the GitHub CLI is ready. Changes nothing.