GitDesktop Files

Added

• Per-repo custom agent container image. A repository can now add extra tools to its containerized agent sessions — e.g. Playwright for browser tests — by committing a .gitdesktop/agent.Dockerfile that starts FROM gitdesktop-agent:latest. GitDesktop builds it into a per-repo image (layered on the managed agent base) and runs that repo's container sessions and Test shell in it. Manage it under Settings → AI → Agent session isolation: a status line shows whether the custom image is built, Review & build shows the Dockerfile and asks you to confirm before building (the build runs the file's commands, so it never happens automatically — the guard for a cloned repo you don't fully trust), and Add custom tools… scaffolds a starter Dockerfile for you to edit and commit.
• Bitbucket Cloud (read). Connect Bitbucket in Settings → Accounts with an Atlassian API token (created at id.atlassian.com, used with your Atlassian account email; stored in your OS keychain), then browse & clone your Bitbucket repositories and read pull requests (diffs, comments, build statuses) and watch Pipelines with step logs — all in the same panels as GitHub and GitLab. Bitbucket has retired its native issue tracker (issues now live in Jira), so issues aren't shown for Bitbucket repositories.
• Bitbucket Cloud pull request & Pipeline actions. Beyond reading, you can now act on Bitbucket Cloud from GitDesktop: comment, decline, merge (merge commit, squash, or fast-forward, with an optional delete-source-branch), edit, create (drafts included), and approve/unapprove pull requests, plus rerun, trigger (with variables), and stop Pipelines. Add the write:pullrequest:bitbucket and write:pipeline:bitbucket token scopes in Settings → Accounts to enable them. Reopening a declined PR isn't available — a Bitbucket platform limit.
• Bitbucket Cloud PR reviews & drafts. Bitbucket pull requests gain the rest of the review flow: request changes as a true toggle (click again to revoke — unlike GitLab, Bitbucket's revoke works on every plan; approving also clears it), a reviewers picker that lists your workspace members (minus the PR author, whom Bitbucket won't accept as a reviewer), and a both-ways draft toggle — mark a draft ready for review or convert a ready PR back to draft.
• Bitbucket Cloud publish, Insights & repository settings. Three more Bitbucket surfaces come online. Publish a local repo — a repo with no remote can be published to Bitbucket from the sync bar's Publish repository… (or the not-ready panel): pick a workspace, give it a name (which becomes the URL slug), optionally a description, website, and public/private, and GitDesktop creates the repo, adds it as origin, and pushes the current branch. Insights now works on Bitbucket repos — the local-git charts, a Pipelines duration and success-rate chart, and a More on Bitbucket card that links out to Commits, Branches, and Pipelines (the GitHub-only community, traffic, and dependencies cards stay hidden). And repository settings (for a repo you admin) manage a Bitbucket repo end to end: General (description, website, language, fork policy, default branch), Default reviewers (from your workspace members), Branch restrictions (prevent pushes / force-pushes / deletion, restrict merges, require approvals / passing builds / resolved tasks, by glob pattern), pipeline Variables (secured supported, with an enable-Pipelines toggle) and Schedules (cron, enable / disable, delete), Webhooks (create / edit / delete with an event checklist — Bitbucket has no delivery-log API, so there's no deliveries view), and a Danger zone (rename, which updates your local origin remote automatically; change visibility; transfer via a link out to Bitbucket; and delete — Bitbucket has no archive).
• Bitbucket Cloud PR tasks, custom pipelines, deployments & create-time reviewers. Four more Bitbucket surfaces. A Bitbucket pull request now has a Tasks checklist in its conversation view — add, edit, resolve/unresolve, and delete tasks, with a completion progress bar, an "N open tasks" chip in the PR header that jumps to the list, and comment-attached tasks that link back to their comment (read-only once the PR is closed or merged). The Run pipeline dialog gains a Pipeline picker on Bitbucket repos whose bitbucket-pipelines.yml defines custom pipelines (pipelines.custom.*) — run the branch's Default pipeline or a named custom one, with the same variables. Repository settings → Pipelines → Deployments lists the repo's deployment environments (read-only, with tier and not-yet-used / admin-only hints and a Manage on Bitbucket… link out), and the Insights More on Bitbucket card gains a Deployments link. Finally, the Create pull request dialog lets you pick reviewers up front (an empty selection keeps Bitbucket's default reviewers).
• GitLab time tracking. Track time on a GitLab issue or merge request without leaving the app: set an estimate (e.g. 3h) and log spent time (e.g. 45m, or subtract with -15m), with a progress bar and an "over" note when spent exceeds the estimate. Issues show it in the side rail; merge requests show a compact clock summary in the header that opens the same controls in a popover.
• GitLab related issues. Link a GitLab issue to other issues in the project right from its side rail — pick one from the inline search, open a linked issue, or unlink it. Read-only once the issue is closed.
• Play manual GitLab jobs. A manual pipeline job — one that waits for a manual trigger — now shows a Run job button in the pipeline detail view that plays it, so you don't have to switch to GitLab to start it.
• GitLab auto-merge. Arm merge-when-pipeline-succeeds from the merge request view while a pipeline is running — the merge menu offers auto-merge (merge or squash) variants, and once armed the footer shows an "Auto-merge enabled" indicator you can cancel in place. GitLab merges it for you when the pipeline passes.
• PR notifications & remote pr-sync on GitLab and Bitbucket. The background PR poller — OS notifications for pull requests opened, merged, or closed, and the remote pr-sync automation that re-reviews an open remote PR when its head advances — now works on GitLab and Bitbucket repositories, not just GitHub. (Check and review-decision notifications stay GitHub-only for now: GitLab and Bitbucket don't report a check rollup or approval state in the list responses the poll uses.)
• Copy the branch name or HEAD SHA. The repository menu (and command palette) gained two clipboard actions alongside "copy the repo path": Copy branch name copies the current branch, and Copy HEAD SHA copies the full commit SHA of HEAD — each with a quick confirmation toast. Each disables when its value isn't available: Copy branch name on a detached HEAD, and Copy HEAD SHA in a fresh repo with no commits yet.
• GitLab, in the same panels. GitDesktop now speaks GitLab as well as GitHub, through the GitLab CLI (glab) — same delegated-auth model as gh, no tokens stored. Point the app at a GitLab repo (or browse and clone your GitLab projects from the GitLab tab in the clone dialog) and the Pull Requests panel lists its merge requests right alongside any local PRs — open and closed/merged, searchable and filterable. Open one for the description, comments, commits, and a syntax-highlighted diff (plus an "Open on GitLab" link) — and comment on a GitLab MR, close / reopen it, edit its title and description, approve / unapprove it (a GitLab reviewer action, with the approval count shown inline), request changes (the blocking reviewer state — the app adds you as a reviewer if needed and posts your drafted comment alongside; approving clears it), react with emoji on the description and comments (GitLab's award emoji, the same reaction bar as GitHub), merge it (merge or squash, optionally deleting the source branch — guarded so it never merges a head you didn't see), and edit its labels and assignees. The AI Review tab works on GitLab MRs too — run a code review or security audit of the MR diff and post it as a comment. You can also create a merge request right from the app (the New menu, the command palette, or the Compare tab) — it pushes your branch and opens the MR, draft included, and the Compare tab now spots an existing open MR from your branch and offers View instead of a duplicate Create. The Issues panel speaks GitLab too — its issues (open and closed) next to your local issues, and an issue view with the description, comments, and a side rail of labels, assignees, and milestone — with GitLab issue writes: comment, close / reopen, edit the title and description, react with emoji, editing labels, assignees, and the milestone right in that side rail, and creating issues (with labels, assignees, and a milestone) from the same dialog GitHub uses. Publishing a local issue or PR to GitLab works too. The Actions panel covers GitLab CI pipelines — the run list, a branch CI badge, a pipeline view with its jobs (status, durations, and per-job logs), plus the actions: cancel a running pipeline, retry a failed or canceled one, and run a fresh pipeline on any branch or tag with optional CI/CD variables. The Tags panel manages GitLab releases too — alongside your local tags: read the notes, the Latest badge, and asset links (open in browser), and publish, edit, and delete releases, upload files as asset links, and remove them (GitLab has no draft/pre-release toggles — it picks the latest release itself). The repository menu speaks GitLab too — View on GitLab, star / unstar, a Fork on GitLab link, and "Create issue on GitLab" — and you can publish a local repository to GitLab: the publish dialog (and the sync bar's Publish button) now offers GitHub or GitLab when both CLIs are signed in, creates the project, adds it as origin, and pushes. Insights rounds it out: the local-git charts always worked, and the CI card now charts GitLab pipeline durations and success rate (the GitHub-only cards — community, traffic, dependencies — hide, with GitLab's web-only analytics linked instead). GitHub repositories are completely unaffected.
• Self-managed GitLab. Everything above now works on your own GitLab instance, not just gitlab.com — sign glab in to the host (glab auth login --hostname …) and GitDesktop recognizes repositories on it automatically, labels them correctly ("View on GitLab"), and routes every read and write through your per-host glab credentials.
• GitLab issue lock, move, and delete. The issue view's "More actions" menu now works on GitLab: lock / unlock the conversation (GitLab locks without a reason, so there's no reason submenu), move the issue to another project you have access to (with project suggestions; the original closes with a "moved" marker), duplicate it, and delete it (Owner-only, type-to-confirm).
• GitLab project settings. The repository-settings dialog now manages GitLab projects end to end: General (description, topics — AI-generate works here too — default branch, per-feature access levels with proper everyone/members-only/disabled tri-states, merge method, squash policy, and the merge checks), Members (add/re-role/remove by username, with inherited group members shown read-only), Webhooks (create/edit/delete with per-event triggers and a secret token, send a test event, and debug with the delivery log — request/response payloads and one-click re-send), CI/CD variables (add/edit/delete, protected and masked flags), and the Danger zone (rename with path redirect, archive/unarchive, visibility, transfer to another namespace, delete — Owner-only actions explain themselves when you're a Maintainer). Gated by your actual GitLab role, straight from the repository menu.
• GitLab protected branches. Manage protected branches from repository settings: protect a branch or wildcard with per-rule push/merge access levels and a force-push policy, toggle force push in place, and unprotect — rules inherited from a group show read-only.
• GitLab issue due dates and confidential issues. Two GitLab-unique fields in the issue view's side rail: a due date (type a date and press Enter or pick from the calendar; one click clears it, and an open issue past its date reads Past due) and a confidential toggle that hides the issue from non-members. GitLab-only — the rail on GitHub repositories is unchanged.
• A browsable, persistent Agent sidebar. Several quality-of-life upgrades to the Agent list: the activity log now survives a restart — reopening the app no longer drops a session's, plan's, or research run's step-by-step tool log (the full interleaved transcript of reads, edits, commands, and web is persisted, not just the flat prose). Every entry now carries a GitHub-style #N identifier (a stable, global number) shown on its row, so an entry can point at what it became — a research run shows the plan it turned into (Turned into plan [#12]), and a plan shows the session that implemented it (Implemented · Ready to review [#10]). Each row also shows its provider · model (e.g. Codex · gpt-5) for browsing by agent, and right-clicking a row opens a context menu of its actions — Open, Resume/Keep/Discard a session, Save/Copy/Turn-into-Plan a research report, jump from a plan to its session or file it as a local issue, and so on.
• See every step the agent takes — now with inline diffs. The agent surfaces (Delegate, Plan, Research) show the agent's work as one step-by-step transcript — each file it reads, edits, searches, command it runs, and page it fetches, interleaved with its narration in the order it happened (the way Claude Code and the VS Code agent read). In a write session you can now expand any edit step to see that file's diff inline — the file's cumulative change in the session, syntax-highlighted, without leaving the conversation. (Read-only Plan and Research don't edit, so their steps stay informational.)
• Research mode — Brainstorm & Deep research. A new read-only, web-enabled agent mode in the Agent tab, sitting upstream of Plan. Brainstorm surveys the web and your repo and surfaces several distinct directions with prior art; Deep research investigates one direction in depth and streams a cited report — rendered right in the app, never bounced to an external editor. The two are one switchable mode, not separate sessions: start in Brainstorm to widen your options, then switch to Deep research from the follow-up composer to flesh out the direction you chose — the whole conversation carries over (just like switching a model mid-session). When you're happy, hand a report straight to Plan or save it as a local Markdown file (written to .gitdesktop/research/ for you to review and commit — never committed automatically). Keep refining with follow-up messages; several runs go side by side. Read-only throughout: it searches and reads, but can never write. Runs on any agent — Claude, Codex, GitHub Copilot, or opencode — each using its own native web search and fetch (opencode's web search needs its Exa integration enabled; web fetch always works).
• Custom & LAN AI servers, with an allowed-hosts list. You can now point GitDesktop at an Ollama (or any OpenAI-compatible) server running on another machine on your network — not just localhost. Set the server's URL under Settings → AI (now available for the review model too, not only generation), then allow its host in the new Allowed hosts list — or just click Allow host on the inline prompt that appears when you enter a URL that isn't permitted yet. Built-in providers and localhost are always allowed; everything else must be on your list, which is the gate the app enforces before every AI request — so a typo or a compromised page can't quietly reach an arbitrary server.
• Advanced merge tooling. The Merge into current picker now predicts the merge before you run it — a calm status line shows fast-forward, already up to date, clean merge, or which files will conflict, computed in memory with git merge-tree (it touches nothing). Two options join it: Always create a merge commit (--no-ff), and an On conflict strategy — Stop and let me resolve (default), Prefer current branch (-X ours), or Prefer incoming branch (-X theirs) — that auto-resolves conflicting hunks in one side's favor, clearly cautioned that the other side's conflicting changes are dropped (and the preview then reframes to "N files auto-resolved"). Degrades quietly on older git. GitHub Desktop has none of this.
• Interactive rebase — "Edit history". A new Edit history… item in the History context menu opens an editor over your unpushed commits where each commit gets a per-row action — pick, reword, squash, fixup, edit, or drop — plus ↑/↓ reorder and inline message editing (reword loads the full original message and can regenerate it with AI). A live "Result: N commits" footer shows what you'll end up with. Edit-free plans run the atomic conflict-safe replay engine (any conflict rolls everything back untouched). Choosing edit instead starts a real, resumable rebase that pauses at that commit so you can amend its contents — the Changes banner reads "Rebase paused — amend… then Continue", you amend with the normal stage/commit flow, and Continue/Abort finish it (conflicts on this path are resolvable, not rolled back). It refuses a dirty tree, merge commits, or already-pushed history. The quick Squash N commits… multi-select shortcut stays; the standalone Reorder dialog is folded into the editor. GitHub Desktop has no equivalent.
• GitHub Enterprise support. GitDesktop no longer assumes github.com — every GitHub feature runs through gh, which detects each repository's host from its remote, so an Enterprise Server repo (github.acme.com) gets the same pull requests, issues, Actions, and repository-settings features once you've signed in with gh auth login --hostname your.github.example. Settings → Accounts now groups signed-in accounts by host and switches the active account per host (a single-host user sees the same flat list as before); author avatars, profile links, and the gh auth refresh scope hints all resolve on the repo's actual host. Unlike GitHub Desktop, no separate Enterprise sign-in flow — it follows whatever hosts you've added to gh.
• Auto-fetch (background sync). GitDesktop now keeps the open repo's view of its remote current on its own: an opt-out periodic background git fetch (Settings → General; on by default, every 5 / 10 / 15 / 30 / 60 minutes) runs while the window is focused, plus once when you return to the app or open a repo and it's been at least one interval. It's quiet — no toasts, the Fetch button just spins, and its tooltip shows when the repo was last fetched. It only updates remote-tracking refs, so the behind-count and incoming commits stay fresh without ever pulling, merging, or touching your files — pushing and pulling stay manual.
• Conflict resolution, in-app. Selecting a conflicted file no longer shows an empty pane — it opens a conflict editor: the file rendered with each conflict region called out as Current (ours) over Incoming (theirs), with Accept current / Accept incoming / Accept both on every region, or whole-file Accept all current / Accept all incoming and Open in editor in the header. Resolve as granularly or as bluntly as you like; the file is marked resolved automatically once the last conflict is gone. Works with AI off.
• AI conflict resolution. The same editor's Resolve with AI asks your model to merge a file: it streams a proposal you review as a diff against your side (flip to the full proposed file or the ours / theirs / base versions), then Accept & stage applies it — nothing is written until you accept; Regenerate retries, Discard drops it. The conflict banner's Resolve all with AI walks every conflicted file in turn. It uses your configured Review model, so it runs on any provider including local Ollama and keyless Claude Code / Codex agents, honors your AI ignore patterns, and is hidden entirely when AI features are off. Unlike GitHub Desktop's Copilot-only equivalent, there's no subscription or sign-in lock-in.
• Worktree manager. A new Worktrees… dialog (repository ⋯ menu, or the command palette) lists the repo's linked worktrees and lets you create one (a new branch from any base, or an existing branch, checked out into its own folder), open one to switch the active repository to it, rename one, lock / unlock one (with an optional reason, to guard it from accidental removal — handy for a worktree on a removable or network drive), and remove one safely (the branch is kept; a worktree with uncommitted changes asks before force-removing). A Repair links action re-connects worktrees after you've moved or renamed the repository folder. The branch switcher is worktree-aware too: a branch already checked out in another worktree is badged, and selecting it offers to open that worktree instead of failing. Worktrees let you work on several branches at once without stashing or switching, and the ones AI agent sessions use internally stay hidden and protected — you can't list, rename, or delete them by accident.
• Use GitDesktop as an MCP server. GitDesktop can now be a Model Context Protocol server, not just consume them. A new Use GitDesktop as an MCP server panel in Settings → MCP servers shows a ready-to-paste config snippet that points any external MCP client — Claude Desktop, Cursor, Claude Code — at this repo. The app runs as a read-only stdio server (gitdesktop mcp --repo <path>) exposing ~20 git & GitHub tools (status, log, diffs, blame, branches, file history/read, PRs, issues, CI logs), so an agent can understand a repository without changing it.

• MCP servers for agent sessions (Claude, host). A new Settings → MCP servers panel lets you register Model Context Protocol servers — local (stdio) or remote (HTTP), with environment variables / headers and secrets kept in your OS keychain — and a new MCP picker in the agent composer opts a session into the ones you choose. A Claude session passes only the servers you picked, in strict mode, so a run never inherits other MCP servers on your machine; with no servers registered, nothing changes. Don't have any yet? Browse opens the official Model Context Protocol registry right in the panel — search it and add a server in a click. Each result shows signals to vet a server before adding it: GitHub stars and activity, weekly npm installs, deprecation status, the source repo, and — expanded — exactly what it runs or connects to and which secrets it needs. Browse has two sources you can toggle between — the official registry and GitHub (repositories tagged mcp-server, ranked by stars, with the same vetting signals; ones with a manifest add cleanly, others arrive marked needs setup). Added servers still land disabled for review. Already have servers set up? Import pulls them in from the open repo's .mcp.json or your global Claude config — reviewed, started disabled, with any secret values moved to your keychain (the source files aren't touched). Each server is scoped Global or to a specific repo (import sets this from where it came from), so a repo's servers only show up in that repo's sessions and the registry stays tidy. And a shared global server can be tuned per repo — set it On, Optional (available but off by default), or Off for the repo you're in, or leave it on Default to follow the global setting. (design.)

• MCP servers for Codex (container sessions). Codex agent sessions can now use your registered MCP servers too — in container isolation. (Host Codex can't approve MCP tool calls non-interactively — an upstream limitation — but a container session bypasses approvals safely because the container is the sandbox.) The composer's MCP picker now appears for Codex and tells you to switch to container isolation if you're on host; it offers local (stdio) servers (Codex's remote-MCP config can't carry the arbitrary headers our HTTP servers use). Your picks are written into the session's sandboxed Codex config — secrets stay in the OS keychain, never in the command line — and, because a container's Codex home is clean, the session sees only the servers you picked.

• MCP servers for Copilot and opencode (host sessions). Your registered MCP servers now work on GitHub Copilot and opencode host sessions too — alongside Claude on the host and Codex in a container. The composer's MCP picker appears for both (local stdio and remote HTTP servers), and your picks are handed to the CLI for that session only — secrets stay in your OS keychain, never on the command line. Both CLIs approve the servers' tools automatically, so a non-interactive run never stalls on a prompt; Copilot and opencode layer your picks onto their own config, while Claude alone runs in strict, only-these mode.

• MCP servers in container sessions, for every agent. Your registered MCP servers now work in container isolation for Claude, Copilot, and opencode too — not just Codex. Each session's picks are written into the agent's config inside the sandbox (secrets stay in your OS keychain, never on the command line), so the servers run in the container alongside the agent. A shared npm cache means an npx-based server is downloaded once and reused across turns and sessions instead of re-fetching every run. You pick servers from the composer the same way whether a session runs on the host or in a container. (Tip: a Claude server takes a few seconds to connect inside a fresh container, so the very first thing in a turn may not see it yet — it's there once the agent gets going.)

• Change a session's MCP servers mid-conversation. The composer's MCP picker now appears on an active session too, not just a new one — toggle servers on or off and the new selection applies from your next turn (and survives a reload).

• MCP servers in best-of-N runs. The composer's MCP picker now appears in best-of-N mode too — your selection is shared across every arm, so each agent attacks the task with the same tools (a fair comparison). Each arm automatically drops any server its own agent or isolation can't use.

• GitHub Pages config, in the app. A new Pages tab in repository settings: enable Pages from a branch + folder or via GitHub Actions, see the live URL and build status, change the source, set a custom domain, enforce HTTPS, and disable the site. Part of the org/repo governance buildout.

• Branch rulesets, in the app. A new Rules tab in repository settings manages GitHub's modern branch rulesets: list them, flip enforcement (Active / Evaluate / Disabled) right from the list — including the reversible "disabled" soft-off that keeps the ruleset instead of deleting it — and create or edit one with a focused editor (target branches, require a PR with approvals / code-owner review / stale-dismissal, require status checks, block force pushes, restrict deletions, require linear history, require signed commits). Editing preserves any advanced rules the editor doesn't surface, and org-level rulesets show read-only. Part of the org/repo governance buildout (docs).

• Repository danger zone, in the app. The General tab of repository settings gained a Danger zone: rename, archive / unarchive (reversible), change visibility (public / private / internal), transfer ownership, and delete the repository. The three irreversible actions (visibility, transfer, delete) are each behind a type-the-owner/repo-name confirmation that spells out the consequences first. Deleting detects when your gh sign-in lacks the delete_repo scope and shows the exact gh auth refresh command to run. Your local clone is never touched. Part of the org/repo governance buildout (docs).

• Code security & analysis toggles, in the app. A new Security tab in repository settings collects secret scanning (and its AI-detection and non-provider-pattern sub-toggles), push protection, code scanning (CodeQL default setup), Dependabot alerts and security updates, and private vulnerability reporting behind a save/discard bar — flip what you want and save once (changes apply in the right dependency order). On private repos it notes which features need GitHub Advanced Security. Dependabot version updates — which GitHub only configures through .github/dependabot.yml — gets a scaffold: pick your package ecosystems and schedule and it writes the file to your working tree for you to commit (it won't overwrite an existing one). The remaining API-less options (dependency graph, grouped security updates, self-hosted runners) appear as "Manage on GitHub" links rather than dead toggles.

• Manage repo collaborators & invitations, in the app. A new Access tab in repository settings lists your collaborators with their role, lets you invite someone by username at any level (Read / Triage / Write / Maintain / Admin), change a collaborator's role inline, and remove them — plus a pending invitations list you can re-role or cancel. (Removing someone revokes only their direct access; team/org access is managed at the org level, coming later.) Part of the org/repo governance buildout (docs/github-governance-expansion.md).

• Edit the Sponsor button, in the app. A new Sponsor tab in repository settings edits .github/FUNDING.yml — the file that powers your repo's Sponsor button — with fields for GitHub Sponsors, Patreon, Open Collective, Ko-fi, Liberapay, Buy Me a Coffee, Polar, Tidelift, and custom URLs. Saving writes .github/FUNDING.yml to your working tree — review and commit it like any other change to publish; one click removes it. (GitHub has no API for the "Sponsorships" feature toggle, but it's on by default — the file is what matters, which is why this is the right lever.)

• Manage GitHub secrets & variables, in the app. A new Secrets & variables tab in repository settings lists and edits Actions, Dependabot, and Codespaces secrets and Actions variables, at repository or environment scope. Secret values are encrypted on your machine before they're sent (GitDesktop never handles the raw encryption), and — as on GitHub — can't be read back, only replaced or removed; a reused name updates the existing variable. Part of the broader org/repo governance buildout (docs/github-governance-expansion.md).

• More GitHub repo settings, in the app. The repository-settings dialog gained a template repository toggle, default squash/merge commit message pickers, and an allow forking toggle (shown only on org-owned private repos, the one place GitHub lets it change) — plus an "Only on GitHub" list that deep-links the five settings GitHub exposes to no app (sponsor button, commenting on commits, LFS-in-archives, per-push branch/tag limit, auto-close issues on merge), so they're discoverable instead of silently missing. This is the first slice of a broader org/repo governance plan (docs/github-governance-expansion.md); the app can now also read your gh token's OAuth scopes, groundwork for features that prompt for the exact gh auth refresh -s <scope> they need.

• More of your git config, editable in the app. Settings → Git gained two controls that write straight to your global git config: line endings (core.autocrlf) — with a note on the right choice per OS — and, when a repository is open, a per-repository identity override (git config --local user.name / user.email) so you can commit as a different author in just that repo without touching your global identity. The override clears back to the global identity with one click, and both apply immediately. They join the global identity and default-branch fields already in that panel.

• Integrated terminal. Every agent session gained a built-in terminal — toggle it with the terminal hotkey (Ctrl/⌘+J) or the Terminal button — so you can run commands right inside GitDesktop instead of opening a separate window. It's a real shell (a PTY) in a resizable bottom dock that keeps running while hidden, so a dev server you start stays up. For a container session the terminal runs inside the session's Docker/Podman container — clicking Terminal opens a small popover to choose which dev-server port(s) to publish before it spins up (so a busy host port doesn't kill the launch), where you can also reconnect to or stop a container that's still running; for a host session it's a shell in the worktree.

• Run a task several ways at once (best-of-N). The Delegate composer gained a Best-of-N button: run the same task across 2–5 arms, each with its own agent, model, and effort — mix Claude, Codex, Copilot, and opencode so different providers attack the problem from different angles. Each arm runs in its own worktree; review them side by side and keep the best one with a single click (it discards the rest). Because fanning out multiple agents costs real money, a confirmation first shows an upfront estimate drawn from what your own recent sessions actually cost (scaling with the arm count), and the ensemble's running total is shown while it works. It's opt-in and never the default — best for open-ended tasks with several good approaches.

• Plan a task before you build it. A new read-only Plan mode in the Agent surface: describe a task (or start from an existing issue with the new Plan button on any issue) and a repo-aware agent explores your actual code, then drafts an agent-ready issue — problem, proposed approach, affected files, acceptance criteria, and a verify plan — without changing anything. Cited file paths are checked against your repo, so hallucinated references are flagged before you file. The planning run's cost is shown when reported. If the plan left any decisions open, they appear as an answerable panel (modeled on Claude Code's clarifying questions): pick from the suggested answers or write your own, and Refine plan continues the same planning conversation with your answers — the agent keeps its exploration in context and refines incrementally instead of starting over. A follow-up composer lets you keep chatting to revise the plan anytime, and the whole thing persists across restarts — close the app and your plans (and their conversation) are right where you left them, still resumable. (Plans are a read-only agent conversation: read tools only, no worktree, never a write.) Review it, then create a local or GitHub issue from it in one click. Plans live in the Agent sidebar alongside your sessions and run several at once — start one, switch to another, and come back; none are lost, and an OS notification tells you when each one finishes (ready, awaiting your answers, or failed) unless you're watching it. Reach it from the Agent tab's "Plan a task" mode, the command palette, or an issue's Plan button.

• Hand a plan or issue straight to an agent. A finished plan gets an Implement button that starts a write-capable session directly (a quick popover sets the agent / model / effort first); any open local or GitHub issue gets Solve with agent (it's a problem to investigate → diagnose → fix), which seeds the Delegate composer to confirm. Either way the agent works in an isolated worktree, the way every agent session does. Once a plan is being implemented it becomes a read-only reference (its row tracks the session's live status), and it archives to its own Archived tab once that session is accepted. Closes the loop from planning to a working change.
• Bring any OpenAI-compatible provider. A new "OpenAI-compatible" provider lets you point GitDesktop at any OpenAI-compatible /chat/completions endpoint with your own API key. One-click presets cover the Vercel AI Gateway (one key, many models), Google Gemini, DeepSeek, Mistral, and Z.ai — or type any base URL. Live model lists and "Test connection" work just like the built-in providers. (A custom host outside the presets must be added to the app's network allowlist.)
• Slash commands and skills in the agent composer. Type / to pick a reusable prompt or a skill. The menu pulls together built-in starters (/review, /test, /fix, /explain, /refactor, plus /clear); custom commands you define under Settings → Slash commands; and — tailored to the selected agent — its own commands and Agent Skills, discovered from both the project and your home directory, including the shared .agents/skills store (so your global skills show up too), plus a curated set of the CLI's own built-in commands (like /init). Type / to browse the whole list — it's scrollable, no narrowing needed. Commands support $ARGUMENTS (and $1, $2…) and are expanded in-app before reaching the agent; picking a skill nudges the agent to use it by name, so the CLI loads the real skill (scripts, references and all) instead of pasting it in. The menu is keyboard-driven, like @file mentions.
• opencode joins the agent line-up. You can now drive agent sessions and AI reviews with opencode alongside Claude Code, Codex, and GitHub Copilot — pick it in the agent composer or as a review provider. opencode's free hosted models need no API key, so it's a genuinely keyless option out of the box (point it at your own provider for paid models too). Sessions run on the host, confined to their throwaway worktree, and resume cleanly across turns and app restarts like the other agents.
• The window remembers where you left it. GitDesktop now reopens at the size, position, and maximized state from your last session, validated against your current monitors so an unplugged display can't strand it off-screen. Settings → About also gained a live readout of the window's current position, size, and display, with a button to copy the coordinates.
• Watch an agent session work, live. The Changes tab now reflects the worktree's uncommitted edits as the agent makes them, before each turn's checkpoint commit — so you can follow along instead of waiting for the commit to land.
• Test a session's changes before you keep them. Every active session gained an Open menu — open its worktree in your editor, a terminal, or the file manager and run it for real before you Keep or Discard. The worktree is a full checkout on the session's branch, isolated from your working tree. For a container session, whose dependencies were installed for Linux, the live shell is the integrated terminal (above) — a shell inside the same image with the worktree mounted, so pnpm install and running it happen in the matching environment rather than failing against host-incompatible deps; that's where you choose the dev-server ports to publish and reconnect to or stop a still-running container. Keeping or discarding the session shuts its test container down for you.
• Promote a kept session to a local PR. A kept agent session gained a Create PR button (and command-palette action) that opens a local pull request from its branch, prefilled and ready — a one-click hand-off from "agent finished" to review.
• See a session's pull-request and merge state on its row. Agent session and plan rows now show a pull-request audit chip — PR open, PR closed, or Merged — derived from the session branch's local and GitHub pull request, so you can tell at a glance whether the agent's work actually landed. An implemented plan reads "Implemented · Merged" once its session's PR is merged. Merge status is read from the pull request itself (not git merge-base), so it stays correct through squash and rebase merges, including a local PR you've promoted to GitHub.
• opencode runs in the container sandbox too. opencode joins Claude and Codex as a container-isolated agent (kernel-enforced filesystem confinement) — add it under Settings → AI → agent image and rebuild. Its free hosted models need no key, so the container runs keyless.
• Deeper opencode reviews. Turn on "Read repo files for context" for an opencode review and it explores surrounding files (via opencode's read-only plan agent — it can read but never write), not just the diff.
• GitHub Copilot runs in the container sandbox too. Copilot joins Claude, Codex, and opencode as a container-isolated agent — add it under Settings → AI → agent image and rebuild. Copilot has no credentials file to mount (its login lives in the OS keychain), so its container authenticates from your GitHub CLI token (gh auth token), passed securely by environment — never written to disk or visible in the container's arguments.
• Deeper Copilot reviews. "Read repo files for context" now works with Copilot too: it reads surrounding files for context while a hard deny on the write and shell tools keeps it strictly read-only, even when reviewing in your live repo.
• Global skills reach container sessions. A container-isolated agent session now mounts your global skills (~/.agents/skills) read-only, so a skill invoked by name resolves inside the container just as it does for a host session — previously only skills committed to the repo were visible there.
• AI re-reviews build on GitLab bot findings. When you re-review a GitLab merge request, GitDesktop now folds in what third-party AI reviewers (CodeRabbit, Copilot, and the like) already flagged in the MR discussion — the same "build on external reviews" context it has offered on GitHub — so the model doesn't re-report findings another tool already raised. Bitbucket has no equivalent bot-review ecosystem, so it stays out of this path.
• Provider-aware AI prompts. AI review, summary, and commit-message prompts now speak the host's vocabulary — "merge request" on GitLab and Bitbucket, "pull request" on GitHub — and use each platform's markdown flavor, and release-notes generation no longer shells out to the GitHub CLI on a GitLab or Bitbucket repository.
• Agentic PR review. When your review model is a CLI agent (Claude Code, Copilot CLI, or opencode), turn on Agentic review and GitDesktop attaches itself to the run as a read-only MCP server: the reviewer pulls the full PR diff (past the prompt's truncation budget), reads any file at any ref, runs blame and history, and reads the PR's existing comments — reporting what it explores live in the status line. It's read-only end to end (no write tools, no repo changes), and after a run whose diff outgrew the prompt budget the panel nudges you to enable agentic review or switch to a CLI agent model for full coverage. Codex reviews explore the repo natively but can't attach the GitDesktop tools.
• AI reviews are clearly machine-authored. Every AI-posted review now carries a branded GitDesktop header and footer, and AI comments on a local PR show a "GitDesktop" bot author with a robot avatar. On GitLab, add a project or group access token in Settings → Accounts and AI reviews post as the real GitLab project bot instead of your signed-in account.
• AI Generate proposes labels. The Generate button in the Create pull request dialog now also suggests labels alongside the title and description, chosen only from the repository's existing labels and added to your current selection (it never invents a label).
• Apply suggested changes locally. Apply a reviewer's suggested change to your working tree straight from the review thread on a GitHub PR — GitDesktop's local answer to GitHub's Commit suggestion, which has no public API. The edit is verified against the file first (refused if the code has drifted), keeps the file's line endings and BOM, and is staged when the file had no other local changes (otherwise applied unstaged, with a note). Disabled with a reason when the thread is outdated or a branch other than the PR's head is checked out.
• Blame and file history from any file list — not just the Changes panel. Right-click a file row in a commit's file list (in History, or a PR's Commits tab), in a pull request's Files tab, or in a Compare / local-PR file list, and you now get View file history… and Blame… — the same actions the Changes panel already had. On those surfaces Blame is pinned at that commit or branch, so you see the file as of that revision. A new Blame file… command in the palette opens a fuzzy picker of every tracked file (arrow-key navigable) and blames the one you choose.
• Clean up stale branches in bulk. A new Clean up branches… action in the branch switcher (and command palette) gathers stale local branches — merged into the default branch, or with no commits in the last 30/60/90 days — and lets you archive them (reversible) or delete them together after reviewing and trimming the list. The current branch, the default branch, and protected branches are never included.
• Collapse the Local and remote sections of the pull-request and issue lists. Click a section header to fold that section away; the header keeps a count of the hidden rows so nothing gets lost, and the choice is remembered across restarts.
• Comment on a PR's commits. A commit's detail view carries a whole-commit comment thread plus line-anchored comments on its diff — create, edit, and delete your own, applied optimistically — on GitHub, GitLab, and Bitbucket pull requests.
• Bitbucket PR reviewers who've acted now show as completed chips. On a Bitbucket pull request, participants who have approved or requested changes now appear as read-only completed-reviewer chips carrying their verdict, and drop off the pending-request list so they no longer double-render as still-pending.
• GitLab MR reviewers who've acted now show as completed chips. On a GitLab merge request, reviewers who have approved or requested changes now appear as read-only completed-reviewer chips carrying their verdict, and drop off the pending-request list so they no longer double-render as still-pending.
• See finished reviewers in the PR Reviewers section. The Reviewers rail now shows reviewers who've already reviewed as read-only chips carrying their verdict — a check for approved, an X for changes requested, a speech bubble for commented — so a completed review (including Copilot's) stays visible after the reviewer drops off the pending-request list. State is conveyed by icon shape plus the word, never color alone.
• Copy CI logs. Job logs and failed-step logs in the Actions panel, and the inline log peek on a pull request's CI checks, now carry a copy button in the log's top-right corner — grab the whole log with one click to paste into an issue, a chat, or an agent.
• Delete a remote-only branch from the switcher. Branches in the branch switcher's Remote section now have a Delete on origin… action that deletes the branch on its remote for everyone. It's a confirmed, server-side delete that can't be undone from the app, and protected branch names are blocked from it.
• Edit and delete your own comments on GitLab merge requests and issues, and on Bitbucket pull requests — including comments inside inline review threads — the same inline editor and delete confirmation that GitHub comments already had, now wired to each provider's native commands.
• Fork repos are marked in the repository lists. A repo that's a fork on its provider now shows a fork glyph beside the public/private badge in both the repo switcher and the welcome screen's Repositories list. The glyph carries a "Fork of <owner/repo>" label (or just "Fork" when the upstream isn't known), so its meaning isn't conveyed by shape alone. Like the visibility badge, it resolves in the background and clears if the remote goes away.
• Edit GitHub PR assignees. Assignee editing on an open pull request now works on GitHub too, reaching parity with GitLab merge requests — pick assignees from the same rail affordance in the PR view.
• Commit-author avatars in History. The History log, commit detail, and file-history views now show each author's avatar — derived from GitHub or Gravatar, falling back to their initials.
• Commit comments from the History tab. Open any pushed commit in History and comment on it straight away — a whole-commit thread plus line-anchored comments (click or drag line numbers to anchor them) — on GitHub, GitLab, and Bitbucket. An unpushed commit shows a push hint, and local-only repos are unchanged.
• Agentic review now works with API review models. Beyond the CLI agents, turning on Agentic review with an HTTP/API model (Anthropic, OpenAI, OpenAI-compatible, OpenRouter, or Ollama) gives it a native read-only tool loop: it pulls the full PR diff past the prompt budget, reads any file at any ref, searches the repo, and runs history — reporting what it explores live in the status line. There's no review workspace to prepare, so these reviews start instantly, and it's read-only end to end. Each tool step is an extra model call (slower and pricier), and small local models that can't do tool calling fail with a clear message to turn agentic off or pick another model.
• Inline review comments. Line-anchored review comments — from Copilot, CodeRabbit, or humans — on GitHub PRs, GitLab MRs, and Bitbucket PRs now render in the app: grouped by file in the Conversation tab and anchored at their exact line in the Files diff (unified or split), with reply-in-thread and resolve/unresolve. GitHub threads show the anchored code excerpt they were left on, reviewer suggestions render as labeled change diffs, and any thread can be copied as Markdown (line range, excerpt, and every reply). Resolved threads collapse behind a per-file expander, and outdated ones are flagged. Previously they were invisible (GitHub) or shown as context-free flat comments (GitLab/Bitbucket).
• Jira issues now show agile fields — story points (in the list and the detail), sprint, a clickable epic / parent, components, and fix versions — discovered automatically per site, with nothing to configure.
• Jira issue writes. Create, comment on, close/reopen (following the project's own workflow, with the real resulting status named in the confirmation), and assign Jira issues right from the Issues tab of a linked Jira Cloud project. Each action is gated on your Jira permissions — anything your token and role can't do stays hidden.
• Linked Jira Cloud projects. Connect a Jira site and project to any repository and browse its issues (status, type, priority, assignee, labels, Markdown description, and comments) from the Issues tab, with View-in-Jira link-outs. Bitbucket repos get a one-click path, since Bitbucket's native issue tracker retires 2026-08-20. Read-only for now; connect with an Atlassian API token (or reuse an existing Bitbucket credential).
• Jira issue links, promote-to-Jira, and agent access. The linked project's issue keys (e.g. PROJ-123) are now spotted in the current branch name, a commit's message, and a PR's title/description, and surfaced as a compact "referenced Jira issues" row that jumps to the issue in the Issues tab. A local issue can be promoted to Jira (alongside GitHub or GitLab when both are available) — its comments carry over and the local one closes with a back-link. And agents connected through GitDesktop's MCP server get jira_* tools to list and read the linked project's issues, plus comment, close/reopen, create, and assign behind the --allow-remote-write opt-in. The status chip in the Jira issue view is now also a menu (when your permissions allow transitions) for moving an issue to any of its workflow's available statuses, alongside the existing close/reopen quick action.
• Edit more of a Jira issue. Set or clear a due date, change the priority, edit the labels, and edit or delete your own comments — all from the Issues tab of a linked Jira Cloud project, and each control gated on your Jira permissions so anything your token and role can't do stays hidden. Agents reach the same edits through the MCP server's new update_jira_issue tool (due date, priority, labels) under the --allow-remote-write opt-in.
• Jira time tracking. On a linked Jira Cloud project that has time tracking enabled, the issue view now shows the original estimate, remaining, and time spent with a progress bar. Log work with Jira's duration grammar (2d 4h 30m) and an optional note, set or clear the original and remaining estimates, and edit or delete your own worklog entries — the full history is a "View all in Jira" link away. Agents get a jira_log_work MCP tool and original/remaining-estimate parameters on update_jira_issue, both behind --allow-remote-write.
• Resolve local-PR merge conflicts without touching your working tree. When a local pull-request merge hits conflicts, GitDesktop now runs the merge in an isolated, hidden worktree — your branch and working tree stay exactly as they were, so you never need a clean tree (unless you're merging into the branch you're currently on). The PR view opens a dedicated resolve surface with the conflicted files and the in-app conflict editor (per-region accept + AI resolution), then Finish merge (commit + mark the PR merged) or Abort (throw the merge away). The PR also pre-shows whether a merge will conflict before you start.
• Local PR activity feed. A local PR's Conversation is now a date-sorted activity feed too: it opens with a created marker, interleaves the branch's pushed commits (grouped, each short SHA clickable to that commit's detail) with your comments, and ends with a merged or closed marker once the PR reaches that state.
• GitHub Discussions tools for GitDesktop's MCP server. When run as an MCP server against a GitHub repo, an agent can now browse discussions: list categories, list discussions, and read a full thread with its nested replies (always-on reads). With --allow-remote-write it can also create a discussion in a category, comment on one, mark/unmark a reply as the answer, and close or reopen a discussion — under your authenticated gh identity, with a Posted by GitDesktop footer on posted comments. Discussions are a GitHub feature, so these tools return an actionable error on a GitLab or Bitbucket remote.
• Full PR/issue forge-write surface for GitDesktop's MCP server. The --allow-remote-write tools now go well beyond commenting: an agent can create, merge, update, and close/reopen a pull request, toggle its draft state, request reviewers, edit labels, set assignees (on issues and PRs), approve or withdraw approval, reply to and resolve review threads, rerun/cancel/dispatch CI, and create or update releases — all under your authenticated forge identity (GitHub gh, GitLab glab, or a stored Bitbucket token). New read tools round it out: list labels, milestones, and releases, get a release, list assignable users, and fetch a PR's full timeline. It stays gated behind the same --allow-remote-write opt-in, off by default.
• AI generation recipes over MCP. GitDesktop's MCP server exposes three ungated generate_commit_message, generate_pr_description, and generate_branch_name tools that hand a connected agent the same fully assembled context and prompt the in-app AI features build — the staged or branch diff with GitDesktop's low-value-file budgeting, recent commit subjects as a style reference, your repo and global instructions, and .aiignore filtering. The tools don't call a model themselves; the agent completes the returned prompt with its own inference, so you can trigger GitDesktop's generation from any MCP client.
• Local-git write tools for GitDesktop's MCP server. Run as an MCP server, GitDesktop can now let a connected agent mutate the bound repo's working tree, index, and refs — stage/unstage, commit (and undo the last commit), create/checkout/rename branches, push/pull/fetch, stash push/pop/apply, merge, rebase, revert, cherry-pick, and tags — behind a new --allow-git-write flag. A further --allow-destructive flag (required on top of --allow-git-write) unlocks the irreversible operations: delete branch, discard changes, reset, force-push (with lease), delete a remote branch, drop a stash, and delete a tag. Two new read tools — list stashes and preview a merge's outcome — stay ungated. Both flags are off by default, and agent-session branches (gd/session/*) are refused by the branch-mutating tools so an in-flight agent session can never be broken.
• See and manage your global MCP install per client. In Settings → MCP servers → Use GitDesktop as an MCP server, the Install globally section now shows a live row for Claude Code and Copilot: whether GitDesktop is installed in that client's user config, and whether it points at the current launcher or an older install (with a one-click Reinstall to switch it over). Each installed client gets a Remove button that takes the entry back out via the client's own CLI.
• One-click global MCP install (Claude Code / Copilot). Use GitDesktop as an MCP server (Settings → MCP servers) can now install gitdesktop into a client's global user config — available in every project, no per-repo .mcp.json — alongside the existing project .mcp.json write. Claude Code and Copilot each get a one-click button that runs the client's own CLI (claude mcp add-json … -s user / copilot mcp add …), using a project-aware --repo so the single global entry follows whatever repo the client opens. The read-only/local-write/remote-write toggles carry over, and an existing entry is replaced only after you confirm.
• See which permission tier your global MCP install runs. In Settings → MCP servers → Use GitDesktop as an MCP server, each Install globally row (Claude Code / Copilot) now reads out the installed entry's permission tier — e.g. Installed (local + remote writes), or Installed (read-only). When the installed permissions no longer match the checkboxes you've selected, the row switches to a warning and offers Reinstall to apply them, so a stale global entry can't keep running old flags unnoticed.
• MCP: fetch a CI job's full log. GitDesktop's built-in MCP server gains a workflow_job_logs tool that returns a single CI job's complete log by job id (from a run's jobs[].id) — the whole job's output, not just its failed steps — so an agent can drill from a run's jobs into any one job's logs (GitHub Actions and GitLab CI).
• Local-issue tools for GitDesktop's MCP server. Alongside the existing local-PR tools, the --allow-write opt-in now also lets a connected agent create a local issue, comment on one, and set its status — GitDesktop's own app-data issue records for the bound repo, nothing pushed to a forge. New ungated read tools list and get local issues (and list/get local PRs), so an agent can read the app's local review artifacts without any write opt-in.
• One-click "add gitdesktop to PATH." Use GitDesktop as an MCP server (Settings → MCP servers) now has a Command-line launcher with an Add to PATH button, so the bare gitdesktop mcp … command resolves in any terminal without a hardcoded path or GITDESKTOP_BIN. It appends the app to your user PATH on Windows (no admin — open a new terminal afterward) or symlinks gitdesktop into ~/.local/bin on macOS/Linux, shows whether it's already on your PATH, and Remove reverses exactly what it added.
• AI generation recipes are now also MCP prompts. GitDesktop's MCP server exposes its commit-message, PR-description, and branch-name generation recipes as native MCP prompts (commit-message, pr-description, branch-name) — the slash-command-like primitive many clients surface — alongside the existing recipe tools. Each assembles the same fully prepared context and prompt the in-app AI feature builds and hands it to the client's own model to complete. The prompts are read-only and always available, with no opt-in flag.
• Cross-forge PR/issue/CI tools for GitDesktop's MCP server. When run as an MCP server, GitDesktop's pull-request, issue, and CI tools now work across GitHub, GitLab, and Bitbucket — routed through the forge abstraction, they dispatch by the repo's remote (Bitbucket covers PRs and pipelines; Bitbucket issues come later via Jira). And a new set of remote-write tools can create and comment on issues, close/reopen them, and comment on pull requests, gated behind a separate --allow-remote-write flag. These make real writes to the repo's forge under your authenticated identity (GitHub gh, GitLab glab, or a stored Bitbucket token), and are kept distinct from the local-PR --allow-write tools: enabling one never grants the other, and read-only remains the default. PR comments an agent posts carry a Posted by GitDesktop attribution footer, and a read tool returns a pull request's full comment set — the conversation, review summaries, and file:line review threads — so an agent can read a review before replying to it.
• More forge-write tools for GitDesktop's MCP server. The --allow-remote-write surface now lets an agent start a new file:line review thread on a pull request (not just reply to an existing one), request changes or withdraw a change request, edit an issue's title/body and set its milestone, and add or remove reactions on an issue or pull request (or one of its comments) — all under your authenticated forge identity (GitHub gh, GitLab glab, or a stored Bitbucket token), and still gated behind the same --allow-remote-write opt-in, off by default.
• Write GitDesktop's MCP config straight into .mcp.json. The Use GitDesktop as an MCP server panel now writes (and merges) its gitdesktop entry into your repo's .mcp.json for you, preserving any other servers — no more copy-paste. A Shareable entry toggle switches between machine-specific absolute paths and portable ${GITDESKTOP_BIN} / ${CLAUDE_PROJECT_DIR} paths a teammate can commit, and an Allow write tools toggle adds --allow-write so agents can create, comment on, approve, and set the status of this repo's local PRs — kept off by default, leaving the server read-only.
• MCP server write tiers as checkboxes. The Use GitDesktop as an MCP server panel now has toggles for all four write tiers — Allow write tools, Allow remote write, Allow git writes (--allow-git-write, recoverable repo mutations: stage/commit, branches, push/pull, stash, merge/rebase, tags), and Allow destructive git writes (--allow-destructive, only enabled once git writes are on: discard, reset, force-push, force deletions). Each toggle threads its flag into the copyable snippet, the Write to .mcp.json action, and both global installs, so you no longer hand-edit the config to grant a tier.
• Multi-line comment ranges. Drag across a range of lines in a diff and the comment now lands as a true multi-line anchor on GitHub and GitLab — across one-off review comments, pending-review drafts, and GitLab commit comments — and clicking the + on any line of the drag reopens the same range. Where a provider's API is single-line only (Bitbucket comments, and GitHub/Bitbucket commit comments), the composer says so and anchors at the last line rather than silently collapsing the range.
• Activity & notifications inbox. The header activity control is now a persistent bell: alongside in-progress work (AI reviews, with Cancel) it keeps a history of terminal events — a finished review, checks passing/failing, a PR approved / changes-requested / commented / merged, a review requested from you, a completed CI run, or a finished agent, research, or plan run. Each entry click-navigates to its source, unread items carry a badge, and the list survives an app restart, so a review that finishes while you're away is never a missed click. Open it with the command palette (Activity & notifications), clear items or mark all read, and arrow-key through the list. Which events appear follows your Settings → Notifications choices. (New-comment / new-review / review-requested detection is GitHub-only for now.)
• Operation journal & interrupted-op recovery. GitDesktop now records the risky compound operations it runs — local PR merges, cherry-picks, history edits, and interactive rebases — each with the exact branch and commit it started from. If one is interrupted by a crash or restart, a calm recovery notice appears above the Changes list naming what was interrupted and the state it began from; it only informs (the git-native Continue/Abort stay in the conflict bar). Browse the full log any time via the Operation history command or the branch ⋮ menu.
• PR activity feed. A pull request's Conversation is now a single date-sorted activity feed that interleaves reviews, comments, pushed commits, and events — on GitHub, GitLab MRs, and Bitbucket PRs alike. A run of pushes collapses into a "pushed N commits" row that expands to the commits, and each commit's short SHA is clickable — it jumps to that commit's detail. GitHub shows the full event set (force-push, label add/remove, review request, ready-for-review, convert-to-draft, close, reopen, merge, rename); GitLab MRs add label add/remove, close/reopen/merge, and approval events (approved / changes-requested / approval-withdrawn), with no force-push or draft events; Bitbucket PRs add merge/close and approved / changes-requested, with no labels or review-requests. An approval or changes-request that predates a later push is flagged stale · N commits since.
• CI checks rollup with inline logs. A pull request's checks now fold into a rollup summary — ✓ passed · ✕ failed · ● pending, each count with its own icon and word — that auto-expands whenever something failed and lists the checks failures-first. This now covers GitHub PRs, GitLab MRs (from the MR's pipeline jobs), and Bitbucket PRs (from the PR head commit's build statuses). A failing GitHub Actions or GitLab pipeline job peeks its job log inline, without leaving the PR, with an "Open full run" link; external checks and Bitbucket build statuses (which expose no fetchable logs) link straight out.
• PR commit detail. The Commits tab of a pull request is now navigable — arrow through the rows and open any commit for its own detail view. A remote commit shows its full message body and per-file diffs with a copy-SHA control; a local PR's commit opens the full history commit detail. Works on GitHub, GitLab, and Bitbucket PRs.
• Labels & assignees when creating a PR/MR. The Create pull request dialog now has Labels and Assignees pickers for GitHub and GitLab — set them up front instead of after the PR/MR is open. (Bitbucket PRs have no labels or assignees, so it still shows only its reviewers picker.)
• AI Generate when editing a PR/MR. The Edit dialog now offers the same Generate button as the create flow, so you can write or regenerate an existing pull request's (or merge request's) title and description with AI — including for PRs from forks, whose head branch isn't checked out locally.
• Request reviewers on GitHub and GitLab pull/merge requests. The reviewers picker — previously Bitbucket-only — now works on GitHub and GitLab too: request a review from a collaborator (GitHub) or project member (GitLab) right from the PR/MR view, and see who's currently requested, each shown with their avatar. (GitLab's free tier keeps only one reviewer per merge request; if it drops the rest, GitDesktop tells you rather than reporting a silent success.)
• Promote a worktree branch to your main workspace. From the Worktrees dialog (or the command palette), bring the branch you've been working on in a linked worktree into your main checkout in one step — it frees the branch, stashes any uncommitted work in the main workspace so the checkout can't be blocked, and checks the branch out there. The branch switcher also lets you jump straight to the main workspace (or any other worktree) instead of routing through a checked-out branch, and reminds you when a checkout will land in a linked worktree rather than the main one.
• Rebase a branch onto a different base. A new Change base… action in the branch switcher (and command palette) fixes the "I branched off the wrong branch" case: pick the branch you meant to base on plus the one you actually based on, and GitDesktop replays only your branch's own commits onto the new base — leaving the wrong base's commits behind. A moving-commits preview shows exactly what will move before you run it, guards against a dirty tree, warns when the branch is already pushed, and routes any conflicts into the usual resolve flow.
• Recover lost work — restore orphaned stashes without the CLI. A new Recover lost work… action (in the branch ⋮ menu and the command palette) opens a Recoverable tab in the stashes dialog that scans your repository with git fsck for orphaned/dangling stashes — uncommitted work a git stash saved but that has since fallen out of git stash list (dropped, or abandoned by an interrupted operation). Preview each one's files and diff, then Restore to working tree re-applies it non-destructively (it applies the stash, never dropping or committing), so you can recover work you thought was gone.
• Remove a worktree from the branch menu. A branch that's checked out in another worktree now has a Remove worktree… action in its right-click menu in the branch switcher, so you don't have to open the worktree manager to free it. The branch stays, and its Delete… action un-disables once the worktree is gone.
• The Rename branch dialog can now suggest a name from your in-progress changes with AI — the same ✧ Generate from changes action the New branch dialog has.
• Repo switcher and welcome list rows now show identity badges at a glance: a GitHub, GitLab, or Bitbucket logo for the forge the repo lives on (a cloud icon for a remote on an unrecognized host, a folder for a local-only repo), and a trailing lock (private), buildings (internal), or globe (public) for its visibility.
• Compose a review, line by line. Click a line number (or drag across a range) in a pull request's Files diff to open an inline composer: post a single comment right away, or Start a review to batch drafts — which persist to disk per PR and survive a restart. Pending drafts show at their anchors with edit and delete, a bar tracks the count, and Submit review… posts the whole batch with a verdict (Comment, Approve, or Request changes — offered where the provider allows, and Request changes needs a summary). The composer can also insert a provider-correct suggestion block pre-filled with the selected code, and reviewer suggestions now apply to your working tree on GitLab and Bitbucket too, not just GitHub.
• Update a branch from its own upstream without switching to it. When a branch is behind the remote it tracks, its right-click menu in the branch switcher now offers Update from origin/… — fast-forwarding it (or merging in place if it's the current branch) without leaving the branch you're on. Made for the "just merged a PR, bring the default branch current before I switch back" flow: the default branch's row shows how far behind its upstream it is after a fetch, and Update default branch from its remote is available from the command palette.
• Update a fork from its upstream. When a repo has an upstream remote, the Pull menu (and the command palette) gain Update from upstream: it fetches upstream, resolves its default branch, and brings your current branch up to date — fast-forwarding silently when it can, creating a merge commit when the histories have cleanly diverged, and routing conflicts to the usual conflict editor. It never pushes for you; the Push button lights up on its own once you're ahead.

Changed

• One unified "Publish repository…" control. The sync bar and the hosted-feature empty states (Pull Requests, Issues, Discussions, Actions) now share a single publish affordance: a plain button when one provider can publish a local-only repo, or a menu to pick between GitHub, GitLab, and Bitbucket when more than one is ready — no more stacked per-provider buttons. In those empty states, publishing now takes precedence over the GitHub CLI setup steps whenever another provider can already publish the repo.
• Empty states now teach their surface and offer the next action. Compare's detached-HEAD and no-other-branches states explain what's needed and offer Switch branch / New branch; Actions' empty runs list explains where runs come from (provider-aware) with a Run workflow/pipeline button, and its branch-scoped empty offers Show all branches; History's filtered no-match adds a Clear filter button; and the Tags, PR Tasks, and Discussions empty states got clearer, more helpful copy.
• Automations redesigned around a lifecycle grid. Automations (Settings → Automations, and per-repo from a repository's ⋯ menu) are now grouped by moment — On commit, On pull request opened, and On new commits to a reviewed PR — with AI code review and security audit as toggles under each, so duplicate or conflicting rules are no longer possible. Each enabled action can be scoped with branch conditions (include/exclude globs, plus a Source / Target / Either match for PR events) and a "Try a branch" preview. Both the global and per-repo surfaces now edit behind Save / Discard rather than saving on every toggle, and the per-repo dialog shows the effective settings, badges overridden cells, can enable an action that's globally off, and offers "Reset to global defaults". Your existing automations are migrated automatically on first launch, with any duplicate rules merged and noted once.
• Faster startup. The app now boots from a much smaller core bundle — agent sessions, diff rendering, the git-hooks editor, and the AI provider SDKs each load on first use instead of on launch.
• Codex model suggestions. The model picker for the Codex (CLI) provider — in AI review, agent sessions, and plans — now suggests real model ids (gpt-5.5, gpt-5.4-mini) instead of showing an empty list. Pick one, type your own, or leave it blank to keep using your Codex account's default (still the default when you switch to Codex, since the right model depends on your plan).
• Collaborator and member avatars in Repository Settings now use the standard avatar component, showing a letter fallback when a user has no picture instead of a blank circle.
• Copying a PR review's markdown now includes its file-anchored review threads — the diff excerpt, every comment, and any suggested changes — so AI and bot reviews (Copilot, CodeRabbit) paste complete instead of losing their findings.
• Syntax highlighting holds up in large files. Diffs keep their syntax colors much further into big files — an edit deep in a long file (past ~2,000 lines) no longer silently drops all highlighting, and the size limit before a diff falls back to plain text is now tuned per highlighter (400 KB for highlight.js, 150 KB for Shiki languages like Rust and TSX, up from a flat 100 KB).
• Calmer error toasts. Long git and forge errors now show a single humanized summary line with a Details action that opens a dialog with the full, selectable text and a Copy button; short errors are unchanged and keep their Copy action.
• Forge views feel snappier. Repeated origin-remote lookups from the many forge queries a pull-request or merge-request view fires are now served from a short-lived in-memory cache instead of re-shelling out to git each time — noticeably fewer process spawns on Windows.
• Provider avatars for assignees and authors. The assignee picker now shows each user's photo (like the reviewers picker), and author avatars on pull/merge requests, issues, and comments now use the person's real GitLab or Bitbucket profile photo instead of falling back to their initial. (GitHub already showed avatars, derived from the username.)
• The History tab stays smooth with thousands of loaded commits — rows now render only as they scroll into view.
• The Jira issue view now puts type, assignee, reporter, dates, agile fields, labels, and time tracking in a right-hand side panel like the GitHub and GitLab issue views, so the header stays compact and the description and comments get the freed space.
• The MCP list_pull_request_comments tool now caps each review thread's diff hunk to its last few lines, so a comment on a brand-new file no longer drags the whole file into the response. Pass include_diff_hunk: false to drop the hunks entirely when you only need the threads' structure.
• MCP approve_pull_request and request_changes now work on GitHub. Both forge write tools previously dead-ended on GitHub repos with a "goes through the Review menu" error; they now route the GitHub arm through gh pr review, so approving and requesting changes on a PR work across GitHub, GitLab, and Bitbucket. (GitHub's request_changes requires a non-empty body; the error surfaces if it's omitted, and withdrawing a requested-changes review stays unsupported on GitHub, as gh can't do it.)
• MCP: cap or widen PR/issue lists. The MCP server's list_pull_requests and list_issues tools take an optional limit — omit it for the provider's default page (GitHub ~30; GitLab and Bitbucket a full page), or pass one to raise or lower how many an agent pulls back in a call.
• MCP create_pull_request now requires --allow-git-write in addition to --allow-remote-write. Opening a pull request pushes the head branch to origin first — a local-git write — so it now correctly demands the git-write tier as well, honoring the rule that enabling one capability tier never grants another.
• MCP: PR/issue text is flagged as untrusted to connected agents. The built-in MCP server's read tools that return third-party prose — list_pull_requests, get_pull_request, list_pull_request_comments, list_issues, and get_issue — now prepend a note marking the titles, bodies, and comments as data to analyze, never as instructions to follow, so an agent pulling a PR's comments in is less exposed to prompt injection from an attacker-authored comment. Defense-in-depth: forge writes remain gated behind --allow-remote-write.
• Snappier UI after issue, pull-request, and Jira actions: closing, editing, commenting, and changing labels/priority/due-date now refresh just the item you touched instead of refetching the whole repository's data.
• Notifications now always show which repository they're for and, for new-pull-request notifications, the author with their avatar; the Activity & notifications panel is slightly wider to fit.
• Research → Plan → Implement handoffs now carry forward what the prior stage already examined (files, searches, web sources), so the next agent starts from that grounding instead of re-exploring from zero.
• Create-PR branch picker. The branch dropdown now widens to fit the longest branch name (up to a limit) instead of clipping to the field width, and each option shows a chip when that branch is checked out in another worktree or is archived.
• Pull request rows now show when each PR was opened, matching the issue list — #12 · author · 3 hours ago · head → base. Local pull request rows show their age too. Each row also gains a small CI indicator a moment after the list loads — on GitHub and GitLab, and on Bitbucket wherever a PR reports build statuses: a check for passing, a cross for failing, and a clock for checks still running (rows with no checks show none). Each icon has a distinct shape and a hover label, so the signal never relies on color alone.
• Archived branches no longer clutter the create-PR branch pickers. When opening a pull request (GitHub/GitLab or a local PR), the base and compare dropdowns now hide branches you've archived, matching the branch switcher. A branch that's still a seeded default (your current branch, say) stays selectable even when archived.
• Local-PR record actions moved off the footer. A local PR's footer is now just the merge decision; Archive / Unarchive and Delete moved to a right-click menu on the PR's list row (Delete still confirms, and never touches the branches). Both are also in the command palette as Archive pull request and Delete pull request, acting on the selected local PR.
• AI review factors in its own prior comments. When you re-review a pull request, the AI review now reads the comments GitDesktop has already posted on it — past reviews and any agent follow-ups (a refutation, or a "fixed in <sha>" reply) — and treats a finding it already resolved or refuted as settled instead of raising it cold again, unless the current diff still shows the problem. Works on GitHub PRs and GitLab MRs (remote PRs only).
• Smoother rendering across major surfaces — the changes list, staging diff, settings, sync controls, conflict view, and history editor were silently opted out of React Compiler optimization; they now compile and re-render less.
• AI-generated repo descriptions are less terse. The Generate button for a repository's About description now aims for a fuller single line (roughly 200–325 characters) that says what the project does and what makes it stand out, instead of the old ~140-character cap that often produced a thin one-liner. GitHub's About field already accepts up to 350 characters, so the result still fits. Long READMEs are now condensed to keep their features and highlights breadth — dropping install and development boilerplate — instead of being blindly cut off at 6,000 characters, so the model sees what the project actually does rather than just its opening.
• Repository settings: friendlier Description and Topics fields. In Settings → General, the Description is now a multi-line box so a long "About" wraps instead of clipping mid-word (GitHub and GitLab; Bitbucket already did). Topics are now removable chips with an inline add-box: type a topic and press Enter or comma to add it. On GitHub, each token is normalized to a valid topic as you add it and the chip shows exactly what will be saved — so C++ becomes c and React_Native becomes react-native, and pasted or space-separated text lands as clean chips instead of being silently mangled on save; the field caps at 20 with a live count. On GitLab, topics keep their case and spaces, so "React Native" stays one topic. Chips are fully keyboard-navigable — arrow between them, remove the focused one with Enter or its ✕, and Backspace in an empty add-box removes the last one.
• "Turn into a Plan" now distills the research session into a clean plan brief (via one extra turn that forks the conversation, so it never disturbs the research session itself) instead of handing the plan the raw multi-turn transcript — with automatic fallback to the full report if distillation fails or is cancelled. Distillation is currently available for Claude; other agents fall back to the full report.
• AI code review now has to trace its data-flow claims: a statement like "X arrives as parameter Y, sliced to N" must point at a real call site or be left out — fewer fabricated parameter and slicing claims in review findings.
• AI PR reviews verify before flagging. The review now checks the typed contract before reporting a possible null/undefined issue — a field the types declare non-optional (or that every code path visibly sets) is no longer flagged — and it omits a finding relayed from another AI reviewer when it cannot verify that finding against the diff, rather than passing it along with a "could not verify" hedge.
• Review comments read in context. On a GitHub PR, each review's line comments now appear inline under that review in the Conversation timeline (grouped by file), instead of being pooled in one block at the bottom — so you follow a review right where it lands. Standalone line comments, and every thread on GitLab and Bitbucket (which don't tie comments to a review), still gather in a by-file block below, retitled Other line comments when some already appear inline above. Reply, resolve, apply-suggestion, and keyboard navigation work the same in both places.
• Repo-aware AI review starts faster: the PR head is no longer pre-fetched when its objects are already present locally.
• The app starts leaner: diff syntax-highlighting grammars and the session terminal now load on first use instead of at startup, and markdown code blocks highlight all languages — the rarer ones load their highlighter on first use.
• Dialogs are a little wider by default, and long branch names now wrap instead of overflowing — applied once in the shared dialog component, so every dialog (create/rename branch, the merge/rebase picker, and the rest) benefits.

Fixed

• Deleting a worktree with installed dependencies now works on Windows. Removing an agent-session (or manually created) worktree that had node_modules installed — where pnpm links packages through junctions/symlinks — used to fail with "failed to delete '…': Invalid argument", leaving the worktree half-removed. GitDesktop now finishes the removal itself (correctly deleting those links) when git's own delete trips on the reparse points, and if a file is still locked by another program it says so plainly instead of showing git's cryptic error.
• Checking out a remote-only branch that lives on more than one remote now works. Clicking a remote branch in the branch switcher used to fail with "matched multiple remote tracking branches" when the same branch name existed on two or more remotes. The switcher now creates the local branch tracking exactly the remote shown on that row, so the checkout matches what the row promised.
• Windows local-path repositories are no longer mislabeled with a bogus owner or host. A repository whose origin points at a local path (e.g. C:\path\to\repo) was misread as a hosted remote, tagging it with a nonsensical owner and host. Local-path remotes are now recognized as having neither.
• The review-model picker no longer changes your global default. Switching the provider or model in a pull request's Review panel now applies to that review only — it no longer overwrites the default review model in Settings → AI. The panel shows a small note while a one-off model is in effect, and resets to your default for the next PR.
• Windows: tools added to PATH after the app started are now found without a restart. Windows never pushes a PATH change into an already-running program, so a CLI you installed (or added to PATH) while GitDesktop was open — glab, gh, or an agent CLI — used to read "Not found" in Settings → About until you fully relaunched the app. The resolver now also reads your live user and system PATH straight from the registry, so detection (and the Re-check button) picks up a freshly-installed tool immediately.

• Host GitHub Copilot sessions no longer fail with "batch file arguments are invalid" on Windows. When the VS Code Copilot extension is installed, it puts a copilot.bat wrapper on your PATH ahead of the real copilot.exe — and Windows won't let an app pass a multi-line prompt to a batch file. GitDesktop now prefers a real .exe over a .cmd/.bat shim found earlier on PATH when locating any agent CLI, so it launches the actual Copilot binary. (CLIs that ship only a .cmd, like Codex, are unaffected.)

• Codex agent sessions no longer show a blank "No response." Codex delivers its whole reply at the end of a turn (it doesn't stream it incrementally like the other CLIs), and the session view was discarding that final message — so every Codex turn looked empty. The message is now displayed.

• A finished plan or agent run on a background tab now notifies you. The OS notification for a completed plan/session was suppressed whenever the window was focused and that run was selected — but since plans and sessions live on the Agent tab, a focused user reading another tab (Changes, Pull Requests, …) was wrongly treated as "watching it" and got nothing. The notification now only stays quiet when the Agent tab is the one actually on screen. A plan that finishes with clarifying questions — a blocking handoff that idles until you answer — now always notifies, even while you're looking right at it.

• The "default branch for new repositories" setting now updates git itself. Settings → Git's default-branch field used to be a GitDesktop-only preference: it changed what the app's Create repository dialog did, but never touched your global git config — so git config --global init.defaultBranch (and a command-line git init) still used the old branch. The setting now reads from and writes to your global git config (init.defaultBranch), with its own Save, the same as the Git identity field beside it — so GitDesktop and the command line finally agree.
• Container agent sessions now actually run the agent. A container-isolated session was launching node instead of the agent CLI inside the container (the CLI name wasn't passed as the command), so Claude/Codex/opencode sessions failed to start in container mode. They now run correctly. (Host sessions were unaffected.)
• AI reviews now show why they failed. A failed PR/local review used to revert silently to the empty "Run a review…" placeholder with no explanation; it now displays the actual error (and keeps any partial output that streamed first). CLI-agent failures also no longer surface as a useless [object Object].
• The co-author picker is fully keyboard-navigable. When adding a commit co-author, ↑/↓ now move through the suggestions and Enter adds the highlighted one (it's a proper combobox), instead of only being able to add the top match or reach for the mouse.
• A couple of dead-ends now explain themselves. The repository Insights error no longer prints a raw error string, and the Actions toolbar's "Run workflow" and refresh buttons, when disabled, now say they need a GitHub CLI sign-in instead of greying out silently.
• Stopping or timing out an agent session now terminates the CLI's entire process tree, so helper processes (language workers, MCP servers, tool subprocesses) can no longer keep running in the background — previously on Windows only the top-level CLI was killed, leaving its children consuming tokens and holding worktree file handles.
• A cancelled automated PR review no longer re-runs after a restart. Cancelling an automatic re-review of new commits on a pull request now remembers that commit, so it isn't reviewed again when you relaunch the app. A genuinely new commit still triggers a review as before.
• Automations no longer fire twice when two app instances (for example a main checkout and a linked worktree) watch the same repository — a run is now claimed atomically across processes before any AI work, so only one instance posts the review.
• Concurrent automation-settings saves no longer overwrite each other — the global defaults and a repository's overrides are each re-derived from fresh state when saved, so two overlapping saves can't drop one another's change.
• Review threads on busy pull requests no longer disappear: Bitbucket comment pages and GitHub review-thread pages are now followed across multiple pages, instead of stopping at the first 100 and silently dropping the rest.
• Blaming a very large file no longer freezes the app — the blame view now virtualizes its rows and syntax-highlights only the lines currently on screen, instead of rendering and highlighting every line at once.
• Bot authors like dependabot, renovate, and github-actions now show their real avatars in PR, issue, and timeline surfaces and in History, instead of falling back to an initial — GitHub serves no login-derived avatar for bot accounts, so GitDesktop now resolves them through the GitHub API once and caches the result.
• A branch whose remote was deleted now offers "Publish branch." After a PR merge deletes the remote branch, the sync bar no longer shows stale Push/Pull against the dead ref — it shows Publish branch, which recreates the remote branch on push. Undo-commit is available again on such a branch, and amending its tip no longer wrongly demands a force-push.
• Cherry-picking commits onto another branch no longer risks uncommitted work. Cherry-picking onto the branch you're currently on could, if it hit a conflict, discard your uncommitted changes during rollback — it now refuses up front on a dirty working tree with a clear "commit or stash your changes first" message. (Untracked files are still fine.)
• Repository Access settings no longer offer the Triage, Maintain, or Admin collaborator roles on a personal (user-owned) repository. GitHub silently keeps collaborators at Write there — picking a higher role returned success but never applied — so the picker now shows Read and Write only (organization repos keep the full set), with a short note explaining why.
• Switching to the Compare tab no longer clears the commit selected in History — each tab now keeps its own selection.
• A requested Copilot review now shows in a pull request's Reviewers. A pending GitHub Copilot (or other bot) review request is displayed as a read-only chip in the PR Reviewers section instead of being invisible. The chip is display-only — the reviewer picker never adds or removes a bot, so managing human reviewers can't drop a pending Copilot request.
• Large file diffs no longer flash or re-render while loading. The diff now waits for its syntax-highlighting inputs (the whole-file context reads and any lazily-loaded language grammar) to settle and paints once, instead of showing a brief hunk-only pass that restructured a moment later.
• On a fork, the Actions tab now shows your fork's workflow runs, not the upstream repository's. When a fork has an upstream remote, GitHub's CLI would resolve the parent repository, so the Actions list, run details/logs, re-run/cancel, "Run workflow" dispatch, and the run notifications could all target the original repo. Every Actions operation is now pinned to your origin remote. Single-remote repositories are unaffected.
• On a fork with an upstream remote, repo administration now always targets your fork (the origin remote) rather than the upstream parent. This covers repo settings, webhooks, Pages, collaborators & invitations, insights, code security, rulesets, secrets & variables, generated release notes, branch- protection import, and — most importantly — repository rename, transfer, and delete.
• The GitLab auto-merge status poll now pauses while the Pulls tab is hidden, instead of quietly polling the server every 8–30 seconds in the background. Switching back to the Pulls tab refreshes it immediately.
• Long branch names no longer overflow the repository header. A very long current-branch name used to push the header wider than the window, adding horizontal (and cascaded vertical) scrollbars and hiding the sync controls. The branch name now truncates with an ellipsis — hover it to see the full name — while the icons, detached badge, and Fetch/Pull/Publish controls stay fully visible. The truncation order is deliberate: the branch name gives way first, then the CI badge's workflow label, and the repository name last.
• Long repository names no longer overflow the header. A repository name or alias longer than the trigger's width used to paint past its box over neighboring controls. It now truncates cleanly with an ellipsis — hover it to see the full name — and at narrow window widths the repository and branch triggers shrink together instead of the branch giving way alone.
• Hidden tabs and unfocused windows no longer keep polling — Actions run and workflow queries pause while their tab is hidden, and GitLab merge-state and agent-session diff polling stops while the window is in the background.
• Arrow-key navigation on the custom slash-commands list (Settings) and the submodules list — move between rows with the arrow keys and act on the active row (edit a command, or initialize/update a submodule) with Enter.
• Pull request, issue, and discussion lists no longer stop silently at 30 or 50. These lists used to cap at the underlying CLI's default page (30 pull requests and issues, 50 discussions) with no indication more existed. They now load the first 100 and, when a full page comes back, offer a "Load 100 more" row at the bottom that pages the rest in — with a "Showing first N" count so you always know where you stand.
• Long pull request, issue, and discussion lists no longer stretch the window with empty space. A list taller than the viewport could spill its full height into the page, adding an outer window scrollbar over a large empty void. Lists (and the detail panels) now contain their own scrolling, so the window stays put and only the list scrolls.
• The local pull-request dialog's branch picker no longer lists internal agent-session branches (gd/session/*).
• Installing the MCP server globally now finds claude / copilot reliably. The global install resolves the client CLI the same way the rest of the app does — checking the system PATH, known install locations, and (on Windows) the live registry PATH — so it no longer reports the CLI as "not found" when it lives in a directory that was added to PATH after GitDesktop started.
• MCP server no longer blocks installs or gets killed by updates (Windows). When you use GitDesktop as an MCP server, the generated config now launches a dedicated gitdesktop-mcp copy of the app instead of the installed executable. Running MCP servers no longer lock the installer out with a "Files in Use" dialog, and are no longer silently terminated mid-session by a passive auto-update. Add to PATH now points at this launcher and migrates any older install-folder entry automatically.
• The merge dialog no longer offers to delete a branch it can't. When merging a pull/merge request, the "Delete branch on the remote after merging" option is now hidden when the head is the repository's default branch (which every forge refuses to delete) and disabled with a reason when a branch rule protects it — matching the branch switcher. Applies to GitHub, GitLab, and Bitbucket, including GitLab auto-merge.
• Merge-confirm dialog: long branch names (e.g. Dependabot's) no longer overflow the delete-branch checkbox label or the dialog description — the text now wraps cleanly.
• New branch dialog: a long base-branch name (e.g. feature/ollama-cloud-provider-custom-endpoints) no longer overflows the dialog — the "Branches from …" description and the base-branch selector now stay within bounds and the name wraps cleanly.
• A UI polish sweep across the app: disabled buttons now explain why they're disabled on hover, bot authors like dependabot display properly on PR rows and headers, PR list fetch failures show an error with retry instead of looking empty, relative times no longer show "24 hours ago" next to "1 day ago", and keyboard navigation & screen-reader labels were added to several lists and icon buttons.
• Creating a pull request with labels or assignees no longer records each one twice on the PR's activity timeline (e.g. "added the documentation label" appearing twice). Labels and assignees are now applied right after the PR is created rather than during creation, which GitHub's CLI double-recorded.
• Very large pull requests now show their full diff and complete file list instead of failing or stopping at 100 files. When GitHub refuses the whole-PR diff (its 300-file limit) or caps the file list at 100, both are rebuilt from the paginated files API so every changed file appears in the rail and renders its hunks.
• Merging a GitHub pull request with Delete branch checked now removes only the remote branch, matching GitLab and Bitbucket — your local branch and whatever you have checked out are left untouched (it previously deleted the local branch too and switched you to the default branch).
• Running automation AI reviews now appear in the header's activity indicator — where they can be cancelled — instead of a persistent toast that floated over the pull-request action bar. Toasts now announce only the result and can be dismissed with a close button.
• PR detail no longer truncates commits, reviews, or conversation comments at 100. A pull request with more than 100 commits, reviews, or conversation comments previously showed only the first 100 as if that were the whole list (GitHub's GraphQL connections cap there). The PR view now completes each list from the paginated REST API, matching how the changed-files rail already worked.
• When promoting a local PR or issue, or creating a sub-issue, a failure that happens after the remote object was already created now tells you what was created (with a View link) and closes the dialog, instead of showing a generic error that invited creating a duplicate.
• Removing the currently open repository while also moving it to the system trash (Recycle Bin on Windows, Trash on macOS/Linux) now closes it first, so the move no longer fails with a raw "Some operations were aborted" error. If the folder is still locked by another program, the message now explains that an open editor, terminal, or file-explorer window is likely holding it — and the repository stays listed so you can close them and retry.
• Switching between repositories no longer briefly shows the previous repository's pull requests, issues, discussions, or other lists before the new repository's load. The panels now drop straight to a loading state on a repo switch, while still keeping their rows in place during in-repo navigation like "Load more" and Open/Closed tab switches.
• Fixed a rare lost update in stored AI review history: when two changes to a PR's reviews landed at nearly the same time — for example an automated review finishing while you edit or delete another review's text — one change could silently overwrite the other. Overlapping writes are now serialized so neither is dropped.
• Review-thread expand/collapse in the Files diff now toggles correctly under rapid clicks, and clipped file paths in the review-comments list show the full path on hover.
• Internal agent-session branches (gd/session/*) no longer show up in the cherry-pick target, GitHub Pages source, or default-branch pickers, nor in the MCP server's list_branches tool or branch-name generation context.
• GitDesktop now enforces a single running instance: launching the app again focuses the existing window — restoring it from the tray if needed — instead of opening a duplicate whose automations could double-fire (e.g. two AI reviews posted on the same PR).
• Review-thread replies no longer clutter the PR timeline. Replying to a review thread on a GitHub PR used to leave a bare, context-free "commented" card in the conversation timeline (GitHub auto-wraps the reply in an empty review); it now renders as a compact "replied in a review thread" row with the file and line, plus a jump-to-thread link. On Bitbucket, thread replies no longer appear twice -- once in the timeline and once inside their thread.
• On a branch that hasn't been published yet, the History tab no longer marks every commit as "not pushed" — it now compares against the remote and flags only the commits actually made on the branch (the ones above where it forked from the default branch).
• Deleting a branch that's checked out in another worktree now explains which worktree holds it instead of failing with a raw git error, and the branch-cleanup dialog leaves such branches out of its delete list (they can still be archived).
• Kept session worktrees no longer leak their folder on Windows. When a worktree couldn't be removed because git's own recursive delete tripped over reparse-point links (how node_modules is laid out on Windows), the folder was left behind on disk. Removal now finishes the job itself once it confirms the worktree has no uncommitted work — a worktree with real unsaved changes is still preserved and surfaced, never silently discarded.
• Merging a local pull request into a base branch that's checked out in another worktree now fast-forwards that worktree instead of refusing, keeping its working tree in sync (and failing with a clear message if that worktree has uncommitted changes).
• Local pull requests, issues, review history, review drafts, branch rules, and automation rules are now keyed by repository identity rather than checkout path, so they're shared across all of a repo's worktrees — a PR created in one worktree now shows up in the main checkout, and the MCP server's local-PR tools no longer report "no local PRs found" when the server is bound to a worktree.

Changed

• The GitLab clone browser lists your most recently active projects first. The listing is capped at 100 projects, so ordering by activity also means anything past the cap is the least-recently-active — not an arbitrary hundred.
• Sharper AI security reviews. The security-review prompt was rebuilt to cut false positives and surface real, exploitable issues. Every finding must now spell out a concrete exploit scenario (no attack path, no finding) and carries a confidence score, reported against a severity-scaled bar — eager on critical-impact issues, strict on low-severity ones. Each risk category now pins its own "not an issue" list right beside it, the model must name the specific guard that makes a risky sink safe before dismissing it, and an exclusion list tuned to this codebase tells it what not to flag — e.g. memory-safety bugs in Rust, React XSS without dangerouslySetInnerHTML, missing client-side auth checks, DoS/rate-limiting, outdated dependencies, and attacks that depend on controlling environment variables or CLI flags. Prompt-injection (XPIA) is now a first-class category, with a carve-out so GitDesktop's own intentional embedding of repo, PR, and diff content into its AI prompts isn't mistaken for a vulnerability. Applies to both the quick (diff-only) and repo-aware security reviews, on any provider.
• Higher-signal AI code reviews. The general code-review prompt was tightened to raise signal without narrowing its scope. Findings are now ordered by severity with clear definitions for blocker, should-fix, and nit; the real ones must cite the concrete case that triggers them (the input, state, or code path), not just an assertion; and the reviewer is told to include a finding only when it's confident, skip formatting a linter already handles, and never let nits crowd out the real issues. It stays a broad review — correctness, edge cases, security smells, performance, clarity, and tests — and runs on any provider, including local models.
• A steadier, tidier agent composer. The task box (Delegate, Plan, and the in-conversation reply) now docks to the bottom of its panel like a terminal: the text grows upward so the action row and Send never drift as you type. The run controls also stopped overflowing — the provider and model stay out for quick access, and run mode, reasoning effort, and MCP servers fold into a single Options popover (with a count + summary so you can still tell at a glance what's set). Best-of-N, the Codex-on-host MCP hint, and changing effort/MCP mid-session all work as before.
• Calmer repository settings. The repository settings dialog moved from a wrapping row of eight tabs to a vertical sidebar — grouped into Repository, Security, Publishing, and Automation — matching the app's main Settings. The Danger zone is now its own sidebar item instead of riding the bottom of the General tab, so delete / transfer / visibility live behind a deliberate click rather than below your topics. Arrow keys move between sections, and the panel crossfades as you switch (respecting "reduce motion").
• The in-app user guide caught up with the app. The guide (press the Open user guide shortcut, or the ? menu) was rewritten and expanded to cover everything that's shipped — Agent sessions (plan, delegate, best-of-N, isolation), the Issues, Discussions, Releases & tags, Insights, and Repository settings surfaces, the full provider list, and more — with arrow-key navigation in its section rail. Keyboard shortcuts shown in the guide now read from your actual bindings (so they show ⌘ on macOS and reflect anything you've rebound), and when Hide AI features is on the guide hides its AI sections and mentions too.
• Keyboard-navigable section sidebars everywhere. The Settings, Repository settings, and user-guide sidebars now share one component, so all three navigate the same way — ↑ / ↓ to move between sections with a visible focus ring (the Settings sidebar was the last one missing this). pick the image's Node version (default 24 LTS, or 22 / 20) and which agents to install (Claude / Codex), and adds Rebuild — which pulls a fresh base image and reinstalls the CLIs so newer releases are picked up. Previously the image was built once with a fixed Node version and every agent baked in, with no way to update it. A stale image (built for a different Node/agent selection) is flagged for rebuild, and starting an agent the image wasn't built with now fails with a clear message instead of a cryptic in-container error.
• Subtle, calm transitions in a few spots. A handful of state changes now ease in instead of popping: the Send/Stop, Generate/Cancel, and Review/Cancel buttons when an AI task starts or stops; agent sessions sliding in and out of the list as you start, keep, or delete them; the "jump to latest" button in an agent chat; the ahead/behind badges in the toolbar; and a soft fade as the Changes list replaces its loading placeholder. Everything respects your system "reduce motion" setting (it falls back to a plain fade or no animation).
• The mint brand color now lives in the app, as a restrained accent. Primary actions (Open repository, Commit, Send a task…), the current selection in lists, and keyboard focus rings are now GitDesktop's mint instead of flat gray — so the one primary action and where the keyboard is focused are obvious at a glance on every screen. The calm monochrome base is unchanged; mint only marks action, selection, and focus. Under the hood, the status colors (added / modified / deleted, success / warning / error, merged) are now driven by shared design tokens, so they stay consistent across every view instead of drifting per-screen, and the diff line-selection highlight uses the accent instead of a one-off blue.

Fixed

• Rust diffs no longer lose syntax highlighting partway down a file. A large Rust diff could render the top of a file highlighted and everything past a certain line as plain text — a quirk of the lightweight highlighter mis-reading a character literal or lifetime and giving up on the rest of the file. Rust now renders with the same VS Code-grade grammar already used for TypeScript, Vue, and others, which highlights every line reliably.

Added

• GitHub Copilot CLI joins Claude Code and Codex as an agent. Pick GitHub Copilot in the agent-session composer to delegate a task to it — keyless, via your Copilot subscription. It runs worktree-confined on the host (its file edits are limited to the worktree), and multi-turn follow-ups resume the same session. Copilot is also available as a code-review provider, and it appears in Settings → About alongside the other CLIs. (Container isolation and repo-aware review for Copilot are coming next; an opencode slot is recognized for a future release.)
• Delegate a task to an AI agent, and iterate with it (agent sessions). A new Agent tab lets you hand a coding task to an AI agent that writes the code for you. It runs full-auto inside an isolated, throwaway git worktree — a separate checkout, so your working tree, staged changes, and current branch are never touched no matter what the agent does. For stronger confinement you can opt into running each session inside an ephemeral Docker/Podman container (Settings → AI), so the agent's filesystem writes are limited to the worktree by the kernel — GitDesktop builds the small agent image for you. It's a conversation: watch the agent work as its narration streams into the conversation, then send follow-ups ("now also handle the empty case", "undo that part") and it keeps going with full context — each turn becomes a reviewable checkpoint commit. The composer stays pinned while output streams (it grows as you type, then scrolls), Enter sends and Shift+Enter adds a line, and a Latest button jumps you back to the newest output if you've scrolled up. Press ↑/↓ to recall your previous prompts (like a terminal), and any turn that came back empty or errored offers Edit & resend to pull its prompt back into the composer and retry. Type @ to reference a repo file, and file paths the agent mentions are clickable — they open in your editor. Flip between the Conversation and a dedicated Changes view (the full diff so far) right in the session. Pick the provider (Claude, Codex, or Copilot), the model, and a reasoning-effort level for the session — model and effort are changeable as you go (effort maps to each CLI's own mechanism, so it applies where the provider supports it). Run several sessions at once — each gets its own worktree and runs independently, listed in the sidebar so you can start one, switch to another while it works (arrow keys included), and come back. The sidebar groups sessions into Active and Kept tabs (with counts) so finalized work doesn't crowd what's ready to review, and a search box filters by task, branch, or any message. An OS notification fires when a turn finishes — unless you're already watching that session — so you can start one and step away. Sessions are remembered across restarts — close and reopen the app and your sessions are still there, ready to keep iterating (a follow-up picks up right where it left off). When you're happy, Keep the work — optionally squashing the per-turn commits into one — and it lands on its own branch ready to open as a PR. Kept sessions stay in the list, so you can come back later: Resume re-opens one and continues the conversation right where it left off, or Delete removes it from the app (the branch is preserved). Discard throws an in-progress session away entirely (branch and all). New session, Keep, Resume, Delete, Discard, and the view toggle are all in the command palette and keyboard-bindable. It builds on the CLI agent you already have — Claude Code or Codex (pick

Release notes truncated — see the full changelog for the rest.