GitDesktop v0.2.0

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.