Przewodniki aktualizacji Cursora

Bezpieczna aktualizacja Cursora to trzy ruchy: zapisanie punktu odniesienia dla obecnego buildu (wersji, rozszerzeń, serwerów MCP i wyników testów projektu), aktualizacja i porównanie nowego buildu z tym zapisem oraz trzymanie poprzedniego buildu ze sprawdzonym hashem, żeby nieudana aktualizacja kosztowała minuty. Domyślnie Cursor aktualizuje się sam.

Ta strona jest dla dewelopera, któremu Cursor zaktualizował się w nocy, i dla tech leada, który musi zdecydować, czy zespół idzie za nim. Rano po aktualizacji agent przestaje stosować regułę projektu, jedno rozszerzenie się nie ładuje, a serwer MCP dla Postgresa nie pokazuje żadnych narzędzi. Bez zapisu, jak wszystko wyglądało wczoraj, nie odróżnisz, czy zepsuła to aktualizacja, czy było zepsute już wcześniej.

Co sprawdziliśmy i kiedy

Strona dotyczy linii Cursor 3.x, sprawdzonej 26 września 2026 r. Tego dnia cursor.com był nieosiągalny, więc poniższe sprawdzenia opierają się na źródłach wymienionych dalej. 12 października 2026 r. cursor.com odpowiedział, a informacje o wydaniu i strony CLI Cursora potwierdzają fakty o wersjach i CLI z sekcji „Jakiego buildu Cursora używasz?”; każde inne twierdzenie na tej stronie nadal opiera się na sprawdzeniu z 26 września. Nazwy poleceń z palety poleceń na tej stronie pochodzą z VS Code; Cursor dziedziczy większość z nich, ale tego dnia nie sprawdziliśmy ich ponownie w Cursorze. Adresy pobierania, hashe, ścieżki danych aplikacji dla macOS, cache aktualizatora i polecenie cursor sprawdziliśmy 26 września 2026 r. w casku Homebrew (Casks/c/cursor.rb); ścieżki dla Linuksa i Windows wynikają z konwencji danych użytkownika VS Code (~/.config/<App>, %APPDATA%\<App>). Wartości update.mode sprawdziliśmy w kodzie źródłowym VS Code (update.config.contribution.ts), a wycofanie na Windows opiera się na manifeście winget dla Anysphere.Cursor (microsoft/winget-pkgs, manifests/a/Anysphere/Cursor), który zawiera hash instalatora. Ten manifest nie nadąża za wydaniami Cursora: 2 października 2026 r. najnowszy wpis w winget był o kilka wydań za caskiem Homebrew. Wzorzec adresu pobierania dla Windows na tej stronie to ten, którego używa każdy manifest winget; samego downloads.cursor.com nie dało się osiągnąć ze środowiska, w którym sprawdzaliśmy stronę. Polecenie cursor to launcher code z VS Code pod inną nazwą: cask linkuje ten plik wykonywalny jako cursor.

Co daje ci ten przewodnik po aktualizacjach Cursora

• Pięciominutową rutynę przed aktualizacją, która archiwizuje dane Cursora i zapisuje punkt odniesienia do porównania.
• Prompt do skopiowania, którym agent zapisuje ten punkt odniesienia, i drugi, który powtarza go na nowym buildzie i raportuje każdą różnicę.
• Kryterium zaliczenia oparte na kodach wyjścia i listach, a nie na czytaniu odpowiedzi agenta linijka po linijce.
• Kroki wycofania dla macOS, Linuksa i Windows, które instalują poprzedni build po sprawdzeniu jego hasha SHA-256, a na Windows podpisu cyfrowego.
• Sposób wyjścia z każdej typowej awarii aktualizacji oraz trzeci prompt, który zamienia regresję w zgłoszenie błędu.

Jakiego buildu Cursora używasz?

Zapisz build, zanim cokolwiek się zmieni. Uruchom w terminalu:

cursor --version

Pierwsza linia to wersja, druga to hash commita buildu, trzecia to architektura procesora. Zapisz wszystkie trzy razem z datą. Przy wycofaniu najważniejszy jest hash commita: adresy pobierania Cursora są od niego zależne, a cask Homebrew zapisuje go dla każdego wydania, do którego został podbity.

Informacje o wydaniu Cursora numerują aplikację desktopową wersjami minor. Na 2026-10-12 bieżące wydanie to Cursor 3.24 (2026-10-09), a od 3.19 (2026-09-02) wychodzi mniej więcej jedna wersja minor tygodniowo. Cursor CLI ma natomiast wersje oparte na dacie: jego najnowszy build na 2026-10-12 to v2026.10.08. agent to polecenie CLI, a nie launcher cursor z powyższego przykładu: wersję sprawdzisz przez agent --version, a zaktualizujesz przez agent update (strona instalacji CLI w Cursorze, sprawdzone 2026-10-12).

Jeśli cursor nie jest w PATH, najpierw to napraw według instalacji Cursora. Reszta strony korzysta z tego polecenia.

Jak kontrolować, kiedy Cursor się aktualizuje?

Cursor sam pobiera i instaluje aktualizacje. Cask Homebrew oznacza go jako auto_updates i dlatego brew upgrade go pomija: o tym, kiedy przychodzi nowy build, decyduje aplikacja, a nie menedżer pakietów.

Cursor jest zbudowany na VS Code, który steruje aktualizacjami ustawieniem update.mode. Build Cursora dla macOS ma jednak własny aktualizator: przy odinstalowaniu cask usuwa cache ShipIt z ToDesktop i cache cursor-updater. Traktuj więc ten klucz jako coś do przetestowania na twoim buildzie, a nie gwarancję. Dodaj je do pliku settings.json użytkownika (w palecie poleceń uruchom Preferences: Open User Settings (JSON)):

{
  "update.mode": "manual"
}

Wartość	Co robi to ustawienie w VS Code	Kiedy go użyć
default	Automatycznie i cyklicznie sprawdza aktualizacje	Chcesz aktualizacji na bieżąco i masz zapisany punkt odniesienia
start	Sprawdza tylko przy starcie	Restartujesz Cursora w przewidywalnym momencie, na przykład w poniedziałek rano
manual	Bez sprawdzania w tle; aktualizacja tylko wtedy, gdy sam ją sprawdzisz	Trzymasz sprawdzony build w czasie deadline’u albo po wycofaniu
none	Wyłącza aktualizacje	Nigdy na codziennej maszynie: tracisz też poprawki bezpieczeństwa

Wartości i ich znaczenie pochodzą z kodu źródłowego VS Code. Sprawdź, czy twój build Cursora respektuje ten klucz: po ustawieniu manual wyszukiwarka ustawień dla update.mode powinna pokazać wybraną wartość, a Cursor nie powinien proponować restartu z aktualizacją, dopóki sam jej nie sprawdzisz. Jeśli propozycja restartu i tak się pojawi, twój build ignoruje ten klucz; jedyną pewną blokadą jest wtedy wycofanie opisane niżej, powtarzane po każdej aktualizacji.

Buildy przedpremierowe tylko na zapasowej maszynie

Jeśli twój build Cursora oferuje opcję aktualizacji przedpremierowych lub wczesnego dostępu, zostaw ją wyłączoną na maszynie, na której wykonujesz płatną pracę. Buildy przedpremierowe uruchamiaj na drugiej maszynie albo na drugim koncie użytkownika, z tym samym repozytorium, żeby zepsuty build nigdy nie stanął między tobą a deadline’em.

Zrób kopię zapasową Cursora przed aktualizacją

Na macOS spośród ścieżek, które cask Homebrew usuwa przy pełnym odinstalowaniu Cursora, dwie przechowują twoje dane; Linux i Windows trzymają te same dwa katalogi w miejscach typowych dla VS Code: katalog danych aplikacji (ustawienia, skróty klawiszowe, snippety i stan poszczególnych workspace’ów) oraz ~/.cursor (w którym jest globalny ~/.cursor/mcp.json). Zarchiwizuj oba przy zamkniętym Cursorze.

1. Zamknij Cursora całkowicie, a nie tylko jego okno. Na macOS użyj Cursor › Quit Cursor.

2. Zarchiwizuj oba katalogi i zapisz obok archiwum build oraz listę rozszerzeń:

   macOS

   STAMP=$(date +%Y%m%d)
   mkdir -p ~/cursor-backups
   tar -czf ~/cursor-backups/cursor-$STAMP.tgz \
     -C ~ ".cursor" "Library/Application Support/Cursor"
   cursor --version > ~/cursor-backups/version-$STAMP.txt
   cursor --list-extensions --show-versions > ~/cursor-backups/extensions-$STAMP.txt

   Linux

   STAMP=$(date +%Y%m%d)
   mkdir -p ~/cursor-backups
   tar -czf ~/cursor-backups/cursor-$STAMP.tgz -C ~ .cursor .config/Cursor
   cursor --version > ~/cursor-backups/version-$STAMP.txt
   cursor --list-extensions --show-versions > ~/cursor-backups/extensions-$STAMP.txt

   Windows

   $stamp = Get-Date -Format yyyyMMdd
   $dir = "$HOME\cursor-backups"
   New-Item -ItemType Directory -Force $dir | Out-Null
   Compress-Archive -Path "$env:APPDATA\Cursor", "$HOME\.cursor" `
     -DestinationPath "$dir\cursor-$stamp.zip"
   cursor --version > "$dir\version-$stamp.txt"
   cursor --list-extensions --show-versions > "$dir\extensions-$stamp.txt"

   Archiwum bywa duże. Trzymaj dwa ostatnie, starsze usuwaj. W Windows PowerShell 5.1 Compress-Archive nie zapisze pliku większego niż 2 GB, a katalog danych aplikacji zawiera duże cache; użyj PowerShell 7, polecenia tar -czf (tar.exe jest w Windows 10 i nowszych) albo pomiń foldery Cache i CachedData.

3. Zacommituj konfigurację Cursora dla projektu. Reguły, skille, hooki i .cursor/mcp.json należą do repozytorium, gdzie git diff pokaże każdą zmianę wprowadzoną przez aktualizację albo przez kogoś z zespołu. Jeśli git status pokazuje niezacommitowane pliki w .cursor/, zacommituj je teraz na osobnej gałęzi.

4. Zapisz punkt odniesienia agenta promptem poniżej, w nowym czacie na obecnym buildzie.

Prompt do skopiowania: zapisz punkt odniesienia przed aktualizacją Cursora

I am about to update Cursor. Record a baseline I can compare against after the
update. Do not change any tracked file.

1. List every rule you have loaded for this project, with its file path.
2. List every skill you can use, with its name and source directory.
3. List every MCP server you can reach and the exact names of its tools.
   Call one read-only tool on each server (for Postgres: list the tables) and
   record whether the call succeeded.
4. Run the project's test, type-check and lint commands (read them from
   package.json, Makefile or the README). Record each command and its exit code.

Write the result to .cursor-baseline.md in the repository root as four
sections with plain lists, one item per line, so the file diffs cleanly.
Then check that .cursor-baseline.md is listed in .gitignore; if it is not,
tell me instead of editing .gitignore.

Przeczytaj punkt odniesienia raz, przed aktualizacją. Reguła, serwer albo narzędzie, których brakuje już dziś, to nie wina aktualizacji, a lepiej dowiedzieć się o tym teraz niż jutro.

Zaktualizuj Cursora i udowodnij, że nowy build działa

Gdy punkt odniesienia jest już na dysku, sama aktualizacja jest prosta: sprawdź aktualizacje z palety poleceń (Check for Updates albo wyszukaj w palecie „update”) albo przyjmij propozycję restartu. Praca polega na udowodnieniu wyniku, a dowodem jest zestaw porównań, które albo się zgadzają, albo nie.

1. Potwierdź, że build się zmienił: uruchom cursor --version i porównaj hash commita z zapisanym. Ten sam hash oznacza, że aktualizacja się nie zainstalowała.

2. Porównaj rozszerzenia z zapisaną listą. Uruchom w katalogu z kopiami:

   macOS i Linux

   diff extensions-YYYYMMDD.txt <(cursor --list-extensions --show-versions)

   Windows

   Compare-Object (Get-Content extensions-YYYYMMDD.txt) (cursor --list-extensions --show-versions)

   Zastąp YYYYMMDD datą z kopii zapasowej. Zmiany wersji są normalne. Linia zaczynająca się od < (w PowerShellu oznaczona <=) bez pasującej linii > (=>) dla tego samego rozszerzenia to rozszerzenie, które nie jest już zainstalowane. Zainstalowane rozszerzenie, które nie daje się aktywować, nie pojawi się w tym porównaniu; wychwyci je prompt porównujący albo polecenie Developer: Show Running Extensions.

3. Sprawdź, czy plik MCP projektu nadal się parsuje. Uszkodzony plik łatwo przeoczyć w interfejsie, więc sprawdź go w terminalu:

   python3 -m json.tool .cursor/mcp.json > /dev/null && echo "mcp.json OK"

4. Otwórz nowy czat na nowym buildzie i uruchom poniższy prompt porównujący.

5. Uruchom polecenie testów projektu samodzielnie, we własnym terminalu, a nie przez agenta, i sprawdź kod wyjścia poleceniem echo $? (w PowerShellu: $LASTEXITCODE). Dzięki temu kluczowe kryterium nie opiera się wyłącznie na raporcie samego agenta.

6. Zdecyduj. Build zalicza, gdy hash commita się zmienił, nie brakuje żadnego rozszerzenia, mcp.json się parsuje, twoje własne uruchomienie testów kończy się kodem 0, a każdy wiersz tabeli porównania mówi MATCH. Każda różnica trafia do tabeli decyzji o wycofaniu, zanim zajmiesz się czymkolwiek innym.

Prompt do skopiowania: porównaj zaktualizowanego Cursora z punktem odniesienia

Cursor was just updated. Read .cursor-baseline.md in the repository root, then
repeat the four checks that produced it: loaded rules, usable skills, MCP
servers with their tool names and one read-only call each, and the test,
type-check and lint commands with their exit codes. Compare what you get now
with the results recorded in the file.

Output one table with columns: check, baseline, now, MATCH or DIFFERENT.
For every DIFFERENT row, add the exact error text or the missing item.
Do not fix anything, do not edit any file, and do not retry a failing command
more than once.

Tak oceniasz aktualizację bez czytania pracy agenta: tabela albo mówi MATCH w każdym wierszu, albo wskazuje wiersz, który się zmienił. Deweloper sam zatwierdza aktualizację na swojej maszynie. W zespole tech lead zatwierdza build dopiero wtedy, gdy na nowym buildzie przejdą też zadania kanarkowe z rutyny w historii wersji. Tę samą zasadę „dowody zamiast diffów” opisuje strona o czytaniu dowodów zamiast kodu.

Kiedy wycofać aktualizację, a kiedy naprawić problem na nowym buildzie?

Wycofaj, gdy regresja blokuje pracę, którą musisz dowieźć w tym tygodniu, i nie ma szybkiej poprawki. Naprawiaj na bieżącym buildzie, bez wycofywania, gdy przyczyna leży w twojej własnej konfiguracji.

Co pokazuje porównanie	Najbardziej prawdopodobna przyczyna	Co zrobić
Brakuje reguły albo skilla, a ich plik w git diff się nie zmienił	Nowy build inaczej czyta pliki reguł lub skilli	Wycofaj, a potem na zapasowej maszynie porównaj plik z aktualną dokumentacją Rules albo Skills Cursora
Serwer MCP nie pokazuje narzędzi, a jego polecenie zawodzi też w terminalu	Twoje środowisko uruchomieniowe (npx, uvx, docker) albo jego poświadczenia, nie Cursor	Napraw bez wycofywania według konfiguracji MCP w Cursorze
Serwer MCP nie pokazuje narzędzi, ale jego polecenie działa w terminalu	Nowy build	Raz zrestartuj Cursora całkowicie; jeśli problem zostaje, wycofaj
Testy lub lint padają na tym samym commicie, który przechodził w punkcie odniesienia	Zmieniło się środowisko agenta, na przykład PATH w zintegrowanym terminalu	Porównaj echo $PATH w terminalu Cursora i w swoim; wycofaj, jeśli nie naprawisz tego w 30 minut
Jedno rozszerzenie przestało się ładować	Rozszerzenie, nie Cursor	Zaktualizuj albo wyłącz to rozszerzenie; wycofuj tylko wtedy, gdy nie możesz bez niego pracować

Wróć do poprzedniego buildu Cursora

Wycofanie instaluje ponownie poprzedni build i zostawia twoje dane na miejscu. Potrzebujesz poprzedniego numeru wersji i hasha commita, zapisanych w version-YYYYMMDD.txt, oraz pasującego hasha SHA-256. Historia casku Homebrew na GitHubie (Homebrew/homebrew-cask, plik Casks/c/cursor.rb) zawiera wydania, do których cask został podbity, każde z wersją, commitem i sha256 dla macOS (Apple silicon i Intel) oraz Linuksa (x86_64 i aarch64), niezależnie od tego, czy instalowałeś przez Homebrew. Może pominąć wydanie, które pojawiło się i zniknęło między podbiciami. Na Windows hash instalatora zawiera manifest winget, ale tylko dla wydań, które winget spakował, a pakuje ich znacznie mniej, niż Cursor publikuje.

1. Otwórz historię pliku Casks/c/cursor.rb w repozytorium casków Homebrew i znajdź commit, który ustawił zapisaną przez ciebie wersję. Skopiuj wersję, hash commita i sha256 dla swojej platformy.

2. Zamknij Cursora całkowicie.

3. Pobierz poprzedni build, sprawdź jego hash i zainstaluj go:

   macOS

   CURSOR_COMMIT=PREVIOUS_COMMIT_HASH
   ARCH=arm64          # x64 on Intel Macs
   curl -fL -o Cursor.zip \
     "https://downloads.cursor.com/production/$CURSOR_COMMIT/darwin/$ARCH/Cursor-darwin-$ARCH.zip"
   shasum -a 256 Cursor.zip   # must equal the cask's sha256 for your arch
   unzip -q Cursor.zip
   mv /Applications/Cursor.app ~/cursor-backups/Cursor-bad.app
   mv Cursor.app /Applications/

   Linux

   CURSOR_VERSION=PREVIOUS_VERSION
   CURSOR_COMMIT=PREVIOUS_COMMIT_HASH
   ARCH=x64; AARCH=x86_64   # on ARM: ARCH=arm64; AARCH=aarch64
   curl -fL -o "Cursor-$CURSOR_VERSION-$AARCH.AppImage" \
     "https://downloads.cursor.com/production/$CURSOR_COMMIT/linux/$ARCH/Cursor-$CURSOR_VERSION-$AARCH.AppImage"
   sha256sum "Cursor-$CURSOR_VERSION-$AARCH.AppImage"   # compare with the cask
   chmod +x "Cursor-$CURSOR_VERSION-$AARCH.AppImage"

   Odsuń nowy AppImage na bok, a stary umieść pod ścieżką, którą uruchamia twój launcher albo wpis pulpitu (cask Homebrew linkuje go jako Cursor.AppImage); potem uruchom go i potwierdź poleceniem cursor --version. Jeśli przy instalacji z AppImage polecenia cursor nie ma w PATH, uruchom zamiast tego ./Cursor-$CURSOR_VERSION-$AARCH.AppImage --version albo zainstaluj polecenie powłoki zgodnie z opisem w instalacji Cursora. Jeśli Cursor jest zainstalowany z pakietu .deb albo .rpm, uruchamiaj AppImage bezpośrednio, dopóki menedżer pakietów znów nie zaoferuje starszej wersji. Zachowuj AppImage używany przed każdą aktualizacją zamiast go usuwać, żeby następne wycofanie było po prostu uruchomieniem starszego pliku.

   Windows

   Najpierw sprawdź, czy winget spakował twoją poprzednią wersję:

   winget show --id Anysphere.Cursor --exact --versions

   Jeśli jest na liście, zainstaluj ją przez winget, który sprawdza instalator względem hasha SHA-256 z manifestu:

   winget uninstall --id Anysphere.Cursor --exact
   winget install --id Anysphere.Cursor --exact --version PREVIOUS_VERSION

   winget często zostaje kilka wydań za Cursorem, więc zwykle twojej poprzedniej wersji na liście nie ma. Wtedy masz dwie drogi:

   • Cofnij się dalej, ze sprawdzeniem hasha. Zainstaluj tymi samymi dwoma poleceniami najnowszą wersję z listy winget, która jest starsza od zepsutego buildu. To więcej niż jedno wydanie wstecz, więc potem uruchom prompt porównujący, zamiast zakładać, że zachowuje się jak build, który miałeś.
   • Pobierz dokładnie swój poprzedni build. Każdy manifest winget wskazuje na downloads.cursor.com/production/<commit>/win32/<arch>/user-setup/CursorUserSetup-<arch>-<version>.exe, więc zapisane przez ciebie commit i wersja wystarczą, żeby go znaleźć. Dla wydania pominiętego przez winget nie ma opublikowanego SHA-256, dlatego skrypt sprawdza zamiast tego podpis Authenticode instalatora i usuwa plik, chyba że Windows uzna podpis za Valid, a organizacja w certyfikacie (O=) to Anysphere:

   $v = 'PREVIOUS_VERSION'; $c = 'PREVIOUS_COMMIT_HASH'
   $a = 'x64'   # arm64 on Windows on ARM
   $f = "CursorUserSetup-$a-$v.exe"
   Invoke-WebRequest -UseBasicParsing -OutFile $f `
     -Uri "https://downloads.cursor.com/production/$c/win32/$a/user-setup/$f"
   $sig = Get-AuthenticodeSignature $f
   if ($sig.Status -ne 'Valid' -or $sig.SignerCertificate.Subject -notmatch '(^|,\s*)O="?Anysphere\b') {
     Remove-Item $f; throw "Do not run ${f}: signature $($sig.Status), signer '$($sig.SignerCertificate.Subject)'"
   }
   "Signed by $($sig.SignerCertificate.Subject)"

   Status Valid oznacza, że plik nie zmienił się od podpisania, a certyfikat prowadzi do głównego urzędu, któremu ufa Windows, więc pole subject wskazuje dokładnie tego, kto podpisał plik. Nie dowodzi jednak, że podpisującym jest Anysphere, dlatego skrypt sprawdza też organizację. Pola subject w certyfikatach instalatorów Cursora nie zweryfikowaliśmy, bo downloads.cursor.com był nieosiągalny; „Anysphere” to wydawca z metadanych pakietu w winget, a nie subject certyfikatu. Jeśli skrypt odrzuci build, który powinien przejść, przeczytaj wypisanego podpisującego i nie luzuj warunku. Gdy skrypt wypisze Signed by, odinstaluj obecny build i uruchom instalator poleceniem & ".\$f". Jeśli Cursor jest zainstalowany dla wszystkich użytkowników, ustaw $f na "CursorSetup-$a-$v.exe" i zamień w adresie user-setup na system-setup. Jeśli pobieranie zwróci 404, ten build nie jest już udostępniany; cofnij się wtedy dalej.

   PREVIOUS_VERSION i PREVIOUS_COMMIT_HASH to dwie pierwsze linie zapisanego pliku version-YYYYMMDD.txt. Jeśli sprawdzenie hasha pokaże inną wartość, przerwij i usuń pobrany plik.

4. Ustaw "update.mode": "manual", zanim uruchomisz stary build, inaczej Cursor przy następnym sprawdzeniu aktualizacji znów zainstaluje nowy. Cursor jest w tym momencie zamknięty, więc edytuj plik ustawień użytkownika bezpośrednio: ~/Library/Application Support/Cursor/User/settings.json na macOS, ~/.config/Cursor/User/settings.json na Linuksie albo %APPDATA%\Cursor\User\settings.json na Windows. Zachowaj instalator, archiwum zip albo AppImage buildu, do którego wracasz: jeśli blokada nie zadziała i Cursor znów się zaktualizuje, cofniesz to tak samo, bez ponownego szukania w historii casku.

5. Uruchom Cursora, potwierdź stary commit poleceniem cursor --version i ponownie uruchom prompt porównujący. Każdy wiersz powinien mówić MATCH.

6. Przywróć archiwum danych tylko wtedy, gdy porównanie nadal zawodzi. Zamknij Cursora, przenieś obecne katalogi danych w inne miejsce (albo zmień ich nazwy) i rozpakuj archiwum na ich miejsce, tak jak robią to poniższe polecenia. Przeniesienie zamiast usunięcia zachowuje wszystko, co powstało po zrobieniu kopii.

   macOS

   mv "$HOME/Library/Application Support/Cursor" "$HOME/Library/Application Support/Cursor.pre-restore"
   mv ~/.cursor ~/.cursor.pre-restore
   tar -xzf ~/cursor-backups/cursor-YYYYMMDD.tgz -C ~

   Linux

   mv ~/.config/Cursor ~/.config/Cursor.pre-restore
   mv ~/.cursor ~/.cursor.pre-restore
   tar -xzf ~/cursor-backups/cursor-YYYYMMDD.tgz -C ~

   Windows

   $tmp = "$HOME\cursor-restore"
   Expand-Archive "$HOME\cursor-backups\cursor-YYYYMMDD.zip" -DestinationPath $tmp
   Rename-Item "$env:APPDATA\Cursor" Cursor.pre-restore
   Rename-Item "$HOME\.cursor" .cursor.pre-restore
   Copy-Item "$tmp\Cursor" "$env:APPDATA\Cursor" -Recurse
   Copy-Item "$tmp\.cursor" "$HOME\.cursor" -Recurse

   Compress-Archive zapisuje każdy folder pod jego własną nazwą na najwyższym poziomie archiwum, więc te dwie kopie odkładają Cursor i .cursor tam, skąd wzięła je kopia zapasowa.

Blokadę aktualizacji zdejmuj świadomie. Nadaj jej termin, na przykład „do następnego wydania, które wspomina o tej regresji”, i przywróć update.mode, gdy to wydanie przejdzie porównanie na zapasowej maszynie.

Co się psuje przy aktualizacji Cursora i jak z tego wyjść?

• Aktualizacja się pobiera, ale nigdy nie instaluje, albo propozycja restartu ciągle wraca. Zamknij Cursora całkowicie, łącznie z oknami na innych pulpitach, i uruchom go ponownie. Jeśli build się nie zmienia, zainstaluj bieżące wydanie z menedżera pakietów albo ze strony pobierania Cursora na istniejącą instalację. Twoje katalogi danych zostają nietknięte.
• Po aktualizacji Cursor mocno obciąża maszynę. Uruchom go z wyłączonymi rozszerzeniami: cursor --disable-extensions. Jeśli obciążenie znika, włączaj rozszerzenia po jednym albo uruchom Help: Start Extension Bisect z palety poleceń. Jeśli nie znika, przetestuj czysty profil poleceniem cursor --user-data-dir /tmp/cursor-clean --extensions-dir /tmp/cursor-clean-ext i zgłoś build Cursorowi, jeśli czysty profil też działa wolno.
• Agent ignoruje regułę po aktualizacji. Tabela porównania wskazuje brakującą regułę. Sprawdź poleceniem git log -p -- .cursor/, że jej plik się nie zmienił, a potem wycofaj aktualizację albo popraw plik według aktualnej dokumentacji Rules Cursora. Format pliku opisuje strona o regułach projektu w Cursorze.
• Serwery MCP nie pokazują narzędzi. Uruchom w terminalu command i args serwera z mcp.json. Jeśli to zawodzi, problem leży w środowisku uruchomieniowym albo poświadczeniach; konfiguracja MCP w Cursorze ma rozwiązanie dla każdego objawu. Jeśli działa, zamknij Cursora całkowicie i uruchom go ponownie, żeby wczytał mcp.json od nowa.
• Wycofałeś aktualizację, a Cursor znów się zaktualizował. update.mode nie było ustawione przed startem starego buildu albo twój build je ignoruje. Ustaw je, zainstaluj stary build ponownie i po pełnym restarcie potwierdź go poleceniem cursor --version.
• Zniknęła historia czatów albo stan workspace’u. Zamknij Cursora i przywróć archiwum jak w kroku 6 wycofania. Bez archiwum nie ma czego przywracać i właśnie dlatego kopia powstaje przed każdą aktualizacją.
• U jednej osoby z zespołu działa, u drugiej nie, na tym samym buildzie. Porównaj linia po linii ich wynik cursor --version i listy rozszerzeń. Różne hashe commitów oznaczają, że to nie jest ten sam build, niezależnie od tego, co mówi linia z wersją.

Prompt do skopiowania: zamień regresję Cursora w zgłoszenie błędu

Cursor regressed after an update and I need to report it. Using only facts you
can check in this session, draft a bug report with these sections:

1. Builds: ask me to paste `cursor --version` for the old and the new build.
2. What changed: the DIFFERENT rows from the baseline comparison, with the
   exact error text.
3. Minimal reproduction: the shortest sequence of steps in this repository
   that shows the difference, run once on the current build to confirm it.
4. What I ruled out: whether the problem remains with `cursor
   --disable-extensions`, and whether the MCP server command works in a
   terminal. Ask me for these results instead of guessing them.

Keep it under 250 words. Do not include file contents, tokens, environment
variables, or anything from .env files.

Wyślij zgłoszenie z oboma hashami commitów. Na zgłoszenie z dwoma buildami i jedną reprodukcją producent może zareagować; na „zepsuło się po aktualizacji” nie.

Jak zespół powinien wdrażać aktualizację Cursora?

Zespół dokłada do wszystkiego powyżej jedną zasadę: żadna maszyna nie spotyka nowego buildu jako pierwsza w trakcie deadline’u. Rutyną zarządza tech lead, a jest ona rozpisana w historii wersji Cursora: przeczytaj informacje o wydaniu pod kątem zacommitowanej konfiguracji, uruchom zadania kanarkowe na starym i nowym buildzie, przenieś najpierw jednego ochotnika, potem wszystkich. Ta strona dostarcza elementów, które ta rutyna zakłada: punktu odniesienia i porównania na każdej maszynie oraz wycofania, które zajmuje minuty. Zatwierdzony build zapisz w dokumencie onboardingowym zespołu jako hash commita, bo dwie maszyny mogą pokazywać tę samą linię wersji i różnić się pod spodem.

Dokąd dalej po aktualizacji Cursora

Bądź na bieżąco z Cursorem Hub materiałów referencyjnych: jaki build i SDK działa na każdej maszynie i w każdym pipeline

Historia wersji Cursora Zweryfikowane kamienie milowe, zmienione nazwy funkcji i zespołowa rutyna od wydania do wdrożenia

Wdrażanie nowych funkcji Cursora Testuj to, co wnosi aktualizacja, według zasięgu ryzyka i udowadniaj w CI

Instalacja Cursora Kanały instalacji, polecenie cursor i migracja z VS Code

Pozostałe narzędzia aktualizują się inaczej: zobacz procedury aktualizacji Claude Code i bądź na bieżąco z Codeksem.