Pull request review

PR Review is a full-screen workspace for reviewing a locally checked-out pull request on GitHub or GitHub Enterprise Server. It is separate from local Git hunk staging and from the editable two-file comparison.

Kvim home

Open and return to the editor

Use :review or Open PR Review in the command palette. There is no default Review shortcut; a custom normal-mode binding can use the review.open action. Kvim resolves the repository and the checked-out branch's PR. If that identity is ambiguous, select the PR explicitly with :review <number> or :review <https-PR-URL>. Discovery queries the current branch and its configured tracking names rather than scanning every open PR. While the initial snapshot is being fetched, a muted loading message is centered in the workspace instead of repeated in a popup or directly below the tabs.

The initial load fetches validated PR identity and revisions, the file inventory and supplied patches, and local drafts. Visible code-anchored review threads load asynchronously after the snapshot, without delaying the first diff. General PR discussion and review summaries load only when you open Discussion. Its first-load message uses the same centered, muted presentation as initial Review loading; failures remain prominent with explicit retry instructions. Hidden threads load when a Changes tree needs feedback badges, when you open Threads, or when file-backed Drafts needs conversation context. Summary-only Drafts does not fetch thread metadata. Thread loading combines comment bodies, anchors, permissions, and the pinned viewer/PR revision checks in one GraphQL read for a single-page collection. Larger collections use bounded pagination with identity/revision checks on every page. Servers that cannot serve this combined query use the existing validated REST-plus-GraphQL compatibility path. If thread permissions remain unavailable, comments stay readable with an explicit warning; publishing and resolution stay disabled. Invalid or stale identities, revisions, and incomplete data are rejected, not treated as empty threads. Partial GraphQL errors cannot bypass viewer/PR revision checks. Invalid error metadata, stalled pagination, and pages beyond the requested size or page limit are rejected without dispatching additional reads. Per-file reviewed state also loads in the background after the initial snapshot. These collections are cached for the current snapshot, including genuinely empty results; moving between panes does not refetch them. r refreshes the snapshot and drafts, invalidates the caches, and reloads only the secondary view you are exploring. Publication also invalidates the caches.

Loading and failed requests are shown explicitly, not as empty discussions. Press r to retry a failed load. Switching PRs, refreshing, or closing Review cancels outstanding reads. Deferred results must still match the PR and its base/head revisions; if the PR changed, refresh instead of mixing snapshots.

Direct terminal startup supports:

kvim --review
kvim --review -- "C:\work tree\project"

The first form uses the launch directory; the second uses the specified local directory, without replaying a saved workspace's startup location. --review cannot be combined with --goto, --diff, or --version. It never checks out a branch, fetches commits, saves buffers, resets the repository, or publishes a comment.

Review preserves the editor's buffers, splits, and unsaved changes. q returns to the editor when no composer, confirmation, or remote update is active. In Changes detail, h or Esc returns to the file tree without losing the source position; Esc from the tree returns to the editor. Reopening Review retains its navigation state and refreshes the PR. Drafts remain local until an explicit publication confirmation. The composer and publication journal share a 100-draft limit; existing drafts remain editable at that limit. Publication batches are validated before any local journal update or remote request.

GitHub Enterprise authentication

Install GitHub CLI (gh) and authenticate it against the relevant host before opening Review. Kvim uses gh for repository discovery and retrieves credentials with gh auth token --hostname <host>. API requests use a persistent HTTP client rather than launching gh for each request. Tokens remain private in Review session memory; they are never written to Kvim configuration, drafts, logs, or status messages.

Credentials are cached in memory for the current snapshot and reused for reads and explicit remote updates. Review remains signed in as its original viewer until refreshed: an external gh auth switch or logout does not change an already-open session while its cached token remains valid. Press r to adopt changed authentication.

If a remote update's read-only preflight receives HTTP 401 before any mutation has been dispatched, Kvim retrieves credentials from gh once, verifies the original viewer, and repeats the complete preflight. A changed viewer stops the update and requires refreshing Review; rejected credentials never replace the session's cache. Concurrent refreshes share the verified replacement. gh auth token retrieves credentials but does not guarantee renewal; an unsuccessful refresh remains an explicit error. Permission errors, rate limits, and network failures do not trigger credential refresh. Mutations are never automatically replayed, nor is an operation restarted after any mutation dispatch.

Enterprise host selection follows repository identity or the explicit PR URL, not an assumed github.com default. GitHub.com and GHE.com use their dedicated API origins; Enterprise Server uses its REST and GraphQL API paths, retaining explicit host ports. Credentials are confined to these validated origins and HTTP redirects are not followed.

Requests run off the editor loop with concurrency, output, pagination, and time bounds, and remain cancellable while connecting or reading the response. Authentication, certificate, permission, rate-limit, unsupported-capability, and truncated-data failures are reported rather than shown as an empty PR. HTTP failures report status and recovery guidance without displaying untrusted response bodies. Corporate certificates must be configured through the OS trust store or the normal trusted certificate mechanisms; Kvim retains bundled public roots and does not disable TLS verification.

The server must support PR review comments with source line/side coordinates. Thread resolution also requires the corresponding GraphQL capability and viewer permission. Unsupported resolution remains unavailable; it is not simulated locally.

Files are grouped in an expandable, directories-first tree with file icons. Added/copied filenames use the theme's Git-added color; modified/renamed filenames use its distinct Git-modified color. Deleted filenames are crossed out in the Git-removed color. Change-status letters are not shown. Changes file rows show right-aligned added/deleted line counts in the theme's Git colors, before the reviewed marker. The PR header shows whole-PR totals, independent of tree folds or thread filters. Both use GitHub's statistics from the existing metadata responses, not patch parsing or additional requests; binary files and omitted patches retain any available counts. Counts below 1,000 are exact; larger counts use compact decimal suffixes with at most one decimal and no trailing .0, such as +1K, +1.2K, and -12.4K (then M, B, and larger suffixes). Missing counts appear as +? -?, not zero. Zero additions or deletions are omitted, including both labels when neither side changed. The split-view tree has eight extra columns for the counts; on narrow layouts, any remaining count labels hide together rather than covering filenames, reviewed markers, or header progress. The far-left column shows a thread callout (@ in ASCII mode) for files with review threads or local file-comment drafts, including resolved threads and historical paths on renamed files. Local line drafts show the callout even before threads load; reply/edit drafts require a uniquely known owning thread. Summary drafts do not mark files. It is blank when no threads or file drafts exist, or ? while thread state is loading or unavailable and no file draft is known. Thread metadata loads in the background whenever the Changes tree is visible, even if inline cards are hidden. The tree describes the remote PR snapshot, not local Git status. Folder selection retains the last file's diff; select a file to change it. Refresh preserves the selected path and folder folds where possible. Changes navigation reveals the selected file even inside folded directories; thread jumps can reveal their target files.

The top tabs and context-sensitive command buttons use the same styling as Explorer. The four tabs are Changes, Threads, Drafts, and Discussion. Changes, Threads, and Drafts share a file tree and whole-file diff with inline feedback. Changes lists every changed file; Threads lists files with matching published threads and their thread children; Drafts lists files with local drafts and their draft children. The navigator is filtered, not the selected file's conversation: its diff includes published threads and local drafts, including the parent conversation for a draft reply or edit. Discussion remains a separate full-width conversation feed. The tab line identifies files/code keyboard focus with colored badges. Enter on a file focuses code; f returns to the tree without changing the file. Selecting a thread or draft previews its code context; Enter focuses the detail without changing tabs. f or Esc returns to that tab's tree. File/source positions and feedback focus are retained independently when switching tabs. Each tab also retains its tree selection and folds; exploring filtered feedback does not move the Changes tree's selection. Below 80 columns, each code-backed tab shows only its focused tree or detail. Narrow terminals use compact tab labels and shortcut-only buttons; numeric tab shortcuts remain available. Tree views keep a dim right-edge scrollbar track even when their content fits, adding a proportional thumb only when scrolling is needed. The diff's independent scrollbar appears when its content exceeds the viewport. The tree tracks expanded rows; the diff tracks code and its anchored thread cards across the full diff viewport. These follow keyboard navigation; Review's mouse handling is unchanged.

Changes uses the same whole-file unified diff renderer as Git Explorer: all unchanged code remains scrollable, with removals and additions interleaved, old/new line numbers, semantic row backgrounds instead of patch-prefix +/- signs, syntax colors, and stronger within-line change highlights. Files open near their first change; earlier code remains available. Literal source operators and indentation remain intact, and tabs use the editor's configured width. As in Git Explorer, added lines get within-line emphasis only when paired with removed text. New files and pure insertions, including extra lines in mixed hunks, keep syntax colors and the subtle added-line background without a redundant full-text overlay. Selection retains the added/removed background distinction. Whole-file views omit @@ headers; missing-final-newline notes remain separate metadata rows. Source selections and EOF-note focus retain their exact anchors as the full file loads; selections anchored to disappearing hunk headers are cleared rather than converted into source selections. Syntax comments adapt for contrast over line, within-line, and selection backgrounds; other token colors are preserved.

Complete content loads lazily for the selected file, pinned to GitHub's file blob SHA rather than the worktree or local branch. Kvim prefers existing local Git objects; otherwise it reads the immutable blob through authenticated gh, using the fork repository where appropriate. It does not fetch commits, change checkouts, or download every changed file up front. The supplied patch remains visible while loading. Source files are limited to 4 MiB, 50,000 lines, and 16 KiB per line, and must be UTF-8 text.

Syntax highlighting is prepared in the background with complete old/new file context; within-line pairing remains limited to original hunks. One worker and a latest-file queue bound source loading and highlighting. Results must match the PR, revisions, path, patch, and pinned blob. A bounded cache retains recent files until refresh. Missing, mismatched, unsupported, or oversized content keeps the authoritative patch view with an explicit Patch only status; r retries. That fallback retains hunk headers and hunk-local syntax context. Highlighting errors are explicit, with line colors still available. Original patch ranges remain separate from displayed context for comment eligibility, hunk navigation, and AI context; hunk-scoped prompts do not include the newly displayed unchanged regions.

Code review threads are shown inline by default, spanning the full diff width below their exact source lines at every terminal width. Comments use whitespace, author emphasis, and subdued metadata rather than horizontal separators. Unselected bodies retain the editor background. Open threads keep their Markdown colors. Only the selected comment has the Discussion-style soft background, dim half-cell caps, and muted left rail. The viewer's own comments are slightly indented. Thread and draft cards leave one editor-background column on each side, outside their decoration and author indentation, so they do not touch the pane edge or scrollbar. These margins are omitted in very narrow spaces; code gutters and scrollbar positions are unchanged. Anchored card headers omit redundant source-side and line labels; standalone, historical, and unmapped cards retain their coordinates. All comments and replies appear together in order, with individual authors and Markdown bodies using the editor's semantic colors. Long comments retain bounded previews; n/p focuses a thread, Left/Right selects a comment for expanded text, and J/K scrolls that comment. Resolved threads start folded and use neutral shades of gray for their authors, bodies, replies, code, links, and metadata. Selected resolved cards keep the same decoration with a neutral gray background; unselected cards retain the editor background. Markdown emphasis and layout are unchanged. The gray shades adapt for contrast in dark and light themes. This also applies to historical conversation previews; local drafts and state/rendering warnings keep their normal colors.

In each code-backed tab, ] reads forward and [ reads backward within the selected file. They page through code when a hunk is taller than the diff viewport, stop on each anchored comment/reply and local draft in display order, and page through long comment bodies before advancing. Small code sections advance to the next hunk or comment directly, skipping long unchanged gaps between hunks. Ordinary line/page navigation still traverses all file content. Reading navigation stops at the file's ends; it never wraps or switches files. Selecting a folded thread expands it locally, without changing its resolution on GitHub. Historical/unmapped cards are not reading stops. The command bar follows the selected code, comment, or draft; edit and resolution actions respect that item's permissions.

Local line-comment drafts and thread reply/edit drafts also appear as distinctly colored, full-width DRAFT sections below their exact source anchors, with the same selected-only card styling. They are not GitHub threads or published comments. Press 3 for Drafts to edit or read the full text; inline cards show a bounded preview until selected with [/]. A selected draft supports e to edit, d to confirm local removal, and J/K to scroll. Draft cards never become source-line targets. Saving a file/thread draft shows the inline cards again if they were hidden with t. Old-head drafts, renamed paths, and unavailable or ambiguous source ranges are never attached approximately; where their file is known, they appear in the historical/unmapped section. A reply/edit without a uniquely known thread stays in Drafts. Overall review summaries remain in Drafts, not in the file diff.

General PR discussion and submitted review summaries appear only in the separate Discussion tab, never above the diff. Press g or 4 to open it, j/k to choose a message. The full-width feed merges comments and reviews from oldest to newest, using comment creation times and review submission times. Editing a comment does not move it in the conversation. Server-side pending reviews, when returned by GitHub, are explicitly labelled Pending / not submitted after the submitted entries; local drafts remain in Drafts.

Messages use one row of spacing, without boxes or horizontal rules. Your own messages (the signed-in GitHub user's, not necessarily the PR author's) indent the whole block by four columns and have a colored you label. Indentation reduces on narrow terminals. Other messages stay at the normal left edge. Authors are bold, timestamps are muted, and review decisions such as Approved and Changes requested use their state colors. Routine COMMENTED / PR DISCUSSION labels and raw URL footers are omitted. Only the selected message has a soft theme-tinted background, dim half-cell caps above and below, and a thin muted rail beside its left edge. The caps occupy spacing rows, rather than adding padding to every message; moving focus does not resize messages. The rail is omitted when the pane is too narrow for its gutter. Unselected messages retain the normal editor background. Selected text colors retain their Markdown styling and are adjusted for contrast when RGB colors are available. Inline feedback in Changes, Threads, and Drafts uses the same selection treatment.

Timestamps combine a compact relative age and local date/time, for example 5 min ago (2026-10-27 2:23 PM). They align to the right of a wide header, or wrap onto muted metadata rows on narrow terminals. The system timezone is resolved off the UI thread when Discussion loads, respecting TZ and historical daylight-saving changes. Refresh reloads it. If local timezone detection fails, Kvim reports the failure and explicitly labels the timestamps as UTC instead. Relative ages update during normal rendering without refetching messages or rebuilding their Markdown.

Short messages appear in full; approvals without summary text need only a header and separator. Long messages start with a four-row preview and More.... Enter or z expands/collapses the selected message; selecting it alone never expands it. Expanded bodies use up to half the viewport, capped at 30 rows, so other messages remain visible. J/K scrolls the expanded body independently. Page Up/Down scrolls the feed, while Home/End selects its first/last message. Navigation never wraps. Focus, expansion, and reading positions survive tab changes, resizing, and refresh where their stable message identities remain.

Only visible and nearby message bodies are prepared as Markdown, using the shared bounded cache. Showing more cards makes no additional GitHub requests; existing lazy loading, empty-state reporting, and explicit failure/retry behavior remain unchanged.

Threads uses a directories-first tree with file icons and individual thread leaves. Only files containing matching threads appear, including historical paths no longer in the current diff. Selecting a thread previews its file diff and inline conversation on the right. Enter focuses that detail without leaving Threads; below 80 columns, tree and detail are separate focus surfaces. Left folds a branch or selects its parent; Right expands a branch. n/p selects the next/previous thread without leaving Threads, revealing folded ancestors. In detail, Left/Right selects a reply. The unresolved filter removes files and folders with no matching threads from the navigator; the selected file still shows its other published and local feedback. A historical file absent from the current inventory keeps an explicitly labelled standalone conversation preview. Selecting its file group instead shows guidance to select a thread, never the previous file's code. A filter with no matching threads clears detail focus and thread actions.

The header separates the PR number, title, and personal viewed progress using distinct text colors. Revision and local-HEAD badges are right-aligned beside the tabs when space permits, with a warning for divergence; narrow layouts prioritize the tabs and compact status badges. The diff is the PR snapshot supplied by GitHub, not the index-to-buffer diff. A matching HEAD does not mean that disk or open buffers have no additional changes.

The title line uses the label Review and a plain editor background, with distinct text colors for the PR number, title, activity, and reviewed-file progress. The PR title is centered, constrained between the label/number and status text, and clipped with an ellipsis when it is too long. Routine feedback such as loaded files and saved drafts appears in a temporary popup, not a reserved status row. Error notices remain until dismissed with Esc or replaced by another operation's feedback; dismissing a notice does not close Review. Confirmation prompts keep their own row only while active. The command bar occupies the last row, with an extra row for : or an active search.

Key Action
1 through 4, Tab/Shift-Tab Changes, Threads, Drafts, Discussion
f Focus the active code-backed tab's tree
h or Esc in detail Return to the active tab's tree
Ctrl-H/J/K/L Continue into the terminal's pane switcher without changing Review state
Ctrl-Shift-H/J/K/L Resize the terminal's pane divider without changing Review state
m on a file or focused code Toggle the file's reviewed marker on GitHub
j/k, arrows, Home/End Move the active selection
Page Up/Down Page the Discussion feed; move the active selection elsewhere
[ / ] Read backward/forward through hunks, code pages, comments, and drafts within the current file
/ / ? in Changes tree or file code Search forward/backward; Enter accepts, Esc cancels and restores the original position
n / N while search is active Next/previous match in the entered search direction; wrap at either end
t Show/hide inline review threads and local draft cards, and focus code in Changes
n / p outside search Focus the next/previous thread; retain Threads or stay within the current file in Drafts
g Open the separate Discussion tab
z or Enter on a thread or Discussion card Fold/expand the thread or message
u Toggle unresolved-only threads
x on a published thread Resolve or reopen the conversation on GitHub, after confirmation
J / K Scroll comment, draft, or expanded Discussion text
Left / Right on a thread in detail Select a reply within the thread
Left / Right in a tree Fold/select parent, or expand the selected branch
h / Left in the tree Fold the directory, or select its parent
l / Right / Enter in the tree Expand a directory, or focus a file's diff
Enter on a thread or draft tree leaf Focus its code-backed detail, or an explicit non-file preview
Enter on a diff source line Verify and open its exact local editor location
r Refresh the snapshot and drafts; reload secondary views on demand
Ctrl-P or <space>p Open the context-specific command palette

In the Changes tree, / searches full relative file paths using a case-insensitive literal substring, like Git Explorer. Search jumps between files without filtering the tree and reveals matches inside collapsed directories. Typing previews tree selection and highlights matching filename and folder text using the same search colors as normal buffers. Enter activates the matched file, and n/N activate subsequent matches. Typing does not fetch files from GitHub. Esc before accepting restores the original selection and folder folds.

In a file's code view, search uses the editor's Rust regex syntax, matched independently on each source line. It includes unchanged code, additions, and removals, but not line numbers, hunk headings, or discussion/draft cards. Visible matches highlight immediately on each keystroke, without waiting for a typing pause or the background search. Completed results mark the current occurrence bold and reveal it vertically and horizontally. Repeated matches on one line are separate stops. Use (?i) for case-insensitive code search.

Search works on the current file only, using the existing lazy file load. The prompt says patch only until complete source is available; if loading fails, results remain explicitly limited to that patch. When full source arrives, the query is rerun against it without fetching other PR files. After acceptance, these background updates preserve subsequent manual navigation. Whole-file matching and navigation counts run in one cancellable background worker; newer queries replace queued work and stale results are discarded. Queries are limited to 4 KiB and 50,000 matches; invalid regexes, excessive matches, and no matches are reported in the search row. The immediate visible preview is bounded to 64 KiB and 4,096 occurrences per frame; source lines over 16 KiB defer to the full background results.

Enter accepts the incremental jump and leaves n/N available for repetition; ? reverses their usual direction. Esc after accepting clears search without leaving the pane or closing Review, restoring normal thread-navigation shortcuts. Before accepting, Esc also restores code focus, source selection, and scroll. Changing panes, tabs, files outside tree search, or refreshing clears the search. Searching does not edit local files, publish comments, or mark files reviewed.

Remote paths are untrusted. Editor jumps retain no-follow and repository confinement checks. A historical/deleted line, a locally changed file, a dirty open buffer, or an unavailable exact mapping produces an explanation instead of positioning on an approximate working-tree line.

Outdated threads retain their original location and are labelled outdated. Threads without a unique current side/line match, including old paths after a rename, appear in a separate historical/unmapped section rather than being silently attached to a new hunk. Card focus cannot create a source selection or open an approximate local line. Missing or unsupported textual patches remain explicit. Display rows and hunk headers are never treated as source-line numbers.

Reviewed files

Press m on a selected file or while its code has focus in Changes to mark it reviewed, or to unmark it. Opening a file never marks it automatically. Folders and discussion cards are not reviewed-file targets.

After GitHub confirms a mark-reviewed update, Kvim advances to the next unreviewed file in tree order, skipping confirmed-reviewed files and including files whose review was dismissed by new changes. Collapsed ancestor directories are opened to reveal the destination. Focus stays in the file tree or code, and the next file starts at the top. No additional file is marked automatically. Navigation never wraps: if nothing eligible follows, Kvim stays on the marked file and reports No further unreviewed files, even if earlier files remain. Unmarking, failed writes, and stale acknowledgements do not advance. Missing reviewed-file state stops navigation with an explicit refresh notice, without discarding a successfully acknowledged marker.

These are the authenticated user's Viewed markers on GitHub/GitHub Enterprise, shared with the web UI, not local-only flags or review approvals. The tree aligns reviewed-state markers at the right edge of each file row, before the permanent scrollbar track. It uses a green check (x in ASCII mode) for viewed, a dot for unviewed, ! for new changes since last viewed (DISMISSED), and ? for unknown state. The title shows reviewed/total progress. Refresh with r to pick up web changes.

State loading is paginated, bounded and validated against the current PR, viewer, file inventory, and base/head revisions. An unsupported or denied API remains visibly unavailable; Kvim does not silently substitute local markers. No credentials or reviewed-file state are persisted locally.

m writes the marker immediately, separately from comment publication. It reuses the session credentials, checks the viewer and exact PR identity and revisions in one GraphQL read, then sends one mutation through the session's pooled HTTP client. A successful update does not reload the PR. Kvim validates the server's acknowledgement before updating the display. Closing or switching PRs is blocked while that write is in flight. Failed or uncertain updates are never retried automatically: refresh and inspect GitHub before retrying. GitHub does not offer a commit-SHA precondition for this mutation; if revisions change during the write, Kvim reports uncertainty instead of claiming the new diff was reviewed.

Resolve conversations

Select a published thread in Threads, or focus its inline card, and press x. Confirm in the centered dialog with y; Esc cancels without sending a request. The command bar and selected card offer Resolve for an open conversation and Reopen for a resolved one, only when GitHub reports the required viewer permission.

Resolution applies to the whole conversation, including all its replies. Outdated describes its source location, independently of whether it is open or resolved. Outdated conversations can be resolved or reopened even when their file no longer appears in the current PR. They retain their original coordinates and outdated label; resolved threads use a checkmark and subdued styling. Missing thread-state capabilities remain explicitly unavailable.

The update runs in the background after validating the PR, viewer, revisions, thread identity, and current permission. Only a matching, validated acknowledgement updates the display. It does not reload file inventory, diffs, or drafts. Kvim preserves the selected conversation, comment identity, and reading position when showing all threads, including saved tab views. If the selected reply has disappeared, it selects a surviving reply and resets body scroll. Local edit drafts whose target disappeared become unmapped without losing their text. In Threads with unresolved-only filtering, a resolved selection advances to the next matching thread in tree order, or the previous one at the end. Resolving the last matching thread clears its actions and shows the empty state.

Failed or uncertain GitHub updates never display success or retry automatically. If GitHub acknowledges the update but local navigation fails, Kvim reports both states and clears remote thread actions until a conversation is selected again. Refresh with r and inspect GitHub before retrying an uncertain update.

Draft comments, replies, and edits

Move to a source line and press c to draft a comment. Press v or V, extend the selection, then c for a range comment. A range must consist of contiguous source lines on one diff side within one original hunk; it cannot span separate hunks or mix added and deleted sides. Newly displayed context outside GitHub's supplied patch is readable and selectable, but cannot become a new line-comment target; c is unavailable there. s chooses the left/right side for context lines; added and deleted lines retain their own side.

On a focused inline thread or in Threads, R drafts a reply and e drafts an edit to a comment the viewer is permitted to edit. C drafts the overall review summary. In Drafts, e edits the selected draft and d asks for confirmation before removing it locally.

Drafts uses a filtered file tree and the shared code-backed detail, with rendered Markdown, target headings, and selected-only card highlighting. Selecting a reply or edit also reveals its published parent conversation, even when the unresolved-only filter hides that thread in other tabs. Review summaries have separate top-level entries with a Markdown preview. Unmapped targets remain accessible with explicit warnings; they never display a previous file's diff or acquire an approximate source anchor. Line drafts show their file, side, and line or range; replies and edits identify their target comment. Not-published, old-head, unconfirmed-save, and uncertain delivery states remain explicit.

Use j/k or the arrows to navigate the tree, Left/Right to fold folders and files, Page Up/Down to page, and Home/End to reach its ends. Enter focuses the selected file or draft's detail; f or Esc returns to the tree. In code, [/] reads through source and feedback; J/K scrolls a selected body. Non-file previews start compact; Enter or z expands or collapses them once detail has focus, and J/K scrolls an expanded body. Selection and expanded reading positions follow draft identity across refreshes and removals, not the draft's list index. C starts a review summary, including from the empty Drafts screen. These controls never publish feedback; S still opens the explicit publication preview.

The composer edits a multiline body: Enter inserts a newline, arrows move the cursor, Home/End move within the line, and bracketed paste inserts bounded text. Ctrl-S saves the draft locally and closes the composer. Esc on unsaved edits opens a centered confirmation dialog: s saves a local draft, d discards only the composer edits, and Esc returns to editing. An unchanged saved draft or an untouched empty composer closes without a prompt. Neither save path publishes. Discarding edits never deletes a previously saved draft. Empty new drafts are not saved; an existing draft cannot be overwritten with an empty body. Storage errors remain visible and block publication or closing with unpersisted changes; w retries local persistence.

Drafts are stored privately in Kvim's platform-resolved state directory, separated by host, repository, and PR. They include their target and PR head identity, not credentials. Changed PR heads do not automatically retarget drafts. Preserve or remove old drafts and recreate them at verified current locations.

Explicit publication

Press S to preview all drafts. Use c for Comment, a for Approve, or r for Request changes. A centered confirmation dialog shows the selected review type over the draft preview. J/K scrolls the preview one line at a time, including text behind the dialog; Page Up/Down pages it. Only y confirms publication; Esc cancels it. Removing local drafts also uses a centered confirmation dialog. Request changes requires a review summary. Approval is never inferred from having read files.

Comment publishes feedback without approving or requesting changes. New line comments and summary drafts still create a submitted GitHub Comment review; Kvim does not currently upload them as pending GitHub review drafts or offer standalone publication of new line comments.

For restored reply or edit drafts, S may first load the target comments. Press S again after loading to preview them; loading never publishes anything.

New line comments and the summary are submitted as a grouped review. Replies and edits are separate API operations. Kvim revalidates the PR snapshot and targets before writing, checks comment edit permissions and concurrent edits, and reports partial completion explicitly.

Publication is journalled before dispatch. A timeout or lost acknowledgement can leave publication unknown: inspect GitHub before removing reconciled drafts or trying again. Kvim never automatically retries an uncertain write. An interrupted publication is also unknown after restarting. Closing Review is blocked while a remote write is awaiting acknowledgement.

On a focused inline thread or in Threads, x asks for confirmation before resolving or reopening a thread, when the server and viewer permit it.

Ask Copilot

a or <space>ac sends a hunk/selected range, or the selected thread, to an existing live Copilot CLI conversation. <space>as chooses the conversation. The comparison commands :copilot send hunk, :copilot send line, and :copilot send selection are also available.

The context includes the PR identity, snapshot revisions, file, and explicit old/new coordinates. Historical or deleted text is source data, not a fake selection in the current file. Sending a snapshot does not save buffers. See Copilot for bridge setup, context limits, and the live conversation's tools, approvals, and privacy boundary.

Ask Copilot and publish a GitHub comment are different actions. Copilot can help explain or change code under its existing CLI permissions, but Kvim never publishes model output, approves a PR, or requests changes automatically.