diff --git a/docs/superpowers/plans/2026-08-07-wcag-skrot-i-graf.md b/docs/superpowers/plans/2026-08-07-wcag-skrot-i-graf.md
new file mode 100644
index 000000000..06b988131
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-07-wcag-skrot-i-graf.md
@@ -0,0 +1,1600 @@
+# Skrót `/` i nawigacja po grafie — plan wdrożenia
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use
+> superpowers:subagent-driven-development (recommended) or
+> superpowers:executing-plans to implement this plan task-by-task. Steps use
+> checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Domknąć kryteria WCAG 2.1.4 (mechanizm wyłączania skrótu `/`),
+2.5.7 (nawigacja po grafie powiązań wskaźnikiem) i 2.1.1 (ta sama nawigacja
+klawiaturą).
+
+**Architecture:** Dwa niezależne moduły JS window-globalnych, wzorem
+`related-records-highlight.js` z poprzedniej iteracji. Pierwszy trzyma
+preferencję skrótów w `localStorage` i obsługuje przełącznik w stopce;
+handlery `/` pytają go przed reakcją. Drugi wystawia czyste funkcje nad
+instancją Cytoscape (`przesun`, `zoomuj`, `dopasuj`), z których korzystają
+zarówno przyciski nakładki, jak i handler klawiatury.
+
+**Tech Stack:** Django (szablony), JavaScript (moduły window-globalne, bez
+bundlera dla `skroty-klawiszowe.js`; `nawigacja.js` idzie przez esbuild do
+`cytoscape-bundle.js`), Cytoscape.js ^3.34.0, vitest, pytest, Playwright,
+SCSS + grunt.
+
+**Spec:** `docs/superpowers/specs/2026-08-07-wcag-skrot-i-graf-design.md`
+
+## Global Constraints
+
+- Wszystkie polecenia Pythona przez `uv run` — nigdy gołe `python`/`pytest`.
+- Max długość linii Pythona: 88 znaków (ruff). JS i szablonów nie dotyczy.
+- Testy: pytest, funkcje standalone (nie klasy), `@pytest.mark.django_db`
+  gdzie potrzebna baza; `model_bakery.baker.make` do tworzenia obiektów.
+- Testy JS: vitest, pliki w `tests/js/**/*.test.js`. Domyślne środowisko to
+  `node` — plik testujący kod używający `window`/`localStorage` musi
+  deklarować u siebie `// @vitest-environment jsdom`.
+- Komentarze Django `{# … #}` **jednoliniowe** — każda linia własne
+  otwarcie i zamknięcie. Wieloliniowy wycieka do wyrenderowanego HTML-a.
+- **NIE modyfikować istniejących migracji** w `src/*/migrations/`.
+- `pre-commit` uruchamiać BEZ ARGUMENTÓW. Nigdy `--all-files`, nigdy
+  `ruff check --fix` — problemy naprawiać ręcznie, po jednym.
+- Na hoście mogą działać cudze kontenery testowe: NIE uruchamiać
+  `make clean-testcontainers`.
+- Praca w worktree `/Volumes/SSD/Programowanie/bpp-wcag-faza2`, gałąź
+  `fix-wcag-2140-2570` (stacked na `fix-wcag-naprawy-stwierdzone`).
+- Po zmianach SCSS: `grunt build` (albo `make assets`).
+
+## Struktura plików
+
+**Tworzone:**
+
+| plik | odpowiedzialność |
+|---|---|
+| `src/bpp/static/bpp/js/skroty-klawiszowe.js` | preferencja skrótów + przełącznik |
+| `tests/js/skroty-klawiszowe.test.js` | testy vitest modułu preferencji |
+| `src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js` | czyste funkcje nawigacji nad Cytoscape |
+| `tests/js/nawigacja-grafu.test.js` | testy vitest modułu nawigacji |
+| `src/bpp/static/scss/graf_powiazan.scss` | nakładka nawigacji + pierścień focusa |
+| `src/bpp/tests/test_wcag/test_skrot_szukania.py` | testy szablonowe części A |
+| `src/powiazania_autorow/tests/__init__.py` | pakiet testów (jeśli nie istnieje) |
+| `src/powiazania_autorow/tests/test_graf_dostepnosc.py` | testy szablonowe grafu |
+| `src/integration_tests/test_wcag_skrot_i_graf.py` | testy Playwright |
+| `src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst` | newsfragment |
+
+**Modyfikowane:**
+
+| plik | zmiana |
+|---|---|
+| `src/django_bpp/templates/base.html:37-51` | **usunięcie** zduplikowanego handlera `/`; dodanie `<script src>` modułu |
+| `src/django_bpp/templates/global_search_modal.html:1040-1052` | warunek preferencji w handlerze |
+| `src/bpp/templates/browse/uczelnia.html:98-142` | warunek preferencji w handlerze banera i przy pokazywaniu banera |
+| `src/django_bpp/templates/base_footer.html` | przycisk przełącznika |
+| `src/powiazania_autorow/templates/powiazania_autorow/graf.html` | nakładka nawigacji; `tabindex`/`role`/`aria-label` na kontenerze |
+| `src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js` | podpięcie przycisków i klawiatury |
+| `src/bpp/static/scss/common.scss` | `@import "graf_powiazan";` |
+| `docs/superpowers/specs/2026-08-06-…-design.md` | usunięcie 2.1.4 i 2.5.7 z wykazu odroczonych |
+| `docs/superpowers/specs/2026-08-05-…-design.md` | jw. |
+
+---
+
+### Task 1: Moduł preferencji skrótów
+
+**Files:**
+- Create: `src/bpp/static/bpp/js/skroty-klawiszowe.js`
+- Test: `tests/js/skroty-klawiszowe.test.js`
+
+**Interfaces:**
+- Consumes: nic
+- Produces: trzy funkcje na `window`:
+  - `bppSkrotyWlaczone()` → `boolean`
+  - `bppUstawSkroty(wlaczone: boolean)` → `boolean` (nowy stan)
+  - `bppPodepnijPrzelacznikSkrotow(el: HTMLElement)` → `void`
+
+  Używane w Task 2 (szablony) i Task 6 (Playwright).
+
+- [ ] **Step 1: Napisz testy vitest**
+
+Utwórz `tests/js/skroty-klawiszowe.test.js`:
+
+```javascript
+// @vitest-environment jsdom
+//
+// Preferencja skrotow jednoznakowych (WCAG 2.1.4). Kryterium wymaga, zeby
+// uzytkownik mogl skrot wylaczyc — BPP w czesci publicznej nie ma kont, wiec
+// preferencja siedzi w localStorage. Domyslka to "wlaczone": brak wpisu nie
+// moze zmieniac zachowania nikomu, kto nic nie ustawil.
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+const ZRODLO = readFileSync(
+    resolve(__dirname, "../../src/bpp/static/bpp/js/skroty-klawiszowe.js"),
+    "utf-8"
+);
+
+function zaladuj() {
+    // Modul jest skryptem window-globalnym (IIFE), nie modulem ESM —
+    // wykonujemy go na biezacym window jsdom.
+    new Function(ZRODLO).call(window);
+    return window;
+}
+
+beforeEach(() => {
+    window.localStorage.clear();
+    delete window.bppSkrotyWlaczone;
+    delete window.bppUstawSkroty;
+    delete window.bppPodepnijPrzelacznikSkrotow;
+});
+
+describe("bppSkrotyWlaczone", () => {
+    it("domyslnie wlaczone gdy brak wpisu", () => {
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(true);
+    });
+
+    it('"0" wylacza', () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "0");
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(false);
+    });
+
+    it('"1" wlacza', () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "1");
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(true);
+    });
+
+    it("smiec w localStorage traktowany jak brak wpisu", () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "tak");
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(true);
+    });
+
+    it("nie rzuca gdy localStorage niedostepny", () => {
+        const oryginalny = window.localStorage.getItem;
+        window.localStorage.getItem = () => {
+            throw new Error("SecurityError");
+        };
+        const w = zaladuj();
+        expect(w.bppSkrotyWlaczone()).toBe(true);
+        window.localStorage.getItem = oryginalny;
+    });
+});
+
+describe("bppUstawSkroty", () => {
+    it("zapisuje wylaczenie i zwraca nowy stan", () => {
+        const w = zaladuj();
+        expect(w.bppUstawSkroty(false)).toBe(false);
+        expect(window.localStorage.getItem("bpp.skrotyJednoznakowe")).toBe("0");
+        expect(w.bppSkrotyWlaczone()).toBe(false);
+    });
+
+    it("zapisuje wlaczenie", () => {
+        const w = zaladuj();
+        w.bppUstawSkroty(false);
+        expect(w.bppUstawSkroty(true)).toBe(true);
+        expect(window.localStorage.getItem("bpp.skrotyJednoznakowe")).toBe("1");
+    });
+
+    it("nie rzuca gdy zapis niemozliwy", () => {
+        const oryginalny = window.localStorage.setItem;
+        window.localStorage.setItem = () => {
+            throw new Error("QuotaExceededError");
+        };
+        const w = zaladuj();
+        expect(() => w.bppUstawSkroty(false)).not.toThrow();
+        window.localStorage.setItem = oryginalny;
+    });
+});
+
+describe("bppPodepnijPrzelacznikSkrotow", () => {
+    function przycisk() {
+        const el = window.document.createElement("button");
+        window.document.body.appendChild(el);
+        return el;
+    }
+
+    it("ustawia stan poczatkowy na wlaczony", () => {
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        expect(el.getAttribute("aria-pressed")).toBe("true");
+        expect(el.textContent).toContain("włączone");
+    });
+
+    it("klik wylacza skroty i aktualizuje etykiete", () => {
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        el.click();
+        expect(w.bppSkrotyWlaczone()).toBe(false);
+        expect(el.getAttribute("aria-pressed")).toBe("false");
+        expect(el.textContent).toContain("wyłączone");
+    });
+
+    it("drugi klik wraca do stanu wyjsciowego", () => {
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        el.click();
+        el.click();
+        expect(w.bppSkrotyWlaczone()).toBe(true);
+        expect(el.getAttribute("aria-pressed")).toBe("true");
+    });
+
+    it("odzwierciedla stan zapisany wczesniej", () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "0");
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        expect(el.getAttribute("aria-pressed")).toBe("false");
+    });
+});
+```
+
+- [ ] **Step 2: Uruchom testy — muszą paść**
+
+```bash
+cd /Volumes/SSD/Programowanie/bpp-wcag-faza2
+npx vitest run tests/js/skroty-klawiszowe.test.js
+```
+
+Oczekiwane: FAIL — brak pliku `skroty-klawiszowe.js`.
+
+- [ ] **Step 3: Napisz moduł**
+
+Utwórz `src/bpp/static/bpp/js/skroty-klawiszowe.js`:
+
+```javascript
+/**
+ * Preferencja skrotow jednoznakowych (WCAG 2.1.4 Character Key Shortcuts).
+ *
+ * Kryterium wymaga, zeby skrot zlozony z samych znakow drukowalnych dalo sie
+ * wylaczyc, przemapowac albo ograniczyc do focusa komponentu. Skrot `/`
+ * otwierajacy wyszukiwarke globalna wisi na `document`, wiec wybieramy
+ * pierwsza droge.
+ *
+ * BPP w czesci publicznej nie ma kont uzytkownikow (GitHub i Gmail trzymaja
+ * taka preferencje w profilu), wiec zapisujemy ja w localStorage. Kryterium
+ * nie wymaga trwalosci miedzy urzadzeniami — tylko istnienia mechanizmu.
+ *
+ * Domyslka: WLACZONE. Brak wpisu nie moze zmieniac zachowania nikomu, kto
+ * nic nie ustawil.
+ */
+(function (window) {
+    "use strict";
+
+    var KLUCZ = "bpp.skrotyJednoznakowe";
+    var ETYKIETA_WL = "Skróty klawiszowe: włączone";
+    var ETYKIETA_WYL = "Skróty klawiszowe: wyłączone";
+
+    function bppSkrotyWlaczone() {
+        try {
+            return window.localStorage.getItem(KLUCZ) !== "0";
+        } catch (e) {
+            // Tryb prywatny, wylaczone ciasteczka, wyczerpany limit —
+            // degradujemy do domyslki zamiast wywracac obsluge klawisza.
+            return true;
+        }
+    }
+
+    function bppUstawSkroty(wlaczone) {
+        try {
+            window.localStorage.setItem(KLUCZ, wlaczone ? "1" : "0");
+        } catch (e) {
+            // Zapis niemozliwy — preferencja nie przetrwa przeladowania,
+            // ale biezaca sesja i tak dziala na zwroconej wartosci.
+        }
+        return !!wlaczone;
+    }
+
+    function bppPodepnijPrzelacznikSkrotow(el) {
+        if (!el) {
+            return;
+        }
+
+        function odswiez() {
+            var wl = bppSkrotyWlaczone();
+            el.setAttribute("aria-pressed", wl ? "true" : "false");
+            el.textContent = wl ? ETYKIETA_WL : ETYKIETA_WYL;
+        }
+
+        el.addEventListener("click", function () {
+            bppUstawSkroty(!bppSkrotyWlaczone());
+            odswiez();
+        });
+
+        odswiez();
+    }
+
+    window.bppSkrotyWlaczone = bppSkrotyWlaczone;
+    window.bppUstawSkroty = bppUstawSkroty;
+    window.bppPodepnijPrzelacznikSkrotow = bppPodepnijPrzelacznikSkrotow;
+})(typeof window !== "undefined" ? window : this);
+```
+
+- [ ] **Step 4: Uruchom testy — muszą przejść**
+
+```bash
+npx vitest run tests/js/skroty-klawiszowe.test.js
+```
+
+Oczekiwane: 13 passed.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/bpp/static/bpp/js/skroty-klawiszowe.js \
+    tests/js/skroty-klawiszowe.test.js
+git commit -m "feat(wcag): modul preferencji skrotow jednoznakowych (2.1.4)"
+```
+
+---
+
+### Task 2: Podpięcie preferencji do wszystkich handlerów `/`
+
+Skrót obsługiwany jest w trzech publicznych miejscach. Objęcie warunkiem
+jednego nie da nic — pozostałe zareagują niezależnie.
+
+**Files:**
+- Modify: `src/django_bpp/templates/base.html:19` (dodanie `<script src>`), `:37-51` (usunięcie handlera)
+- Modify: `src/django_bpp/templates/global_search_modal.html:1040-1052`
+- Modify: `src/bpp/templates/browse/uczelnia.html:96-142`
+- Modify: `src/django_bpp/templates/base_footer.html`
+- Test: `src/bpp/tests/test_wcag/test_skrot_szukania.py`
+
+**Interfaces:**
+- Consumes: `window.bppSkrotyWlaczone()`, `window.bppPodepnijPrzelacznikSkrotow(el)` z Task 1
+- Produces: przycisk `#bpp-przelacznik-skrotow` w stopce (używany w Task 6)
+
+- [ ] **Step 1: Napisz testy szablonowe**
+
+Utwórz `src/bpp/tests/test_wcag/test_skrot_szukania.py`:
+
+```python
+"""WCAG 2.1.4 — mechanizm wyłączania skrótu `/`.
+
+Skrót obsługiwany był w trzech publicznych miejscach naraz; dwa z nich
+(`base.html` i `global_search_modal.html`) otwierały wyszukiwarkę
+niezależnie, więc na jedno naciśnięcie `openGlobalSearch` wołane było
+dwukrotnie. Duplikat zlikwidowano — zostaje handler w modalu.
+
+Testy pilnują trzech rzeczy: modułu preferencji faktycznie podpiętego,
+przełącznika w stopce oraz braku powrotu usuniętego handlera.
+"""
+
+from pathlib import Path
+
+import pytest
+from django.template.loader import render_to_string
+
+SZABLONY = Path(__file__).resolve().parents[3] / "django_bpp" / "templates"
+
+
+def _tresc(nazwa):
+    return (SZABLONY / nazwa).read_text(encoding="utf-8")
+
+
+def test_modul_skrotow_podpiety_w_base():
+    # Bez tego tagu przełącznik i warunki w handlerach przestają działać,
+    # a żaden inny test by tego nie wykrył.
+    assert "skroty-klawiszowe.js" in _tresc("base.html")
+
+
+def test_base_nie_ma_juz_wlasnego_handlera_skrotu():
+    # Dowód likwidacji duplikatu: handler żyje wyłącznie w modalu.
+    tresc = _tresc("base.html")
+    assert "e.key === '/'" not in tresc
+
+
+def test_modal_pyta_o_preferencje():
+    tresc = _tresc("global_search_modal.html")
+    assert "e.key === '/'" in tresc
+    assert "bppSkrotyWlaczone" in tresc
+
+
+def test_modal_ma_guard_typeof():
+    # Gdy moduł się nie załaduje, gołe wywołanie rzucałoby TypeError przy
+    # każdym naciśnięciu `/` i skrót umarłby po cichu.
+    assert "typeof window.bppSkrotyWlaczone" in _tresc("global_search_modal.html")
+
+
+@pytest.mark.django_db
+def test_stopka_ma_przelacznik(client):
+    html = render_to_string("base_footer.html", {})
+
+    assert 'id="bpp-przelacznik-skrotow"' in html
+    assert 'aria-pressed' in html
+    assert 'type="button"' in html
+```
+
+- [ ] **Step 2: Uruchom testy — muszą paść**
+
+```bash
+uv run pytest src/bpp/tests/test_wcag/test_skrot_szukania.py -v
+```
+
+Oczekiwane: FAIL na wszystkich poza `test_modal_pyta_o_preferencje`
+(częściowo — `e.key === '/'` już tam jest, `bppSkrotyWlaczone` jeszcze nie).
+
+- [ ] **Step 3: Dodaj `<script src>` modułu w `base.html`**
+
+W `src/django_bpp/templates/base.html`, obok istniejącego tagu w linii 19
+(`formdefaults/modal.js`), dopisz:
+
+```django
+        <script src="{% static 'bpp/js/skroty-klawiszowe.js' %}"></script>
+```
+
+Bez `defer` — moduł musi być dostępny, gdy handlery sprawdzają preferencję
+przy naciśnięciu klawisza, a przełącznik w stopce podpina się po
+`DOMContentLoaded`.
+
+- [ ] **Step 4: Usuń zduplikowany handler z `base.html`**
+
+W `src/django_bpp/templates/base.html` usuń CAŁY blok (linie 37-51):
+
+```django
+    <script type="text/javascript">
+        // Global search hotkey handler
+        document.addEventListener('DOMContentLoaded', function() {
+            document.addEventListener('keydown', function(e) {
+                // Check if "/" key is pressed and not in an input field
+                if (e.key === '/' && !$(e.target).is('input, textarea, select')) {
+                    e.preventDefault(); // Prevent default search behavior
+                    if (typeof openGlobalSearch === 'function') {
+                        openGlobalSearch(null, true); // Pass true to indicate keyboard trigger
+                    }
+                }
+            });
+        });
+    </script>
+```
+
+Handler w `global_search_modal.html` robi to samo i dodatkowo sprawdza stan
+modala. Zostawienie obu oznacza dwa wywołania `openGlobalSearch` na jedno
+naciśnięcie klawisza.
+
+- [ ] **Step 5: Dodaj warunek w `global_search_modal.html`**
+
+W `src/django_bpp/templates/global_search_modal.html`, linie 1047-1052,
+zamień:
+
+```javascript
+            // Check for "/" key (forward slash)
+            if (e.key === '/' && !$('#globalSearchModal').hasClass('show')) {
+                e.preventDefault();
+                openGlobalSearch(null, true); // Pass true to indicate keyboard trigger
+            }
+```
+
+na:
+
+```javascript
+            // Check for "/" key (forward slash)
+            // WCAG 2.1.4: skrot jednoznakowy musi dac sie wylaczyc.
+            // Guard `typeof` — gdy modul sie nie zaladuje, degradujemy do
+            // zachowania dotychczasowego zamiast rzucac TypeError.
+            var skrotyWl = (typeof window.bppSkrotyWlaczone !== 'function'
+                            || window.bppSkrotyWlaczone());
+            if (e.key === '/' && skrotyWl
+                && !$('#globalSearchModal').hasClass('show')) {
+                e.preventDefault();
+                openGlobalSearch(null, true); // Pass true to indicate keyboard trigger
+            }
+```
+
+- [ ] **Step 6: Dodaj warunek w `browse/uczelnia.html`**
+
+Dwie zmiany w `src/bpp/templates/browse/uczelnia.html`.
+
+Pierwsza — handler zamykający baner (linie 134-141), zamień:
+
+```javascript
+    document.addEventListener('keydown', function(e) {
+        if (e.key === '/' && !$(e.target).is('input, textarea, select')) {
+```
+
+na:
+
+```javascript
+    document.addEventListener('keydown', function(e) {
+        var skrotyWl = (typeof window.bppSkrotyWlaczone !== 'function'
+                        || window.bppSkrotyWlaczone());
+        if (e.key === '/' && skrotyWl && !$(e.target).is('input, textarea, select')) {
+```
+
+Druga — pokazywanie banera (linie 102-108). Baner reklamuje skrót
+(„Wciśnij klawisz `/`…"), więc przy wyłączonych skrótach nie może się
+pojawiać. Zamień:
+
+```javascript
+        if (!bannerDismissed || (dismissedDate && daysSince(dismissedDate) > 30)) {
+```
+
+na:
+
+```javascript
+        // WCAG 2.1.4: nie reklamuj skrotu, ktory uzytkownik wylaczyl.
+        var skrotyWl = (typeof window.bppSkrotyWlaczone !== 'function'
+                        || window.bppSkrotyWlaczone());
+        if (skrotyWl
+            && (!bannerDismissed || (dismissedDate && daysSince(dismissedDate) > 30))) {
+```
+
+- [ ] **Step 7: Dodaj przycisk w stopce**
+
+W `src/django_bpp/templates/base_footer.html`, wewnątrz
+`<div class="footer__content">`, przed blokiem
+`{% if uczelnia.pokazuj_deklaracje_dostepnosci == 1 %}`, dodaj:
+
+```django
+            {# WCAG 2.1.4: mechanizm wylaczenia skrotow jednoznakowych. #}
+            {# Stopka, bo strona deklaracji dostepnosci jest opcjonalna #}
+            {# (Uczelnia.pokazuj_deklaracje_dostepnosci) i bywa zewnetrzna. #}
+            <button type="button" id="bpp-przelacznik-skrotow"
+                    class="footer__link-button" aria-pressed="true">Skróty klawiszowe: włączone</button> |
+```
+
+Na końcu pliku dodaj podpięcie:
+
+```django
+<script type="text/javascript">
+    document.addEventListener('DOMContentLoaded', function () {
+        if (typeof window.bppPodepnijPrzelacznikSkrotow === 'function') {
+            window.bppPodepnijPrzelacznikSkrotow(
+                document.getElementById('bpp-przelacznik-skrotow')
+            );
+        }
+    });
+</script>
+```
+
+- [ ] **Step 8: Dodaj styl przycisku**
+
+Przycisk ma wyglądać jak sąsiednie linki stopki, nie jak przycisk
+formularza. W `src/bpp/static/scss/base_footer.scss` (bez podkreślnika —
+tak nazywa się w tym projekcie, mimo że część partiali ma prefiks) dopisz:
+
+```scss
+// Przelacznik skrotow klawiszowych (WCAG 2.1.4) ma wygladac jak sasiednie
+// linki stopki — jest <button>, bo zmienia stan aplikacji, a nie nawiguje.
+.footer__link-button {
+    background: none;
+    border: none;
+    padding: 0;
+    margin: 0;
+    font: inherit;
+    color: inherit;
+    text-decoration: underline;
+    cursor: pointer;
+}
+```
+
+Jeżeli plik nazywa się inaczej, sprawdź:
+`ls src/bpp/static/scss/ | grep -i footer`.
+
+Następnie przebuduj CSS:
+
+```bash
+grunt build
+```
+
+- [ ] **Step 9: Uruchom testy — muszą przejść**
+
+```bash
+uv run pytest src/bpp/tests/test_wcag/test_skrot_szukania.py -v
+npx vitest run tests/js/skroty-klawiszowe.test.js
+```
+
+Oczekiwane: 5 passed (pytest), 13 passed (vitest).
+
+- [ ] **Step 10: Regresja szablonów**
+
+```bash
+uv run pytest src/bpp/tests/test_views/ -q
+```
+
+Oczekiwane: bez nowych błędów.
+
+- [ ] **Step 11: Commit**
+
+```bash
+git add src/django_bpp/templates/base.html \
+    src/django_bpp/templates/global_search_modal.html \
+    src/bpp/templates/browse/uczelnia.html \
+    src/django_bpp/templates/base_footer.html \
+    src/bpp/static/scss/ \
+    src/bpp/tests/test_wcag/test_skrot_szukania.py
+git commit -m "feat(wcag): przelacznik skrotow w stopce, likwidacja duplikatu handlera (2.1.4)"
+```
+
+---
+
+### Task 3: Moduł nawigacji po grafie
+
+**Files:**
+- Create: `src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js`
+- Test: `tests/js/nawigacja-grafu.test.js`
+
+**Interfaces:**
+- Consumes: nic
+- Produces: moduł ESM eksportujący:
+  - `przesun(cy, kierunek)` — `kierunek` ∈ `"gora" | "dol" | "lewo" | "prawo"`
+  - `zoomuj(cy, wspolczynnik)` — `wspolczynnik` > 1 przybliża, < 1 oddala
+  - `dopasuj(cy)`
+
+  Importowane w Task 4 (przyciski) i Task 5 (klawiatura).
+
+- [ ] **Step 1: Napisz testy vitest**
+
+Utwórz `tests/js/nawigacja-grafu.test.js`:
+
+```javascript
+// Nawigacja po grafie powiazan bez przeciagania (WCAG 2.5.7) i z klawiatury
+// (2.1.1). Modul operuje na instancji Cytoscape przez jej publiczne API,
+// wiec testujemy go na atrapie — bez uruchamiania biblioteki.
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+    przesun,
+    zoomuj,
+    dopasuj
+} from "../../src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js";
+
+function atrapaCy(opcje) {
+    opcje = opcje || {};
+    const stan = {
+        panBy: null,
+        zoomArg: null,
+        fitWolane: false,
+        poziomZoom: opcje.zoom === undefined ? 1 : opcje.zoom
+    };
+    return {
+        _stan: stan,
+        width: () => (opcje.width === undefined ? 1000 : opcje.width),
+        height: () => (opcje.height === undefined ? 500 : opcje.height),
+        minZoom: () => 0.1,
+        maxZoom: () => 4,
+        zoom: function (arg) {
+            if (arg === undefined) {
+                return stan.poziomZoom;
+            }
+            stan.zoomArg = arg;
+            stan.poziomZoom = arg.level;
+            return undefined;
+        },
+        panBy: function (arg) {
+            stan.panBy = arg;
+        },
+        fit: function () {
+            stan.fitWolane = true;
+        }
+    };
+}
+
+describe("przesun", () => {
+    let cy;
+    beforeEach(() => {
+        cy = atrapaCy();
+    });
+
+    it("w prawo przesuwa widok w lewo (ujemny x)", () => {
+        przesun(cy, "prawo");
+        expect(cy._stan.panBy.x).toBeLessThan(0);
+        expect(cy._stan.panBy.y).toBe(0);
+    });
+
+    it("w lewo przesuwa widok w prawo (dodatni x)", () => {
+        przesun(cy, "lewo");
+        expect(cy._stan.panBy.x).toBeGreaterThan(0);
+        expect(cy._stan.panBy.y).toBe(0);
+    });
+
+    it("w dol przesuwa widok w gore (ujemny y)", () => {
+        przesun(cy, "dol");
+        expect(cy._stan.panBy.y).toBeLessThan(0);
+        expect(cy._stan.panBy.x).toBe(0);
+    });
+
+    it("w gore przesuwa widok w dol (dodatni y)", () => {
+        przesun(cy, "gora");
+        expect(cy._stan.panBy.y).toBeGreaterThan(0);
+        expect(cy._stan.panBy.x).toBe(0);
+    });
+
+    it("krok skaluje sie z szerokoscia widoku", () => {
+        const waski = atrapaCy({ width: 500 });
+        const szeroki = atrapaCy({ width: 2000 });
+        przesun(waski, "prawo");
+        przesun(szeroki, "prawo");
+        expect(Math.abs(szeroki._stan.panBy.x)).toBeGreaterThan(
+            Math.abs(waski._stan.panBy.x)
+        );
+    });
+
+    it("nieznany kierunek nic nie robi", () => {
+        przesun(cy, "wszedzie");
+        expect(cy._stan.panBy).toBeNull();
+    });
+});
+
+describe("zoomuj", () => {
+    it("przyblizanie zwieksza poziom", () => {
+        const cy = atrapaCy({ zoom: 1 });
+        zoomuj(cy, 1.2);
+        expect(cy._stan.zoomArg.level).toBeCloseTo(1.2);
+    });
+
+    it("oddalanie zmniejsza poziom", () => {
+        const cy = atrapaCy({ zoom: 1 });
+        zoomuj(cy, 1 / 1.2);
+        expect(cy._stan.zoomArg.level).toBeLessThan(1);
+    });
+
+    it("nie przekracza maxZoom", () => {
+        const cy = atrapaCy({ zoom: 3.9 });
+        zoomuj(cy, 1.2);
+        expect(cy._stan.zoomArg.level).toBe(4);
+    });
+
+    it("nie schodzi ponizej minZoom", () => {
+        const cy = atrapaCy({ zoom: 0.11 });
+        zoomuj(cy, 1 / 1.2);
+        expect(cy._stan.zoomArg.level).toBe(0.1);
+    });
+
+    it("zoomuje wokol srodka widoku", () => {
+        const cy = atrapaCy({ width: 1000, height: 500 });
+        zoomuj(cy, 1.2);
+        expect(cy._stan.zoomArg.renderedPosition).toEqual({ x: 500, y: 250 });
+    });
+});
+
+describe("dopasuj", () => {
+    it("wola cy.fit()", () => {
+        const cy = atrapaCy();
+        dopasuj(cy);
+        expect(cy._stan.fitWolane).toBe(true);
+    });
+});
+```
+
+- [ ] **Step 2: Uruchom testy — muszą paść**
+
+```bash
+npx vitest run tests/js/nawigacja-grafu.test.js
+```
+
+Oczekiwane: FAIL — brak pliku `nawigacja.js`.
+
+- [ ] **Step 3: Napisz moduł**
+
+Utwórz
+`src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js`:
+
+```javascript
+// Nawigacja po grafie bez przeciagania (WCAG 2.5.7 Dragging Movements) oraz
+// z klawiatury (2.1.1 Keyboard). Kryterium 2.5.7 wymaga, zeby funkcje
+// dostepna przez przeciaganie dalo sie wykonac pojedynczym wskaznikiem —
+// stad przyciski. Te same funkcje obsluguja klawiature.
+//
+// Modul operuje wylacznie na publicznym API Cytoscape, wiec da sie go
+// przetestowac na atrapie, bez uruchamiania biblioteki.
+
+// Krok przesuniecia jako UDZIAL rozmiaru widoku, nie stala w pikselach:
+// przy duzym przyblizeniu stala byla by ledwo zauwazalna, przy oddaleniu
+// przeskakiwala by caly graf.
+const UDZIAL_KROKU = 0.2;
+
+export function przesun(cy, kierunek) {
+    const dx = cy.width() * UDZIAL_KROKU;
+    const dy = cy.height() * UDZIAL_KROKU;
+
+    // Znaki sa odwrocone wzgledem intuicji: `panBy` przesuwa PLOTNO,
+    // a przyciski opisuja ruch WIDOKU. "w prawo" = plotno w lewo.
+    switch (kierunek) {
+        case "prawo":
+            cy.panBy({ x: -dx, y: 0 });
+            break;
+        case "lewo":
+            cy.panBy({ x: dx, y: 0 });
+            break;
+        case "dol":
+            cy.panBy({ x: 0, y: -dy });
+            break;
+        case "gora":
+            cy.panBy({ x: 0, y: dy });
+            break;
+        default:
+            break;
+    }
+}
+
+export function zoomuj(cy, wspolczynnik) {
+    // Limity czytamy z instancji (utworzCy ustawia minZoom 0.1, maxZoom 4),
+    // zeby nie duplikowac ich w dwoch miejscach.
+    const docelowy = Math.min(
+        Math.max(cy.zoom() * wspolczynnik, cy.minZoom()),
+        cy.maxZoom()
+    );
+
+    cy.zoom({
+        level: docelowy,
+        renderedPosition: { x: cy.width() / 2, y: cy.height() / 2 }
+    });
+}
+
+export function dopasuj(cy) {
+    cy.fit();
+}
+```
+
+- [ ] **Step 4: Uruchom testy — muszą przejść**
+
+```bash
+npx vitest run tests/js/nawigacja-grafu.test.js
+```
+
+Oczekiwane: 12 passed.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js \
+    tests/js/nawigacja-grafu.test.js
+git commit -m "feat(wcag): modul nawigacji po grafie powiazan (2.5.7)"
+```
+
+---
+
+### Task 4: Przyciski nawigacji w grafie
+
+**Files:**
+- Modify: `src/powiazania_autorow/templates/powiazania_autorow/graf.html` (nakładka przed `</div>` zamykającym `#graf-wrapper`)
+- Modify: `src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js`
+- Create: `src/bpp/static/scss/graf_powiazan.scss`
+- Modify: `src/bpp/static/scss/common.scss`
+- Create: `src/powiazania_autorow/tests/__init__.py` (jeśli nie istnieje)
+- Test: `src/powiazania_autorow/tests/test_graf_dostepnosc.py`
+
+**Interfaces:**
+- Consumes: `przesun`, `zoomuj`, `dopasuj` z Task 3
+- Produces: siedem przycisków o identyfikatorach `graf-nav-gora`,
+  `graf-nav-dol`, `graf-nav-lewo`, `graf-nav-prawo`, `graf-nav-zoom-in`,
+  `graf-nav-zoom-out`, `graf-nav-dopasuj` (używane w Task 6)
+
+- [ ] **Step 1: Sprawdź, czy pakiet testów istnieje**
+
+```bash
+ls src/powiazania_autorow/tests/__init__.py 2>/dev/null \
+  || (mkdir -p src/powiazania_autorow/tests && touch src/powiazania_autorow/tests/__init__.py)
+```
+
+Uwaga: istniejące testy tej aplikacji leżą płasko
+(`src/powiazania_autorow/test_views.py`), ale nowy plik dotyczy dostępności i
+zyskuje na wydzieleniu.
+
+- [ ] **Step 2: Napisz testy szablonowe**
+
+Utwórz `src/powiazania_autorow/tests/test_graf_dostepnosc.py`:
+
+```python
+"""Dostępność grafu powiązań: nawigacja wskaźnikiem (2.5.7) i klawiaturą (2.1.1).
+
+Graf stoi na Cytoscape.js i do tej pory dawał się przesuwać wyłącznie
+przeciąganiem. Kryterium 2.5.7 wymaga alternatywy realizowanej pojedynczym
+wskaźnikiem — stąd przyciski. Sam kontener zyskuje `tabindex`, żeby te same
+funkcje dało się wywołać z klawiatury (2.1.1).
+"""
+
+from pathlib import Path
+
+SZABLON = (
+    Path(__file__).resolve().parents[1]
+    / "templates"
+    / "powiazania_autorow"
+    / "graf.html"
+)
+
+PRZYCISKI = [
+    "graf-nav-gora",
+    "graf-nav-dol",
+    "graf-nav-lewo",
+    "graf-nav-prawo",
+    "graf-nav-zoom-in",
+    "graf-nav-zoom-out",
+    "graf-nav-dopasuj",
+]
+
+
+def _tresc():
+    return SZABLON.read_text(encoding="utf-8")
+
+
+def test_wszystkie_przyciski_nawigacji_obecne():
+    tresc = _tresc()
+    for identyfikator in PRZYCISKI:
+        assert f'id="{identyfikator}"' in tresc, f"brak przycisku {identyfikator}"
+
+
+def test_kazdy_przycisk_ma_aria_label():
+    # Sam glif strzałki nic nie mówi czytnikowi ekranu.
+    tresc = _tresc()
+    fragmenty = tresc.split("<button")
+    nawigacyjne = [f for f in fragmenty if "graf-nav-" in f]
+
+    assert len(nawigacyjne) == len(PRZYCISKI)
+    for fragment in nawigacyjne:
+        assert "aria-label=" in fragment
+
+
+def test_przyciski_sa_typu_button():
+    # Bez type="button" przycisk wewnątrz formularza wysyła go.
+    tresc = _tresc()
+    for fragment in tresc.split("<button")[1:]:
+        if "graf-nav-" in fragment:
+            assert 'type="button"' in fragment
+
+
+def test_glify_ukryte_przed_czytnikiem():
+    # Treść dla czytnika jest w aria-label; glif to dekoracja.
+    tresc = _tresc()
+    for fragment in tresc.split("<button")[1:]:
+        if "graf-nav-" in fragment:
+            assert 'aria-hidden="true"' in fragment
+```
+
+- [ ] **Step 3: Uruchom testy — muszą paść**
+
+```bash
+uv run pytest src/powiazania_autorow/tests/test_graf_dostepnosc.py -v
+```
+
+Oczekiwane: FAIL — brak przycisków w szablonie.
+
+- [ ] **Step 4: Dodaj nakładkę do `graf.html`**
+
+W `src/powiazania_autorow/templates/powiazania_autorow/graf.html`, wewnątrz
+`#graf-wrapper`, bezpośrednio po bloku `#graf-notka` (kończącym się w linii
+199) a przed `</div>` zamykającym wrapper, wstaw:
+
+```django
+        {# WCAG 2.5.7: nawigacja bez przeciagania. Prawy dolny rog to #}
+        {# jedyny wolny — lewy gorny zajmuje #graf-panel, prawy gorny #}
+        {# #graf-legenda, lewy dolny #graf-notka (przy przycietej sieci). #}
+        <div id="graf-nawigacja" class="graf-nawigacja">
+            <button type="button" id="graf-nav-gora" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w górę"><span aria-hidden="true">↑</span></button>
+            <button type="button" id="graf-nav-lewo" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w lewo"><span aria-hidden="true">←</span></button>
+            <button type="button" id="graf-nav-dopasuj" class="graf-nawigacja__btn"
+                    aria-label="Dopasuj graf do ekranu"><span aria-hidden="true">⤢</span></button>
+            <button type="button" id="graf-nav-prawo" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w prawo"><span aria-hidden="true">→</span></button>
+            <button type="button" id="graf-nav-dol" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w dół"><span aria-hidden="true">↓</span></button>
+            <button type="button" id="graf-nav-zoom-in" class="graf-nawigacja__btn"
+                    aria-label="Przybliż"><span aria-hidden="true">+</span></button>
+            <button type="button" id="graf-nav-zoom-out" class="graf-nawigacja__btn"
+                    aria-label="Oddal"><span aria-hidden="true">−</span></button>
+        </div>
+```
+
+- [ ] **Step 5: Utwórz partial SCSS**
+
+Utwórz `src/bpp/static/scss/graf_powiazan.scss`:
+
+```scss
+// Nakladka nawigacji po grafie powiazan (WCAG 2.5.7) oraz pierscien focusa
+// kontenera grafu (2.4.7). Aplikacja powiazania_autorow nie ma wlasnego
+// katalogu SCSS — graf.html opisuje wyglad atrybutami style="" — ale
+// :focus-visible wymaga arkusza, wiec komponent siedzi w calosci tutaj.
+
+.graf-nawigacja {
+    position: absolute;
+    right: 10px;
+    bottom: 10px;
+    z-index: 1001;
+
+    display: grid;
+    grid-template-columns: repeat(3, auto);
+    gap: 2px;
+
+    padding: 6px;
+    background: rgba(255, 255, 255, 0.92);
+    border: 1px solid #ddd;
+    border-radius: 4px;
+}
+
+.graf-nawigacja__btn {
+    // WCAG 2.5.8 (Target Size Minimum): cel dotykowy nie mniejszy niz
+    // 24x24 px CSS. Naprawiajac 2.5.7 nie wolno zlamac sasiedniego
+    // kryterium.
+    min-width: 28px;
+    min-height: 28px;
+
+    padding: 0;
+    margin: 0;
+    font-size: 15px;
+    line-height: 1;
+
+    background: #fff;
+    border: 1px solid #ccc;
+    border-radius: 3px;
+    color: #333;
+    cursor: pointer;
+
+    &:hover {
+        background: #f0f0f0;
+    }
+
+    &:focus-visible {
+        outline: 2px solid #2c6cb0;
+        outline-offset: 1px;
+    }
+}
+
+// WCAG 2.4.7: uzytkownik klawiatury musi widziec, ze graf przejal focus —
+// inaczej nie wie, ze strzalki zaczely dzialac.
+#cytoscape-container:focus-visible {
+    outline: 3px solid #2c6cb0;
+    outline-offset: -3px;
+}
+```
+
+- [ ] **Step 6: Zaimportuj partial**
+
+W `src/bpp/static/scss/common.scss`, obok pozostałych importów (linie 7-18),
+dopisz:
+
+```scss
+@import "graf_powiazan";
+```
+
+- [ ] **Step 7: Podepnij przyciski w `controls.js`**
+
+W
+`src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js`
+dopisz import na górze, obok istniejących:
+
+```javascript
+import { przesun, zoomuj, dopasuj } from "./nawigacja.js";
+```
+
+Na końcu funkcji `podepnijZdarzenia(ctx)`, przed zamykającym `}`, dopisz:
+
+```javascript
+    // --- nawigacja bez przeciagania (WCAG 2.5.7) ---
+    const KIERUNKI = {
+        "graf-nav-gora": "gora",
+        "graf-nav-dol": "dol",
+        "graf-nav-lewo": "lewo",
+        "graf-nav-prawo": "prawo"
+    };
+    Object.keys(KIERUNKI).forEach(function (id) {
+        const btn = document.getElementById(id);
+        if (btn) {
+            btn.addEventListener("click", function () {
+                przesun(cy, KIERUNKI[id]);
+            });
+        }
+    });
+
+    const btnZoomIn = document.getElementById("graf-nav-zoom-in");
+    if (btnZoomIn) {
+        btnZoomIn.addEventListener("click", function () {
+            zoomuj(cy, 1.2);
+        });
+    }
+
+    const btnZoomOut = document.getElementById("graf-nav-zoom-out");
+    if (btnZoomOut) {
+        btnZoomOut.addEventListener("click", function () {
+            zoomuj(cy, 1 / 1.2);
+        });
+    }
+
+    const btnDopasuj = document.getElementById("graf-nav-dopasuj");
+    if (btnDopasuj) {
+        btnDopasuj.addEventListener("click", function () {
+            dopasuj(cy);
+        });
+    }
+```
+
+- [ ] **Step 8: Przebuduj front i uruchom testy**
+
+```bash
+grunt build
+uv run pytest src/powiazania_autorow/tests/test_graf_dostepnosc.py -v
+npx vitest run tests/js/nawigacja-grafu.test.js
+```
+
+Oczekiwane: 4 passed (pytest), 12 passed (vitest).
+
+- [ ] **Step 9: Commit**
+
+```bash
+git add src/powiazania_autorow/templates/powiazania_autorow/graf.html \
+    src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js \
+    src/bpp/static/scss/graf_powiazan.scss \
+    src/bpp/static/scss/common.scss \
+    src/powiazania_autorow/tests/
+git commit -m "feat(wcag): przyciski nawigacji po grafie bez przeciagania (2.5.7)"
+```
+
+---
+
+### Task 5: Obsługa grafu klawiaturą
+
+**Files:**
+- Modify: `src/powiazania_autorow/templates/powiazania_autorow/graf.html:158-166` (atrybuty kontenera)
+- Modify: `src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js` (handler `keydown`)
+- Test: `src/powiazania_autorow/tests/test_graf_dostepnosc.py` (dopisanie)
+
+**Interfaces:**
+- Consumes: `przesun`, `zoomuj`, `dopasuj` z Task 3
+- Produces: nic dla dalszych zadań
+
+- [ ] **Step 1: Dopisz testy**
+
+Do `src/powiazania_autorow/tests/test_graf_dostepnosc.py` dopisz:
+
+```python
+def test_kontener_grafu_jest_fokusowalny():
+    # Bez tabindex użytkownik klawiatury nigdy nie dotrze do grafu.
+    tresc = _tresc()
+    fragment = tresc.split('id="cytoscape-container"')[1][:600]
+
+    assert 'tabindex="0"' in fragment
+
+
+def test_kontener_grafu_ma_role_application():
+    # Bez tego czytnik ekranu w trybie przeglądania sam obsłuży strzałki
+    # i nigdy nie dotrą one do grafu.
+    tresc = _tresc()
+    fragment = tresc.split('id="cytoscape-container"')[1][:600]
+
+    assert 'role="application"' in fragment
+
+
+def test_kontener_grafu_opisuje_dostepne_klawisze():
+    # role="application" wycisza tryb przeglądania, więc aria-label jest
+    # jedynym sposobem, w jaki użytkownik pozna dostępne klawisze.
+    tresc = _tresc()
+    fragment = tresc.split('id="cytoscape-container"')[1][:600]
+
+    assert "aria-label=" in fragment
+    for slowo in ("trzałk", "Home"):
+        assert slowo in fragment
+```
+
+- [ ] **Step 2: Uruchom testy — muszą paść**
+
+```bash
+uv run pytest src/powiazania_autorow/tests/test_graf_dostepnosc.py -v
+```
+
+Oczekiwane: trzy nowe FAIL.
+
+- [ ] **Step 3: Dodaj atrybuty kontenera**
+
+W `src/powiazania_autorow/templates/powiazania_autorow/graf.html`, element
+`#cytoscape-container` (linie 158-166), dopisz trzy atrybuty przed
+`style=`:
+
+```django
+             tabindex="0"
+             role="application"
+             aria-label="Graf powiązań autorów. Strzałki przesuwają widok, plus i minus przybliżają, klawisz Home dopasowuje graf do ekranu."
+```
+
+- [ ] **Step 4: Dodaj handler klawiatury w `controls.js`**
+
+Na końcu funkcji `podepnijZdarzenia(ctx)`, po kodzie przycisków z Task 4,
+dopisz:
+
+```javascript
+    // --- obsluga klawiatura (WCAG 2.1.1) ---
+    // Klawisze `+`/`-` sa znakami drukowalnymi, wiec podlegaja tez 2.1.4 —
+    // spelniaja je trzecim wariantem kryterium: dzialaja WYLACZNIE gdy
+    // kontener grafu ma focus, bo handler wisi na nim, nie na `document`.
+    const kontener = document.getElementById("cytoscape-container");
+    if (kontener) {
+        kontener.addEventListener("keydown", function (e) {
+            let obsluzone = true;
+
+            switch (e.key) {
+                case "ArrowUp": przesun(cy, "gora"); break;
+                case "ArrowDown": przesun(cy, "dol"); break;
+                case "ArrowLeft": przesun(cy, "lewo"); break;
+                case "ArrowRight": przesun(cy, "prawo"); break;
+                case "+":
+                case "=": zoomuj(cy, 1.2); break;
+                case "-":
+                case "_": zoomuj(cy, 1 / 1.2); break;
+                case "Home": dopasuj(cy); break;
+                default: obsluzone = false;
+            }
+
+            // preventDefault WYLACZNIE dla obsluzonych klawiszy. Blokowanie
+            // wszystkiego zamknelo by Tab w grafie, czyli naprawiajac 2.1.1
+            // stworzylibysmy pulapke klawiaturowa i zlamali 2.1.2.
+            if (obsluzone) {
+                e.preventDefault();
+            }
+        });
+    }
+```
+
+Warianty `=` i `_` są obok `+` i `-`, bo na większości układów klawiatury
+`+` wymaga Shift.
+
+- [ ] **Step 5: Przebuduj front i uruchom testy**
+
+```bash
+grunt build
+uv run pytest src/powiazania_autorow/tests/test_graf_dostepnosc.py -v
+```
+
+Oczekiwane: 7 passed.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/powiazania_autorow/templates/powiazania_autorow/graf.html \
+    src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js \
+    src/powiazania_autorow/tests/test_graf_dostepnosc.py
+git commit -m "feat(wcag): obsluga grafu powiazan klawiatura (2.1.1, 2.4.7)"
+```
+
+---
+
+### Task 6: Testy Playwright
+
+Testy szablonowe i jednostkowe nie dowodzą, że mechanizm **działa**. Bez
+tego zadania usunięcie warunku z handlera nie wywaliłoby niczego.
+
+**Files:**
+- Create: `src/integration_tests/test_wcag_skrot_i_graf.py`
+
+**Interfaces:**
+- Consumes: `#bpp-przelacznik-skrotow` (Task 2), `#graf-nav-*` (Task 4),
+  `tabindex` na `#cytoscape-container` (Task 5)
+- Produces: nic
+
+- [ ] **Step 1: Poznaj wzorzec z tego projektu**
+
+Sygnatura testu przeglądarkowego w BPP (z
+`src/integration_tests/test_siec3d_bez_webgl.py:44-57`):
+
+```python
+@pytest.mark.django_db(transaction=True)
+def test_cos(channels_live_server, page: Page, transactional_db):
+    autor = baker.make(Autor, imiona="Jan", nazwisko="Kowalski", pokazuj=True)
+    url = reverse("bpp:browse_autor_powiazania", args=[autor.pk])
+    page.goto(f"{channels_live_server.url}{url}", wait_until="domcontentloaded")
+```
+
+Trzy fixture: `channels_live_server`, `page: Page`, `transactional_db`.
+Autora tworzy się przez `baker.make(Autor, …, pokazuj=True)` — nie ma
+gotowej fixture autora dla tych testów. URL składa się przez f-string, bez
+`+`. Import: `from playwright.sync_api import Page, expect`.
+
+**Wymaganie wstępne:** `make assets` — bez zbudowanego bundla strona nie ma
+czego wykonać i testy padną.
+
+- [ ] **Step 2: Napisz testy**
+
+Utwórz `src/integration_tests/test_wcag_skrot_i_graf.py`:
+
+```python
+"""WCAG 2.1.4 i 2.5.7/2.1.1 — testy zachowania w przeglądarce.
+
+Testy szablonowe dowodzą, że kod jest w pliku; te dowodzą, że działa.
+Bez nich usunięcie warunku `bppSkrotyWlaczone()` z handlera albo
+`preventDefault` z obsługi klawiatury nie wywaliłoby żadnego testu.
+"""
+
+import pytest
+from django.urls import reverse
+from model_bakery import baker
+from playwright.sync_api import Page, expect
+
+from bpp.models import Autor
+
+
+def _url_autora(channels_live_server):
+    autor = baker.make(Autor, imiona="Jan", nazwisko="Kowalski", pokazuj=True)
+    return (
+        f"{channels_live_server.url}"
+        f"{reverse('bpp:browse_autor', args=[autor.slug])}"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_skrot_otwiera_wyszukiwarke_domyslnie(
+    channels_live_server, page: Page, transactional_db
+):
+    page.goto(_url_autora(channels_live_server), wait_until="domcontentloaded")
+
+    page.keyboard.press("/")
+
+    expect(page.locator("#globalSearchModal")).to_be_visible(timeout=5000)
+
+
+@pytest.mark.django_db(transaction=True)
+def test_wylaczenie_skrotu_dziala(
+    channels_live_server, page: Page, transactional_db
+):
+    page.goto(_url_autora(channels_live_server), wait_until="domcontentloaded")
+
+    page.locator("#bpp-przelacznik-skrotow").click()
+    page.keyboard.press("/")
+    page.wait_for_timeout(500)
+
+    expect(page.locator("#globalSearchModal")).not_to_be_visible()
+
+
+@pytest.mark.django_db(transaction=True)
+def test_ponowne_wlaczenie_przywraca_skrot(
+    channels_live_server, page: Page, transactional_db
+):
+    page.goto(_url_autora(channels_live_server), wait_until="domcontentloaded")
+
+    przelacznik = page.locator("#bpp-przelacznik-skrotow")
+    przelacznik.click()
+    przelacznik.click()
+    page.keyboard.press("/")
+
+    expect(page.locator("#globalSearchModal")).to_be_visible(timeout=5000)
+
+
+@pytest.mark.django_db(transaction=True)
+def test_przelacznik_aktualizuje_aria_pressed(
+    channels_live_server, page: Page, transactional_db
+):
+    page.goto(_url_autora(channels_live_server), wait_until="domcontentloaded")
+
+    przelacznik = page.locator("#bpp-przelacznik-skrotow")
+    expect(przelacznik).to_have_attribute("aria-pressed", "true")
+
+    przelacznik.click()
+    expect(przelacznik).to_have_attribute("aria-pressed", "false")
+
+
+@pytest.mark.django_db(transaction=True)
+def test_preferencja_przezywa_przeladowanie(
+    channels_live_server, page: Page, transactional_db
+):
+    url = _url_autora(channels_live_server)
+    page.goto(url, wait_until="domcontentloaded")
+
+    page.locator("#bpp-przelacznik-skrotow").click()
+    page.reload(wait_until="domcontentloaded")
+
+    expect(page.locator("#bpp-przelacznik-skrotow")).to_have_attribute(
+        "aria-pressed", "false"
+    )
+```
+
+Widok strony autora został wybrany zamiast strony uczelni, bo nie wymaga
+obiektu `Uczelnia` w bazie, a stopka i modal wyszukiwarki renderują się na
+nim tak samo. `bpp:browse_autor` ma dwa warianty URL-a — po `pk`
+(`urls.py:274`) i po `slug` (`urls.py:300`); `reverse` z argumentem `slug`
+trafia w drugi. `Autor` tworzony przez `baker.make` dostaje slug
+automatycznie (pole wyliczane przy zapisie).
+
+**Nie zamieniaj** testu zachowania na sprawdzenie obecności elementu w
+HTML-u — testy szablonowe z Task 2 już to pokrywają, ten plik ma dowodzić
+działania.
+
+- [ ] **Step 3: Uruchom testy**
+
+```bash
+make assets
+make playwright-install
+uv run pytest src/integration_tests/test_wcag_skrot_i_graf.py -v
+```
+
+Pierwszy przebieg bywa wolny (zimny start testcontenerów) i `page.goto`
+potrafi raz timeoutnąć — wtedy ponów.
+
+Jeżeli nazwa fixture live-servera albo widoku (`bpp:browse_uczelnia`) nie
+pasuje, dostosuj ją do wzorca z kroku 1 — ale **nie** zamieniaj testu
+zachowania na test obecności elementu w HTML-u. Testy szablonowe już to
+pokrywają; ten plik ma dowodzić działania.
+
+Jeżeli strona uczelni nie renderuje przełącznika (np. wymaga obiektu
+`Uczelnia` w bazie), utwórz go w teście przez `baker.make` albo użyj
+istniejącej fixture — sprawdź `src/fixtures/conftest_*.py`.
+
+- [ ] **Step 4: Dopisz test grafu**
+
+Do tego samego pliku dopisz:
+
+```python
+def _url_grafu(channels_live_server):
+    autor = baker.make(Autor, imiona="Jan", nazwisko="Kowalski", pokazuj=True)
+    return (
+        f"{channels_live_server.url}"
+        f"{reverse('bpp:browse_autor_powiazania', args=[autor.pk])}"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_ma_przyciski_nawigacji_i_jest_fokusowalny(
+    channels_live_server, page: Page, transactional_db
+):
+    page.goto(_url_grafu(channels_live_server), wait_until="domcontentloaded")
+
+    kontener = page.locator("#cytoscape-container")
+    expect(kontener).to_have_attribute("tabindex", "0")
+    expect(page.locator("#graf-nav-dopasuj")).to_be_visible(timeout=10000)
+
+    page.locator("#graf-nav-dopasuj").click()
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_nie_jest_pulapka_klawiaturowa(
+    channels_live_server, page: Page, transactional_db
+):
+    # Handler robi preventDefault WYŁĄCZNIE dla obsłużonych klawiszy. Gdyby
+    # blokował wszystko, Tab przestałby wyprowadzać focus — czyli naprawiając
+    # 2.1.1 stworzylibyśmy pułapkę klawiaturową i złamali 2.1.2.
+    page.goto(_url_grafu(channels_live_server), wait_until="domcontentloaded")
+
+    page.locator("#cytoscape-container").focus()
+    page.keyboard.press("Tab")
+
+    assert page.evaluate("document.activeElement.id") != "cytoscape-container"
+```
+
+Widok `bpp:browse_autor_powiazania` przyjmuje `pk` — potwierdzone w
+`test_siec3d_bez_webgl.py:67`, gdzie ten sam URL jest budowany przez
+`reverse("bpp:browse_autor_powiazania", args=[autor.pk])`.
+
+Jeżeli graf nie renderuje się dla autora bez powiązań i przyciski nie
+pojawią się w DOM, sprawdź warunek widoczności sieci
+(`Autor.czy_pokazywac_siec_powiazan`) i ustaw wymagane pole przez
+`baker.make`. Nakładka jest w szablonie statycznie, więc powinna być obecna
+niezależnie od danych — jeśli tak nie jest, zgłoś to jako znalezisko, bo
+oznaczałoby, że nawigacja znika akurat przy pustym grafie.
+
+- [ ] **Step 5: Uruchom całość i commit**
+
+```bash
+uv run pytest src/integration_tests/test_wcag_skrot_i_graf.py -v
+git add src/integration_tests/test_wcag_skrot_i_graf.py
+git commit -m "test(wcag): testy przegladarkowe skrotu i nawigacji po grafie"
+```
+
+---
+
+### Task 7: Wykaz odroczonych i newsfragment
+
+**Files:**
+- Modify: `docs/superpowers/specs/2026-08-06-wcag-naprawy-stwierdzone-design.md`
+- Modify: `docs/superpowers/specs/2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md`
+- Create: `src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst`
+
+**Interfaces:**
+- Consumes: nic
+- Produces: nic
+
+- [ ] **Step 1: Usuń 2.1.4 i 2.5.7 z wykazu w dokumencie 08-06**
+
+W sekcji „Wykaz odroczonych niezgodności" zastąp wpisy o 2.1.4 i 2.5.7
+jednym akapitem:
+
+```markdown
+**2.1.4 i 2.5.7 — domknięte 2026-08-07.**
+Oba kryteria zostały naprawione w kolejnej iteracji: skrót `/` dostał
+mechanizm wyłączania (localStorage + przełącznik w stopce), graf powiązań —
+przyciski nawigacji i obsługę klawiaturą. Szczegóły:
+`2026-08-07-wcag-skrot-i-graf-design.md`.
+```
+
+- [ ] **Step 2: To samo w dokumencie 08-05**
+
+Ten sam akapit w sekcji „Odroczone niezgodności".
+
+- [ ] **Step 3: Przejrzyj oba dokumenty pod kątem pozostałych wzmianek**
+
+Poprzednia iteracja pokazała, że dokument o rozbudowanej historii zostawia
+twierdzenia sprzeczne ze stanem faktycznym w miejscach, o których się nie
+myśli — trzy kolejne przejścia znajdowały kolejne.
+
+```bash
+grep -n "2\.1\.4\|2\.5\.7\|skrót\|skrot\|graf\|przeciąganie" \
+    docs/superpowers/specs/2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md \
+    docs/superpowers/specs/2026-08-06-wcag-naprawy-stwierdzone-design.md
+```
+
+Dla KAŻDEGO trafienia rozstrzygnij, czy twierdzenie jest nadal prawdziwe.
+Miejsca mówiące „odroczone", „niezgodne", „świadomie nie naprawiamy" dla
+tych dwóch kryteriów wymagają dopisku
+`**Korekta (2026-08-07):**` — zgodnie z konwencją przyjętą w tych
+dokumentach, bez usuwania oryginalnego tekstu.
+
+W raporcie wymień **wszystkie** sprawdzone miejsca, także uznane za
+niewymagające zmiany, z uzasadnieniem.
+
+- [ ] **Step 4: Napisz newsfragment**
+
+Utwórz `src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst`:
+
+```rst
+Skrót klawiszowy ``/`` otwierający wyszukiwarkę można teraz wyłączyć —
+przełącznik „Skróty klawiszowe" znajduje się w stopce strony. Ma to
+znaczenie dla osób korzystających ze sterowania głosem, którym pojedyncze
+znaki mimowolnie uruchamiały wyszukiwarkę (kryterium WCAG 2.2 AA 2.1.4).
+Przy okazji naprawiono zdublowany obsługiwacz tego skrótu.
+
+Graf powiązań autorów da się teraz przesuwać i przybliżać przyciskami oraz
+klawiaturą (strzałki, plus, minus, Home), a nie wyłącznie przeciąganiem
+myszą — kryteria 2.5.7 i 2.1.1.
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add docs/superpowers/specs/ src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst
+git commit -m "docs(wcag): domkniecie 2.1.4 i 2.5.7 w wykazie, newsfragment"
+```
+
+---
+
+### Task 8: Weryfikacja końcowa
+
+- [ ] **Step 1: Pełna suita Pythona**
+
+```bash
+cd /Volumes/SSD/Programowanie/bpp-wcag-faza2
+make tests-without-playwright
+```
+
+Trwa do ~10 minut. Poczekaj w swojej turze, nie uruchamiaj w tle.
+
+- [ ] **Step 2: Testy JS**
+
+```bash
+make js-tests
+```
+
+- [ ] **Step 3: Testy Playwright**
+
+```bash
+make assets
+make tests-only-playwright
+```
+
+- [ ] **Step 4: pre-commit**
+
+```bash
+pre-commit
+```
+
+BEZ ARGUMENTÓW. Problemy naprawiaj ręcznie, edytorem, po jednym.
+
+- [ ] **Step 5: Spójność gałęzi**
+
+```bash
+git log --oneline fix-wcag-naprawy-stwierdzone..HEAD
+git diff --stat fix-wcag-naprawy-stwierdzone..HEAD
+uv run python src/manage.py makemigrations --check --dry-run
+```
+
+Gałąź jest **stacked** na `fix-wcag-naprawy-stwierdzone`, więc bazą
+porównania jest ta gałąź, nie `dev`.
+
+Dryf migracji w pakietach zewnętrznych (favicon, flexible_reports, siteblog)
+jest zastany — zweryfikowano to w poprzedniej iteracji. Dryf w pakietach
+`bpp`/`powiazania_autorow` byłby znaleziskiem: zgłoś, nie twórz migracji.
+
+- [ ] **Step 6: Obejrzyj efekt w przeglądarce**
+
+```bash
+uv run run-site run --from-dump ~/db-backup-20260428-093811.pg_dump --no-browser
+```
+
+Sprawdź: przełącznik w stopce zmienia etykietę i faktycznie wyłącza skrót;
+na stronie autora z włączoną siecią powiązań przyciski przesuwają graf, a
+Tab dochodzi do kontenera i strzałki działają.
diff --git a/docs/superpowers/specs/2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md b/docs/superpowers/specs/2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md
index eb3c12ebf..bb8dd1053 100644
--- a/docs/superpowers/specs/2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md
+++ b/docs/superpowers/specs/2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md
@@ -510,6 +510,12 @@ naprawione — patrz sekcja „Odroczone niezgodności". Formuła „naprawa
 stwierdzona → B…" dla `3.1.2` niżej jest poprawna i pozostaje bez zmian —
 tam naprawa faktycznie zaszła.
 
+**Korekta (2026-08-07):** odroczenie z korekty wyżej okazało się
+tymczasowe — oba kryteria naprawiono dzień później
+(`2026-08-07-wcag-skrot-i-graf-design.md`). Pierwotne brzmienie wierszy
+`2.1.4` i `2.5.7` w tabeli („naprawa stwierdzona → B1/B5") jest więc znów
+aktualne: audyt ma te naprawy zweryfikować, nie odnotować niezgodność.
+
 ### Zrozumiałość
 
 | Kryterium | Poz. | Źródło werdyktu |
@@ -555,6 +561,12 @@ naprawione — decyzje i uzasadnienia w sekcji „Odroczone niezgodności".
 „Zadanie brzmi »napraw«" było zamiarem na starcie tej sekcji, nie jest
 opisem tego, co się faktycznie stało z każdym z czterech kryteriów.
 
+**Korekta (2026-08-07):** ostatecznie naprawiono wszystkie cztery. 2.1.4
+i 2.5.7 domknęła kolejna iteracja
+(`2026-08-07-wcag-skrot-i-graf-design.md`), więc pierwotne „Zadanie brzmi
+»napraw«" opisuje jednak to, co się stało — tyle że w dwóch podejściach,
+nie w jednym.
+
 ### 2.1.4 Character Key Shortcuts (A) — skrót `/`
 
 `base.html:39-49` wiąże jednoznakowy skrót `/` na poziomie `document`.
@@ -572,6 +584,14 @@ przeniesiony w zasięg focusa pola wyszukiwania.
 
 **Korekta (2026-08-06):** kryterium **odroczono**, nie naprawiono. Skrót
 `/` działa dokładnie tak samo jak w opisie wyżej — bez zmian w kodzie.
+
+**Korekta (2026-08-07):** kryterium **naprawione**. Z trzech dopuszczonych
+wyjść wybrano pierwsze — wyłączalność. Preferencja siedzi w `localStorage`
+(nie w profilu, więc działa też dla anonima), przełącznik „Skróty
+klawiszowe" jest w stopce, a wszystkie trzy handlery `/` sprawdzają ją
+przed otwarciem wyszukiwarki. Opis w akapitach wyżej („Obecny kod nie
+spełnia żadnego") dotyczy stanu sprzed tej naprawy. Szczegóły:
+`2026-08-07-wcag-skrot-i-graf-design.md`.
 Rekomendacja z sekcji „Otwarte decyzje" (zawężenie do focusa pola
 wyszukiwania) nie została wdrożona. Wpis w wykazie: sekcja „Odroczone
 niezgodności".
@@ -677,6 +697,16 @@ jednowskaźnikowej. Powód: koszt nieproporcjonalny do pozostałych napraw w
 tej iteracji, funkcja opcjonalna i w części wdrożeń wyłączona. Wpis w
 wykazie: sekcja „Odroczone niezgodności".
 
+**Korekta (2026-08-07):** kryterium **naprawione**, i to obiema drogami
+wymienionymi wyżej. Graf dostał siedem przycisków nawigacji (cztery
+kierunki, przybliż, oddal, dopasuj) oraz obsługę klawiaturą (strzałki,
+`+`/`-`, `Home`) na fokusowalnym kontenerze — przy okazji domyka to
+2.1.1 dla tego widoku. Handler robi `preventDefault` wyłącznie dla
+obsłużonych klawiszy, żeby nie stworzyć pułapki klawiaturowej (2.1.2),
+i przepuszcza kombinacje z Ctrl/Cmd/Alt, żeby nie przechwycić zoomu
+przeglądarki (1.4.4). Szczegóły:
+`2026-08-07-wcag-skrot-i-graf-design.md`.
+
 ## Hipotezy do zbadania w audycie
 
 Poniższe **nie są stwierdzonymi naruszeniami**. To miejsca, w których
@@ -908,6 +938,11 @@ nie da się ułożyć:
    wyżej), a `2.1.4` i `2.5.7` zostały świadomie odroczone, nie naprawione
    (sekcja „Odroczone niezgodności"). Szczegóły:
    `2026-08-06-wcag-naprawy-stwierdzone-design.md`.
+   **Korekta (2026-08-07):** krok (3) domknięto w drugim podejściu — `2.1.4`
+   i `2.5.7` naprawiono nazajutrz
+   (`2026-08-07-wcag-skrot-i-graf-design.md`). Cały krok „Naprawy
+   stwierdzone" jest więc wykonany; kroki (4)–(7) nie mają już na co czekać
+   po tej stronie.
 4. **Baseline freeze.** Dopiero **po** (3) i po zamrożeniu próbki. Kolejność
    jest istotna: baseline zakładany przed naprawami zaksięgowałby dług,
    który zaraz znika, i wymuszałby natychmiastową aktualizację pliku.
@@ -939,6 +974,14 @@ globalny, nadal niewyłączalny), wpis w wykazie niezgodności zamiast
 implementacji zawężenia do focusa. Powód i szczegóły: sekcja „Odroczone
 niezgodności".
 
+**Korekta (2026-08-07):** rekomendacja nadal nie została przyjęta, ale
+kryterium **naprawiono inaczej** — przez wyłączalność, nie przez zawężenie
+do focusa. Założenie stojące za rekomendacją („dwa pierwsze wyjścia
+wymagają interfejsu ustawień, a ten nie istnieje dla anonima") okazało się
+zbyt ostrożne: preferencja w `localStorage` plus jeden przycisk w stopce
+wystarczą, bez budowania profilu użytkownika. Skrót działa więc nadal
+globalnie — dla tych, którzy go nie wyłączyli.
+
 **Motywy uczelniane w raporcie silnika.** `vizja`, `mwsl`, `uafm` to
 motywy konkretnych klientów, nie warianty produktu. Jeśli test (b) wykaże
 w nich zły kontrast, naprawa **zmienia branding uczelni** — decyzja nie
@@ -1041,22 +1084,15 @@ Zapisane tutaj, bo raport zgodności — właściwe miejsce takich wpisów —
 jeszcze nie istnieje. Szczegóły i uzasadnienia:
 `2026-08-06-wcag-naprawy-stwierdzone-design.md`.
 
-**2.1.4 Character Key Shortcuts (A) — skrót `/`.**
-Handler w `src/django_bpp/templates/base.html:39-49` wiąże `/` na
-`document`, wykluczając jedynie `input`/`textarea`/`select`. Nie spełnia
-żadnego z trzech warunków kryterium (wyłączalny, przemapowywalny, aktywny
-tylko przy focusie). Stan: **niezgodne, świadomie odroczone**. Powód: brak
-nacisku regulacyjnego i brak odbiorcy raportu; wszystkie trzy dopuszczone
-wyjścia mają koszt produktowy (utrata skrótu globalnego albo zbudowanie
-interfejsu preferencji dla użytkownika anonimowego).
-
-**2.5.7 Dragging Movements (AA) — graf powiązań.**
-`src/powiazania_autorow/templates/powiazania_autorow/graf.html`, widok
-publiczny bramkowany per uczelnia (`czy_pokazywac_siec_powiazan`,
-`src/bpp/views/browse.py:245`). Nawigacja wyłącznie przez przeciąganie.
-Stan: **niezgodne, świadomie odroczone**. Powód: koszt nieproporcjonalny do
-pozostałych napraw w tej iteracji, a funkcja jest opcjonalna i w części
-wdrożeń wyłączona.
+Wpisy, które przestały być aktualne, zostają w sekcji z datą domknięcia
+zamiast zniknąć — inaczej nie dałoby się odtworzyć, co i kiedy uznano za
+niezgodność.
+
+**2.1.4 i 2.5.7 — domknięte 2026-08-07.**
+Oba kryteria zostały naprawione w kolejnej iteracji: skrót `/` dostał
+mechanizm wyłączania (localStorage + przełącznik w stopce), graf powiązań —
+przyciski nawigacji i obsługę klawiaturą. Szczegóły:
+`2026-08-07-wcag-skrot-i-graf-design.md`.
 
 **3.1.2 — tytuł przełożony (`tytul`).**
 Stan: **spełnione częściowo**. Oznaczamy tytuł oryginalny; przekład zostaje
diff --git a/docs/superpowers/specs/2026-08-06-wcag-naprawy-stwierdzone-design.md b/docs/superpowers/specs/2026-08-06-wcag-naprawy-stwierdzone-design.md
index dd25824d9..28a3307d8 100644
--- a/docs/superpowers/specs/2026-08-06-wcag-naprawy-stwierdzone-design.md
+++ b/docs/superpowers/specs/2026-08-06-wcag-naprawy-stwierdzone-design.md
@@ -40,6 +40,11 @@ i raportu bez odbiorcy byłoby produkcją artefaktu, którego nikt nie czyta.
 - 2.5.7 — nawigacja po grafie powiązań
 - 3.1.2 dla tytułu przełożonego (`tytul`) — patrz „Decyzja o polu `jezyk_alt`"
 
+**Korekta (2026-08-07):** 2.1.4 i 2.5.7 nie zostały ostatecznie odroczone —
+domknęła je kolejna iteracja (`2026-08-07-wcag-skrot-i-graf-design.md`).
+Zakres tej iteracji, opisany wyżej, pozostaje bez zmian; nieaktualna jest
+tylko prognoza, że oba kryteria zostaną z niego trwale wyłączone.
+
 **Nie wchodzi (poza tą iteracją):**
 
 - bramka CI z axe-core, baseline, strona wzorników
@@ -499,24 +504,15 @@ miejsce. Zapisujemy je w specyfikacji z 2026-08-05 (nowa sekcja
 „Odroczone niezgodności"), bo to dokument, który przyszły audyt przeczyta
 jako pierwszy; issue na GitHubie by zaginęło.
 
-Każdy wpis zawiera kryterium, stan, uzasadnienie i datę decyzji.
-
-**2.1.4 Character Key Shortcuts (A) — skrót `/`.**
-Handler w `src/django_bpp/templates/base.html:39-49` wiąże `/` na
-`document`, wykluczając jedynie `input`/`textarea`/`select`. Nie spełnia
-żadnego z trzech warunków kryterium (wyłączalny, przemapowywalny, aktywny
-tylko przy focusie). Stan: **niezgodne, świadomie odroczone**. Powód: brak
-nacisku regulacyjnego i brak odbiorcy raportu; wszystkie trzy dopuszczone
-wyjścia mają koszt produktowy (utrata skrótu globalnego albo zbudowanie
-interfejsu preferencji dla użytkownika anonimowego).
-
-**2.5.7 Dragging Movements (AA) — graf powiązań.**
-`src/powiazania_autorow/templates/powiazania_autorow/graf.html`, widok
-publiczny bramkowany per uczelnia (`czy_pokazywac_siec_powiazan`,
-`src/bpp/views/browse.py:245`). Nawigacja wyłącznie przez przeciąganie.
-Stan: **niezgodne, świadomie odroczone**. Powód: koszt nieproporcjonalny do
-pozostałych napraw w tej iteracji, a funkcja jest opcjonalna i w części
-wdrożeń wyłączona.
+Każdy wpis zawiera kryterium, stan, uzasadnienie i datę decyzji. Wpisy,
+które przestały być aktualne, zostają z datą domknięcia zamiast zniknąć —
+inaczej nie dałoby się odtworzyć, co i kiedy uznano za niezgodność.
+
+**2.1.4 i 2.5.7 — domknięte 2026-08-07.**
+Oba kryteria zostały naprawione w kolejnej iteracji: skrót `/` dostał
+mechanizm wyłączania (localStorage + przełącznik w stopce), graf powiązań —
+przyciski nawigacji i obsługę klawiaturą. Szczegóły:
+`2026-08-07-wcag-skrot-i-graf-design.md`.
 
 **3.1.2 — tytuł przełożony (`tytul`).**
 Stan: **spełnione częściowo**. Oznaczamy tytuł oryginalny; przekład zostaje
diff --git a/docs/superpowers/specs/2026-08-07-wcag-skrot-i-graf-design.md b/docs/superpowers/specs/2026-08-07-wcag-skrot-i-graf-design.md
new file mode 100644
index 000000000..6aeac8ba1
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-07-wcag-skrot-i-graf-design.md
@@ -0,0 +1,425 @@
+# Skrót `/` i nawigacja po grafie powiązań — WCAG 2.1.4, 2.5.7, 2.1.1
+
+Data: 2026-08-07
+Poprzednik: `2026-08-06-wcag-naprawy-stwierdzone-design.md`
+Gałąź: `fix-wcag-2140-2570`, stacked na `fix-wcag-naprawy-stwierdzone` (PR #732)
+
+## Cel
+
+Domknąć dwa kryteria WCAG 2.2 AA, które poprzednia iteracja **świadomie
+odroczyła**, wpisując je do wykazu niezgodności:
+
+- **2.1.4 Character Key Shortcuts (A)** — skrót `/` wiązany na `document`
+- **2.5.7 Dragging Movements (AA)** — nawigacja po grafie powiązań wyłącznie
+  przez przeciąganie
+
+Przy okazji grafu domykamy też **2.1.1 Keyboard (A)** — obsługa klawiaturą
+kosztuje niewiele, gdy funkcje nawigacyjne i tak powstają dla przycisków.
+
+Odroczenie z 2026-08-06 miało uzasadnienie: brak nacisku regulacyjnego i brak
+odbiorcy raportu. Ta iteracja jest decyzją, żeby mimo to poprawić dostępność
+tam, gdzie koszt jest znany i ograniczony.
+
+## Zakres
+
+**Wchodzi:**
+
+- 2.1.4 — mechanizm wyłączania skrótów jednoznakowych (localStorage),
+  obejmujący **wszystkie** publiczne handlery `/`, nie jeden
+- likwidacja zduplikowanego handlera `/` (dziś `openGlobalSearch` woła się
+  dwa razy na jedno naciśnięcie) — znalezisko poboczne, naprawiane przy okazji
+- 2.5.7 — przyciski nawigacji po grafie (kierunki, zoom, dopasowanie)
+- 2.1.1 — obsługa grafu klawiaturą (strzałki, `+`/`−`, `Home`)
+- 2.4.7 — widoczny pierścień focusa na kontenerze grafu
+- usunięcie obu kryteriów z wykazu odroczonych w obu specyfikacjach
+
+**Nie wchodzi:**
+
+- 3.1.2 dla tytułu przełożonego (wymaga nowego pola w modelu)
+- bramka CI z axe-core, skan szeroki, audyt ręczny, raport zgodności
+- 2.5.8 (rozmiar celów dotykowych) w skali całego serwisu — ale **nowe**
+  przyciski muszą spełniać to kryterium, patrz „Część B"
+
+## Część A — 2.1.4, skrót `/`
+
+### Problem
+
+Wykluczenie pól formularza nie wystarcza: gdy focus spoczywa na `body`,
+linku albo przycisku, naciśnięcie `/` porywa klawisz. Kryterium wymaga
+spełnienia **jednego z trzech** warunków — wyłączalności, przemapowania albo
+aktywności wyłącznie przy focusie komponentu. Żaden z istniejących handlerów
+nie spełnia żadnego.
+
+Kryterium chroni przede wszystkim użytkowników sterowania głosem, których
+wejściem są ciągi liter, oraz osoby z drżeniem rąk.
+
+### Inwentaryzacja: skrót `/` obsługiwany jest w czterech miejscach
+
+To ustalenie jest warunkiem skuteczności całej części A. Objęcie preferencją
+jednego handlera nie da nic, dopóki pozostałe reagują niezależnie.
+
+| miejsce | co robi | w zakresie? |
+|---|---|---|
+| `src/django_bpp/templates/base.html:42` | otwiera wyszukiwarkę globalną | **tak** |
+| `src/django_bpp/templates/global_search_modal.html:1048` | otwiera wyszukiwarkę globalną (**duplikat**) | **tak** |
+| `src/bpp/templates/browse/uczelnia.html:134` | zamyka baner podpowiedzi | **tak** |
+| `src/django_bpp/templates/admin/base_site.html:127` | wyszukiwarka w adminie | nie — panel zalogowanego jest poza zakresem audytu |
+
+Modal jest włączany z `top_bar.html:511`, a ten z `base.html`, więc oba
+pierwsze handlery wiszą na `document` **na tej samej stronie**.
+
+**Znalezisko poboczne: dziś oba wołają `openGlobalSearch` na jedno
+naciśnięcie.** Handler w `base.html` nie sprawdza stanu modala, handler w
+modalu sprawdza (`!$('#globalSearchModal').hasClass('show')`), ale przy
+zamkniętym modalu oba warunki są prawdziwe. To istniejący błąd, niezależny
+od WCAG.
+
+### Wybrane wyjście: mechanizm wyłączania
+
+Wzorce branżowe potwierdzają ten kierunek. GitHub trzyma to jako ustawienie
+konta („You can disable character key shortcuts, while still allowing
+shortcuts that use modifier keys, in your accessibility settings"), Gmail
+udostępnia dialog pod `?` z przełącznikiem.
+
+Obie realizacje zakładają jednak **zalogowanego użytkownika z profilem**, a
+audytowany zakres BPP to część publiczna, anonimowa. Funkcjonalnym
+odpowiednikiem jest `localStorage`: nie wymaga konta, przeżywa sesję, działa
+per przeglądarka. Kryterium nie wymaga trwałości między urządzeniami — tylko
+istnienia mechanizmu.
+
+Odrzucone alternatywy:
+
+- **zawężenie do focusa w polu wyszukiwania** — zgodne, ale skrót traci sens:
+  mając focus w wyszukiwarce wystarczy pisać;
+- **modyfikator (`Alt+/`)** — wyprowadza skrót spoza kryterium jednym
+  ruchem, ale łamie konwencję branżową (`/` w GitHub, Gmail, Slack), a
+  `Alt+/` bywa zajęty przez czytniki ekranu;
+- **całkowite usunięcie** — pełna zgodność zerowym kosztem, ale odbiera
+  działającą wygodę użytkownikom klawiatury;
+- **przełącznik w obiekcie `Uczelnia`** — wyłączenie przez administratora
+  **nie spełnia** kryterium: WCAG wymaga mechanizmu dostępnego dla
+  użytkownika.
+
+### Komponenty
+
+**Moduł preferencji** — `src/bpp/static/bpp/js/skroty-klawiszowe.js`.
+Odpowiedzialność: preferencja użytkownika i jej przełącznik.
+
+- klucz `localStorage`: `bpp.skrotyJednoznakowe`, wartości `"1"` / `"0"`
+- `window.bppSkrotyWlaczone()` → `boolean`, **domyślnie `true`** (brak wpisu
+  = zachowanie niezmienione dla każdego, kto nic nie ustawił); wartość inna
+  niż `"0"`/`"1"` traktowana jak brak wpisu
+- `window.bppUstawSkroty(bool)` → zapisuje i zwraca nowy stan
+- `window.bppPodepnijPrzelacznikSkrotow(el)` → wiąże `click` na przekazanym
+  elemencie, aktualizuje jego tekst i `aria-pressed`
+- odporny na niedostępny `localStorage` (tryb prywatny, wyczerpany limit,
+  wyłączone ciasteczka): `try`/`catch` wokół obu operacji, w razie błędu
+  zwraca wartość domyślną zamiast rzucać wyjątkiem
+
+Trzecia funkcja jest w module celowo: gdyby logika przełącznika została
+inline w stopce, nie dałoby się jej przetestować jednostkowo, a moduł
+znałby tylko połowę własnego kontraktu.
+
+**Handlery** — warunek dodany w **obu** publicznych miejscach otwierających
+wyszukiwarkę oraz w handlerze banera:
+
+```javascript
+if (e.key === '/'
+    && (typeof window.bppSkrotyWlaczone !== 'function'
+        || window.bppSkrotyWlaczone())
+    && !$(e.target).is('input, textarea, select')) {
+```
+
+Guard `typeof` jest konieczny: gdyby moduł się nie załadował (404, błąd
+wcześniejszego skryptu), gołe wywołanie rzucałoby `TypeError` przy każdym
+naciśnięciu `/` i skrót umarłby po cichu. Wzorzec jest zgodny z istniejącym
+`typeof openGlobalSearch === 'function'` w tym samym handlerze
+(`base.html:44`). Przy braku modułu degradujemy do zachowania dotychczasowego.
+
+**Likwidacja duplikatu.** Handler w `base.html:39-49` i ten w
+`global_search_modal.html:1040-1052` robią to samo. Zostaje **jeden** — ten
+w `global_search_modal.html`, bo sprawdza już stan modala i mieszka obok
+kodu, który obsługuje. Handler z `base.html` znika w całości.
+
+To upraszcza część A: zamiast trzech miejsc do objęcia warunkiem zostają
+dwa (modal + baner na stronie uczelni).
+
+**Kolejność ładowania nie jest krytyczna.** Handlery rejestrują się wewnątrz
+`DOMContentLoaded`, ale preferencję sprawdzają dopiero w momencie
+naciśnięcia klawisza — więc moduł musi być obecny przy pierwszym użyciu
+skrótu, nie przy rejestracji. Mimo to ładujemy go w `base.html` przed
+blokiem skryptów, dla przewidywalności.
+
+**Baner podpowiedzi.** `src/django_bpp/templates/search_banner.html:9`
+reklamuje skrót („Wciśnij klawisz `/` (ukośnik) aby szybko znaleźć…").
+Przy wyłączonych skrótach baner **nie może się pokazywać** — instrukcja
+używania niedziałającej funkcji jest gorsza niż brak instrukcji. Moduł
+ukrywa baner, gdy preferencja jest wyłączona.
+
+**Przełącznik w stopce** — `src/django_bpp/templates/base_footer.html`.
+
+Przycisk (`<button type="button">`) z etykietą „Skróty klawiszowe: włączone"
+/ „…: wyłączone", przełączający stan i tekst bez przeładowania strony.
+Atrybut `aria-pressed` odzwierciedla stan, żeby czytnik ogłaszał zmianę.
+
+**Dlaczego stopka, a nie strona deklaracji dostępności** — mimo że to
+naturalniejsze miejsce na ustawienia dostępności: deklaracja jest w BPP
+konfigurowalna per uczelnia (`Uczelnia.pokazuj_deklaracje_dostepnosci`:
+wartość 1 → zewnętrzny URL uczelni, 2 → wewnętrzna strona BPP, brak → brak
+linku). Na części wdrożeń strony nie ma wcale, na innych prowadzi na serwer
+uczelni, gdzie nie postawimy przełącznika. Mechanizm ukryty za opcjonalną
+stroną nie spełnia wymogu „dostępny".
+
+**Zasięg stopki.** `base_footer.html` jest włączana z `base.html`, więc stoi
+na wszystkich stronach dziedziczących po nim. Strony rozszerzające
+bezpośrednio `bare.html` (kreator instalacji, `multiseek/live-results.html`,
+podgląd opisu w adminie) stopki nie mają — ale nie mają też handlera `/`,
+bo ten żyje w bloku `body` w `base.html`. Mechanizm i skrót pokrywają się
+zakresem, więc nie powstaje strona ze skrótem bez możliwości wyłączenia go.
+
+## Część B — 2.5.7, nawigacja po grafie wskaźnikiem
+
+### Problem
+
+`src/powiazania_autorow/templates/powiazania_autorow/graf.html` to widok
+publiczny, bramkowany metodą `Autor.czy_pokazywac_siec_powiazan(uczelnia)`
+(`src/bpp/views/browse.py:245`) — ustawienie per-autor nadpisuje
+per-uczelnia. Wizualizacja stoi na Cytoscape.js (`^3.34.0`); jedyną drogą
+przesunięcia widoku jest przeciąganie.
+
+Kryterium wymaga alternatywy realizowanej **pojedynczym wskaźnikiem** —
+kliknięciem lub tapnięciem. Obsługa klawiaturą (część C) jest odrębnym
+kryterium i nie zastępuje tego wymogu.
+
+Wyszukiwarka węzłów (`powiazania/search.js`) istnieje, ale jedynie
+podświetla trafienia i przygasza resztę — **nie przesuwa widoku**, więc
+zobaczenie trafienia nadal wymaga przeciągnięcia grafu. Nie jest zatem
+alternatywą w rozumieniu kryterium.
+
+### Komponenty
+
+**Moduł nawigacji** —
+`src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js`.
+Czyste funkcje nad instancją Cytoscape, testowalne z atrapą:
+
+- `przesun(cy, kierunek)` — `kierunek` ∈ `"gora" | "dol" | "lewo" | "prawo"`
+- `zoomuj(cy, wspolczynnik)` — `wspolczynnik` > 1 przybliża, < 1 oddala;
+  zoom wokół środka widoku (`cy.zoom({level, renderedPosition})`)
+- `dopasuj(cy)` — `cy.fit()` z niewielkim marginesem
+
+**Krok przesunięcia liczony jako procent rozmiaru widoku** (20% szerokości
+lub wysokości), nie stała w pikselach. Przy dużym przybliżeniu stały krok
+byłby ledwo zauważalny, przy oddaleniu — przeskakiwałby cały graf.
+
+**Współczynnik zoomu**: 1,2 na krok, z ograniczeniem do zakresu ustawionego
+przy tworzeniu instancji — `utworzCy` (`powiazania/cy.js:99-100`) ustawia
+`minZoom: 0.1`, `maxZoom: 4`. Moduł odczytuje je przez `cy.minZoom()` /
+`cy.maxZoom()`, nie zaszywa liczb u siebie.
+
+**Nakładka z przyciskami** — w `graf.html`, wewnątrz istniejącego
+`#graf-wrapper` (ma już `position: relative`, więc nakładka nie zmienia
+układu strony). Siedem przycisków: cztery kierunki, `+`, `−`, „dopasuj do
+ekranu".
+
+**Podpięcie zdarzeń** w istniejącym `powiazania/controls.js`, zgodnie z
+tamtejszym wzorcem (`podepnijZdarzenia(ctx)`).
+
+**Style** — nowy partial `src/bpp/static/scss/graf_powiazan.scss`,
+zaimportowany w `common.scss` obok pozostałych (`@import "graf_powiazan";`).
+
+Aplikacja `powiazania_autorow` **nie ma własnego katalogu SCSS** — `graf.html`
+stosuje style inline w atrybutach `style=""` (np. `#graf-legenda`:
+`position: absolute; top: 10px; right: 10px`). Nakładkę nawigacji mimo to
+opisujemy w SCSS, nie inline, z dwóch powodów: pierścień focusa wymaga
+pseudoklasy `:focus-visible` (część C), której w atrybucie `style` zapisać
+się nie da, a rozbijanie jednego komponentu między atrybut i arkusz byłoby
+gorsze niż trzymanie go w całości w arkuszu.
+
+Pozycjonowanie absolutne wewnątrz `#graf-wrapper`. Trzy z czterech rogów są
+już zajęte:
+
+| róg | zajmuje | kiedy widoczny |
+|---|---|---|
+| lewy górny | `#graf-panel` (`graf.html:183`) | po kliknięciu węzła |
+| prawy górny | `#graf-legenda` (`graf.html:167`) | zawsze |
+| lewy dolny | `#graf-notka` (`graf.html:191`) | gdy sieć przycięta (`data.truncated`) |
+| **prawy dolny** | — | — |
+
+Nakładka idzie w **prawy dolny**. Lewy dolny odpada mimo pozornej wolności:
+`#graf-notka` pojawia się dokładnie przy dużych sieciach, czyli wtedy, gdy
+nawigacja jest najbardziej potrzebna.
+
+Po zmianie SCSS wymagany `grunt build` (albo `make assets`).
+
+### Dostępność samych przycisków
+
+- `type="button"` — bez tego przycisk wewnątrz formularza wysyła go
+- `aria-label` po polsku („Przesuń widok w lewo", „Przybliż", „Dopasuj graf
+  do ekranu") — sam glif strzałki nic nie mówi czytnikowi
+- **rozmiar celu ≥ 24×24 px CSS** — kryterium 2.5.8 (AA). Naprawiając 2.5.7
+  nie wolno złamać sąsiedniego kryterium; to jedyne miejsce w tej iteracji,
+  gdzie 2.5.8 obowiązuje nas wprost, bo tworzymy nowe cele dotykowe
+- glify jako tekst (`↑`, `+`, `⤢`) z `aria-hidden="true"`, treść dla
+  czytnika wyłącznie w `aria-label`
+
+## Część C — 2.1.1, obsługa grafu klawiaturą
+
+### Komponenty
+
+**Kontener** `#cytoscape-container` w `graf.html`:
+
+- `tabindex="0"` — wchodzi w kolejność tabulacji
+- `role="application"` — sygnalizuje czytnikowi, że komponent przechwytuje
+  klawisze strzałek (bez tego czytnik w trybie przeglądania sam je obsłuży)
+- `aria-label` wymieniający dostępne klawisze, np. „Graf powiązań autorów.
+  Strzałki przesuwają widok, plus i minus przybliżają, Home dopasowuje graf
+  do ekranu."
+
+**Handler `keydown`** na kontenerze, wołający te same funkcje co przyciski:
+
+| klawisz | akcja |
+|---|---|
+| `ArrowUp` / `ArrowDown` / `ArrowLeft` / `ArrowRight` | `przesun` |
+| `+` / `=` | `zoomuj` (przybliż) |
+| `-` / `_` | `zoomuj` (oddal) |
+| `Home` | `dopasuj` |
+
+`preventDefault()` **wyłącznie dla klawiszy obsłużonych** — `Tab`, `Escape`
+i reszta muszą działać normalnie, inaczej powstaje pułapka klawiaturowa
+(kryterium 2.1.2).
+
+Wariant `=` obok `+` bo na większości układów `+` wymaga Shift; `_` obok `-`
+symetrycznie.
+
+**Widoczny focus** — pierścień na `#cytoscape-container:focus-visible`
+(kryterium 2.4.7). Bez tego użytkownik klawiatury nie wie, że graf przejął
+focus i strzałki zaczęły działać.
+
+### Relacja do kryterium 2.1.4
+
+Klawisze `+`, `-`, `=`, `_` są znakami drukowalnymi, więc formalnie podlegają
+temu samemu kryterium co skrót `/`. Spełniają je jednak **trzecim** wariantem
+— „skrót jest aktywny wyłącznie wtedy, gdy komponent ma focus" — bo handler
+wisi na kontenerze grafu, nie na `document`. Nie wymagają przełącznika i
+**nie** są objęte preferencją z części A.
+
+To rozgraniczenie jest zamierzone: skrót globalny, którego nie da się przypiąć
+do komponentu, dostaje mechanizm wyłączania; skróty lokalne — ograniczenie do
+focusa.
+
+## Testy
+
+Konwencja: pytest (funkcje standalone, `@pytest.mark.django_db` gdzie baza),
+vitest dla JS (`tests/js/**/*.test.js`).
+
+**Moduł preferencji skrótów** (vitest). Moduł jest skryptem window-globalnym
+(jak `djangoql-*.js`), więc plik testowy deklaruje u siebie
+`// @vitest-environment jsdom` — domyślnym środowiskiem w `vitest.config.js`
+jest `node`, w którym nie ma `window` ani `localStorage`.
+
+- brak wpisu → `true` (domyślka)
+- `"0"` → `false`; `"1"` → `true`
+- `getItem` zwracający śmieci (`"tak"`) → domyślka
+- `bppUstawSkroty(false)` zapisuje `"0"` i zwraca `false`
+- rzucający `localStorage` (tryb prywatny) → zwraca domyślkę, nie wyjątek
+- `bppPodepnijPrzelacznikSkrotow(el)` — klik odwraca stan, aktualizuje
+  `aria-pressed` i tekst; drugi klik wraca do stanu wyjściowego
+
+**Moduł nawigacji grafu** (vitest, atrapa `cy` z `pan`, `zoom`, `fit`,
+`width`, `height`, `minZoom`, `maxZoom`):
+- `przesun` w każdym z czterech kierunków zmienia właściwą oś i znak
+- krok skaluje się z rozmiarem widoku (dwa różne `width` → dwa różne kroki)
+- `zoomuj` nie przekracza `minZoom`/`maxZoom`
+- `dopasuj` woła `cy.fit()`
+
+**Szablony** (pytest):
+- stopka zawiera przycisk przełącznika z `aria-pressed`
+- `graf.html` zawiera siedem przycisków nawigacji, każdy z `aria-label`
+- `#cytoscape-container` ma `tabindex="0"`, `role`, `aria-label`
+- `skroty-klawiszowe.js` jest podpięty przez `<script src>` w renderze —
+  inaczej usunięcie tagu nie wywali żadnego testu, a przełącznik przestanie
+  działać
+- w `base.html` **nie ma już** handlera `/` (dowód likwidacji duplikatu)
+
+Analogiczna asercja **nie ma sensu dla `nawigacja.js`**: moduł trafia do
+`dist/cytoscape-bundle.js` przez import w `controls.js` (entry
+`js/cytoscape-entry.js`, esbuild), więc w renderze `graf.html` nie pojawi
+się osobny `<script src>` — tag bundla (`graf.html:202`) istnieje już dziś
+i niczego z tej iteracji nie broni. Dla grafu rolę tę pełnią testy vitest
+samego modułu plus test Playwright klikający przycisk.
+
+**Playwright** — `src/integration_tests/`, obok istniejącego
+`test_siec3d_bez_webgl.py` (jedyny dotychczasowy test przeglądarkowy
+wizualizacji powiązań; testy widoków grafu bez przeglądarki żyją w
+`src/powiazania_autorow/test_views.py`).
+
+Graf:
+- klik w „dopasuj" zmienia zoom/pan grafu
+- Tab dochodzi do kontenera grafu, strzałka przesuwa widok
+- `Tab` po sfokusowaniu grafu **wychodzi** z niego (brak pułapki, 2.1.2)
+
+Skrót `/` — **to jest test broniący celu całej części A**, bez niego
+usunięcie warunku z handlera nie wywali niczego:
+- przy domyślnej preferencji `/` otwiera wyszukiwarkę globalną
+- po kliknięciu przełącznika w stopce `/` **nie** otwiera wyszukiwarki
+- po ponownym kliknięciu otwiera znowu
+- przy wyłączonych skrótach baner podpowiedzi się nie pokazuje
+- `/` wciśnięty przy focusie w polu tekstowym wpisuje znak, nie otwiera
+  wyszukiwarki (zachowanie zastane, nie może się zepsuć)
+
+Weryfikacja przed PR: `make tests-without-playwright`, `make js-tests`,
+`make tests-only-playwright`, `pre-commit` (bez argumentów).
+
+## Aktualizacja wykazu odroczonych
+
+Wpisy o 2.1.4 i 2.5.7 znikają z sekcji „Odroczone niezgodności" w **obu**
+specyfikacjach (`2026-08-06-…` i `2026-08-05-…`) i zostają zastąpione notą, że
+kryteria domknięto 2026-08-07 wraz z odsyłaczem do tego dokumentu.
+
+Poprzednia iteracja pokazała, że dokument o rozbudowanej historii łatwo
+zostawia twierdzenia sprzeczne ze stanem faktycznym — trzy kolejne przejścia
+znajdowały kolejne. Dlatego przy tej zmianie trzeba przejrzeć **wszystkie**
+wystąpienia `2.1.4`, `2.5.7`, „skrót", „graf", „przeciąganie", „naprawa
+stwierdzona" i wymienić w raporcie także miejsca uznane za niewymagające
+zmiany, wraz z uzasadnieniem.
+
+Nadal odroczone (bez zmian): 3.1.2 dla tytułu przełożonego, warunki po
+stronie wdrożenia (`kod_bcp47`, własny szablon opisu, override allowlisty,
+wiersz `opis_bibliograficzny.html` w `dbtemplates`).
+
+## Ryzyka
+
+**`role="application"` wycisza tryb przeglądania czytnika.** Wewnątrz takiego
+regionu czytnik przekazuje klawisze do aplikacji zamiast obsługiwać je
+własną nawigacją. To zamierzone (inaczej strzałki nie dotrą do grafu), ale
+oznacza, że `aria-label` musi wyczerpująco opisać dostępne klawisze — poza
+nim użytkownik nie ma jak ich odkryć.
+
+**Nakładka może zasłonić graf na wąskich ekranach.** Przyciski zajmują prawy
+dolny róg — jedyny wolny — więc przy małej wysokości widoku mogą przykryć
+węzły. Mitygacja: półprzezroczyste tło jak w legendzie, `z-index` spójny z
+sąsiadami (1001).
+
+**Nowy partial SCSS obok stylów inline.** `graf.html` opisuje dziś cały
+wygląd atrybutami `style=""`; dokładamy do niego arkusz. Rozbicie jest
+świadome (patrz „Style"), ale oznacza, że kolejna osoba zmieniająca wygląd
+grafu musi zajrzeć w dwa miejsca. Alternatywa — przeniesienie całego wyglądu
+grafu do SCSS — byłaby refaktorem poza zakresem tej iteracji.
+
+**Skrót `/` wyłączony w localStorage nie przenosi się między przeglądarkami.**
+Użytkownik sterowania głosem, który wyłączył skróty na jednym urządzeniu,
+napotka je ponownie na innym. Kryterium tego nie wymaga, ale warto odnotować
+w wykazie jako ograniczenie znane.
+
+**Domyślka „włączone" oznacza, że problem trwa do momentu wyłączenia.**
+Alternatywą byłoby domyślne wyłączenie, ale odebrałoby to działającą funkcję
+wszystkim dotychczasowym użytkownikom. Kryterium wymaga mechanizmu, nie
+domyślnego wyłączenia.
+
+## Poza zakresem
+
+- bramka CI z axe-core, baseline, strona wzorników
+- skan szeroki na dumpie, audyt ręczny WCAG-EM, raport zgodności
+- 2.5.8 w skali serwisu (obowiązuje nas tylko dla nowych przycisków)
+- panel zalogowanego użytkownika i Django admin
+- poziom AAA
diff --git a/docs/superpowers/specs/2026-08-13-wcag-stan-i-pozostale-prace.md b/docs/superpowers/specs/2026-08-13-wcag-stan-i-pozostale-prace.md
new file mode 100644
index 000000000..ff596ba47
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-13-wcag-stan-i-pozostale-prace.md
@@ -0,0 +1,157 @@
+# WCAG w BPP — stan prac i co zostało (2026-08-13)
+
+Dokument-rozdzielacz: jedno miejsce, z którego widać, co w temacie WCAG jest
+zrobione, co czeka i gdzie leżą szczegóły. Powstał, bo dotychczasowa wiedza
+o pozostałych pracach żyła w `.superpowers/` — katalogu **wykluczonym przez
+`.gitignore`** (linia 229), a więc znikającym razem z worktree. Ten plik jest
+w repozytorium.
+
+`docs/superpowers/` jest wykluczone z budowania mkdocs (`exclude_docs`
+w `mkdocs.yml`), więc dokument nie trafia na stronę dokumentacji i nie
+podlega gejtowi `mkdocs build --strict`.
+
+## Mapa dokumentów
+
+| dokument | o czym |
+|---|---|
+| `2026-08-05-wcag-22-aa-zgodnosc-frontendu-design.md` | audyt całościowy: tabela 55 kryteriów, kolejność prac, hipotezy, wykaz odroczonych |
+| `2026-08-06-wcag-naprawy-stwierdzone-design.md` | faza 1 — 1.1.1, 3.1.1, 3.1.2 |
+| `2026-08-07-wcag-skrot-i-graf-design.md` | faza 2 — 2.1.4, 2.5.7, 2.1.1 |
+| `docs/superpowers/plans/2026-08-07-wcag-skrot-i-graf.md` | plan wdrożenia fazy 2 (8 zadań) |
+
+Oba dokumenty audytowe używają konwencji `**Korekta (data):**` — poprawki
+dopisywane pod oryginalnym tekstem, bez kasowania. Ustalenia bywały
+odwracane (2.1.4 i 2.5.7 przeszły drogę „napraw" → „odroczone" →
+„naprawione"), więc historia decyzji jest tam czytelna.
+
+## Co jest zrobione
+
+**Faza 1** — PR [#732](https://github.com/iplweb/bpp/pull/732), gałąź
+`fix-wcag-naprawy-stwierdzone`. Kryteria 1.1.1 (`alt=""` na 504), 3.1.1
+(`lang="pl"` na 504), 3.1.2 (atrybut `lang` na tytułach, oba wektory).
+Poza tym: allowlista nh3 o `span[lang]`, migracja `0488`, naprawa
+podświetlania w wyszukiwarce rekordów powiązanych.
+
+**Faza 2** — gałąź `fix-wcag-2140-2570`, worktree
+`/Volumes/SSD/Programowanie/bpp-wcag-faza2`, PR jeszcze nie wystawiony.
+Kryteria 2.1.4 (skrót `/` wyłączalny: `localStorage` + przełącznik
+w stopce), 2.5.7 i 2.1.1 (siedem przycisków nawigacji po grafie + obsługa
+klawiaturą, bez pułapki klawiaturowej 2.1.2 i bez przechwytywania zoomu
+przeglądarki 1.4.4). Wszystkie 8 zadań planu domknięte.
+
+## Ścieżka do scalenia
+
+1. **#732** — odrzucić alerty CodeQL 155 i 156 (uzasadnienie:
+   `codeql-155-156-report.md` w worktree `bpp-wcag-naprawy`), zmergować.
+   Wszystkie realne gejty przechodzą; `UNSTABLE` bierze się wyłącznie
+   z pomijanego „Deploy to GitHub Pages".
+2. **Recenzja całej gałęzi fazy 2** na najmocniejszym modelu.
+3. **Rebase.** `fix-wcag-naprawy-stwierdzone` został przebazowany po tym,
+   jak odbiła się od niego faza 2: commity fazy 1 obecne w
+   `fix-wcag-2140-2570` **nie są przodkami** base'a, który ma równoważne
+   pod innymi SHA. `merge-base` obu gałęzi to dzisiaj czysty `dev`, więc
+   PR stacked pokazałby zmiany fazy 1 jako część diffu fazy 2. Po merge'u
+   #732:
+   ```bash
+   git rebase --onto origin/dev 6a0d66398 fix-wcag-2140-2570
+   ```
+   (`6a0d66398` to ostatni commit fazy 1 w historii fazy 2; rebase odtworzy
+   wyłącznie commity fazy 2.)
+4. **PR fazy 2** z bazą `dev` + recenzja PR-a.
+
+## Triaż — otwarte decyzje projektowe
+
+Nie usterki, tylko rzeczy wymagające czyjegoś zdania. Pozycje techniczne
+z tej listy zostały już zamknięte (guardy `uczelnia.html` pod testem,
+martwy `catch`, selektor BEM, test osi Y).
+
+- **Układ siedmiu przycisków nawigacji.** Grid 3-kolumnowy układa je jako
+  `↑ ← ⤢` / `→ ↓ +` / `−`, czyli w kolejności czytania, nie przestrzennie.
+  Dla pomocy nawigacyjnej to słaby afordans: „w górę" sąsiaduje poziomo
+  z „w lewo". Alternatywa to krzyż kierunkowy z zoomem obok.
+- **Brak media query dla czterech narożnych overlayów grafu.** Przy 390 px
+  legenda (`max-width: 260px`) zasłania większość obszaru rysowania,
+  a przyciski nawigacji wypadają poniżej załamania.
+- **Stopki `Co-Authored-By`.** Cztery z commitów fazy 2 ich nie mają
+  (briefy 1–4 nie wymagały; dopisane od briefu 5). Rebase z punktu 3 jest
+  naturalną okazją, żeby to poprawić — albo świadomie zostawić.
+
+## Program WCAG poza tą gałęzią
+
+Specyfikacja 08-05 rozpisuje siedem kroków. Wykonane są (1) infrastruktura
+testowa częściowo i (3) naprawy stwierdzone. **Otwarte pozostają:**
+
+- **(2) Skan szeroki na dumpie** — zamraża próbkę widoków. Wąskie gardło:
+  wszystko poza naprawami stwierdzonymi na niego czeka.
+- **(4) Baseline freeze** — dopiero po naprawach i po zamrożeniu próbki.
+  Kolejność jest istotna: baseline zakładany przed naprawami zaksięgowałby
+  dług, który zaraz znika.
+- **(5) Bramka CI z axe-core** — wymaga (4). Od tego momentu regresje
+  dostępności są blokowane automatycznie.
+- **(6) Audyt ręczny WCAG-EM, bloki 1–6** — wymaga próbki z (2).
+- **(7) Raport zgodności** — wymaga (6) i wyników (5). Dziś nie istnieje,
+  dlatego wykazy niezgodności mieszkają tymczasowo w specyfikacjach.
+
+**Znalezione przy recenzji fazy 2 (2026-08-16), nierozwiązane:**
+
+- **2.1.4 w panelu administracyjnym.**
+  `src/django_bpp/templates/admin/base_site.html:127` wiąże skrót `/` na
+  `$(document)` i robi `preventDefault()` — dokładnie ten sam wzorzec, który
+  faza 2 naprawiła po stronie publicznej, tylko nietknięty. Poza
+  zadeklarowanym zakresem audytu (część publiczna dla anonima), ale
+  kryterium obowiązuje per strona, więc raport zgodności obejmujący panel
+  administracyjny to wykaże. Naprawa nie jest jednolinijkowa: admin nie
+  dziedziczy po `base.html`, więc nie ładuje `skroty-klawiszowe.js` —
+  potrzebny jest i skrypt, i guard. Osobne zadanie.
+
+**Hipotezy do zbadania** (nie są stwierdzonymi naruszeniami — zadanie brzmi
+„zbadaj", nie „napraw"):
+
+- **3.3.7 Redundant Entry** — kreator zgłoszenia na `formtools`; czy któryś
+  krok wymaga ponownego podania tej samej informacji.
+- **3.3.8 Accessible Authentication** — czy na ścieżce logowania pojawia się
+  test funkcji poznawczych, np. po serii nieudanych prób (`django-axes`).
+- **1.1.1 dla CAPTCHA** — Altcha jest proof-of-work, więc niewizualna, co
+  rokuje dobrze, ale wymaga potwierdzenia.
+- **2.5.8 Target Size** — przewidywana najliczniejsza kategoria naruszeń
+  (1781 ikon `fi-*`, paginator multiseek, gęste tabele). Skala jest
+  hipotezą do zmierzenia skanem, nie faktem.
+
+**Niezgodności odroczone i zgodności warunkowe** (pełne wpisy w sekcji
+„Odroczone niezgodności" w 08-05):
+
+- **3.1.2 dla tytułu przełożonego** — model nie ma pola z językiem
+  przekładu; `jezyk_alt` to co innego. Domknięcie wymaga migracji schematu
+  i uzupełnienia danych przez uczelnie.
+- **3.1.2 na instalacjach z własnym szablonem opisu, z override'em
+  `opis_bibliograficzny.html` w dbtemplates albo z własnym
+  `OPIS_BIBLIOGRAFICZNY_ALLOWED_TAGS`** — trzy warianty tego samego
+  ryzyka: wdrożenie dostanie deploy bez znacznika `lang` i **bez żadnego
+  sygnału o tym**. Sposób sprawdzenia per wdrożenie i dwa wyjścia opisane
+  w 08-05.
+
+## Pułapki, które kosztowały czas
+
+- **`grunt build` jest konieczny** po zmianie SCSS; szablony Django
+  odświeżają się same, arkusze nie. Bundle JS jest **minifikowany**, więc
+  grep po źródłowym formatowaniu daje fałszywy negatyw.
+- **Nigdy `npm install`** — projekt używa Yarn.
+- **Nigdy `pre-commit --all-files`** ani `ruff check --fix`. Uwaga: `pre-commit`
+  bez argumentów przy czystym drzewie **nic nie sprawdza** („no files to
+  check" na każdym hooku) — to przebieg pusty, nie zielony.
+- **Nigdy `make clean-testcontainers`** na tym hoście — usuwa też cudze,
+  działające kontenery. Zdarzyło się w trakcie prac: przy kilkunastu
+  kontenerach na 8 GB świeży Postgres nie wstaje w 120 s. Obejście:
+  `PYTEST_TESTCONTAINERS_REUSE=1`.
+- **`run-site --from-dump` jest zepsuty** — `pg_restore: could not open
+  input file "/tmp/dump": Brak dostępu`, mimo pliku 644, `/tmp` 1777
+  w obrazie i `docker exec` jako root. Do zgłoszenia autorowi run-site.
+  Obejście dla oględzin wizualnych: zrzuty ekranu z live servera
+  Playwrighta.
+- **Nazwa katalogu testów.** Założenie pakietu `tests/` obok istniejącego
+  modułu `tests.py` przesłania ten drugi — pytest odmawia kolekcji, a testy
+  po cichu przestają się wykonywać. Zdarzyło się w `powiazania_autorow`
+  i kosztowało 18 niewykonywanych testów przez kilka commitów.
+- **Ścieżki do plików w testach** kotwicz na katalogu pakietu
+  (`Path(pakiet.__file__).parent`), nie na `parents[n]` od `__file__` —
+  drugie łamie się przy każdym przeniesieniu pliku testowego.
diff --git a/src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst b/src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst
new file mode 100644
index 000000000..d94a0b308
--- /dev/null
+++ b/src/bpp/newsfragments/wcag-skrot-i-graf.feature.rst
@@ -0,0 +1,9 @@
+Skrót klawiszowy ``/`` otwierający wyszukiwarkę można teraz wyłączyć —
+przełącznik „Skróty klawiszowe" znajduje się w stopce strony. Ma to
+znaczenie dla osób korzystających ze sterowania głosem, którym pojedyncze
+znaki mimowolnie uruchamiały wyszukiwarkę (kryterium WCAG 2.2 AA 2.1.4).
+Przy okazji naprawiono zdublowany obsługiwacz tego skrótu.
+
+Graf powiązań autorów da się teraz przesuwać i przybliżać przyciskami oraz
+klawiaturą (strzałki, plus, minus, Home), a nie wyłącznie przeciąganiem
+myszą — kryteria 2.5.7 i 2.1.1.
diff --git a/src/bpp/static/bpp/js/skroty-klawiszowe.js b/src/bpp/static/bpp/js/skroty-klawiszowe.js
new file mode 100644
index 000000000..e43bce091
--- /dev/null
+++ b/src/bpp/static/bpp/js/skroty-klawiszowe.js
@@ -0,0 +1,74 @@
+/**
+ * Preferencja skrotow jednoznakowych (WCAG 2.1.4 Character Key Shortcuts).
+ *
+ * Kryterium wymaga, zeby skrot zlozony z samych znakow drukowalnych dalo sie
+ * wylaczyc, przemapowac albo ograniczyc do focusa komponentu. Skrot `/`
+ * otwierajacy wyszukiwarke globalna wisi na `document`, wiec wybieramy
+ * pierwsza droge.
+ *
+ * BPP w czesci publicznej nie ma kont uzytkownikow (GitHub i Gmail trzymaja
+ * taka preferencje w profilu), wiec zapisujemy ja w localStorage. Kryterium
+ * nie wymaga trwalosci miedzy urzadzeniami — tylko istnienia mechanizmu.
+ *
+ * Domyslka: WLACZONE. Brak wpisu nie moze zmieniac zachowania nikomu, kto
+ * nic nie ustawil.
+ */
+(function (window) {
+    "use strict";
+
+    var KLUCZ = "bpp.skrotyJednoznakowe";
+    var ETYKIETA_WL = "Skróty klawiszowe: włączone";
+    var ETYKIETA_WYL = "Skróty klawiszowe: wyłączone";
+    var stanAwaryjny = null;  // Fallback w pamięci gdy localStorage niedostępny
+
+    function bppSkrotyWlaczone() {
+        if (stanAwaryjny !== null) {
+            return stanAwaryjny;
+        }
+        try {
+            return window.localStorage.getItem(KLUCZ) !== "0";
+        } catch (e) {
+            // Tryb prywatny, wylaczone ciasteczka, wyczerpany limit. Fallbacku
+            // z pamieci NIE czytamy tu ponownie: warunek wyzej juz zwrocil
+            // `stanAwaryjny`, jesli byl ustawiony, wiec w tym miejscu jest on
+            // zawsze `null`. Zostaje domyslka — skroty wlaczone.
+            return true;
+        }
+    }
+
+    function bppUstawSkroty(wlaczone) {
+        try {
+            window.localStorage.setItem(KLUCZ, wlaczone ? "1" : "0");
+            stanAwaryjny = null;  // Zapis się powiedział — czyść fallback
+        } catch (e) {
+            // Zapis niemozliwy (tryb prywatny, limit, itp.) — trzymaj
+            // stan w pamięci sesji. Przełącznik będzie działa w bieżącej
+            // sesji, choć preferencja nie przetrwa przeładowania.
+            stanAwaryjny = !!wlaczone;
+        }
+        return !!wlaczone;
+    }
+
+    function bppPodepnijPrzelacznikSkrotow(el) {
+        if (!el) {
+            return;
+        }
+
+        function odswiez() {
+            var wl = bppSkrotyWlaczone();
+            el.setAttribute("aria-pressed", wl ? "true" : "false");
+            el.textContent = wl ? ETYKIETA_WL : ETYKIETA_WYL;
+        }
+
+        el.addEventListener("click", function () {
+            bppUstawSkroty(!bppSkrotyWlaczone());
+            odswiez();
+        });
+
+        odswiez();
+    }
+
+    window.bppSkrotyWlaczone = bppSkrotyWlaczone;
+    window.bppUstawSkroty = bppUstawSkroty;
+    window.bppPodepnijPrzelacznikSkrotow = bppPodepnijPrzelacznikSkrotow;
+})(typeof window !== "undefined" ? window : this);
diff --git a/src/bpp/static/scss/base_footer.scss b/src/bpp/static/scss/base_footer.scss
index f1a4d9000..ce5519171 100644
--- a/src/bpp/static/scss/base_footer.scss
+++ b/src/bpp/static/scss/base_footer.scss
@@ -11,6 +11,27 @@
         display: none;
     }
 
+    // Przelacznik skrotow klawiszowych (WCAG 2.1.4) ma wygladac jak sasiednie
+    // linki stopki — jest <button>, bo zmienia stan aplikacji, a nie nawiguje.
+    //
+    // Padding NIE jest kosmetyka. `.footer__content` ma `font-size: 70%`, wiec
+    // bez niego cel miał 134 x 15 px, przy progu 24 x 24 z 2.5.8. Formalnie
+    // bronilby sie wyjatkiem "inline" (cel osadzony w bloku tekstu), ale
+    // konsekwencja byla realna: beneficjentem naprawy 2.1.4 sa osoby ze
+    // sterowaniem glosem i z zaburzeniami motoryki, a jedyny sposob
+    // skorzystania z tej naprawy to trafienie w ten wlasnie przycisk.
+    // Sam `padding` nie rusza `font-size`, wiec linia stopki sie nie rozjezdza.
+    &__link-button {
+        background: none;
+        border: none;
+        padding: 5px 6px;
+        margin: 0;
+        font: inherit;
+        color: inherit;
+        text-decoration: underline;
+        cursor: pointer;
+    }
+
     // Print styles
     &__print {
         .text-right {
diff --git a/src/bpp/static/scss/common.scss b/src/bpp/static/scss/common.scss
index 5ea88dbe1..62ee88385 100644
--- a/src/bpp/static/scss/common.scss
+++ b/src/bpp/static/scss/common.scss
@@ -22,6 +22,7 @@
 @import "zrodla";
 @import "rok";
 @import "lata";
+@import "graf_powiazan";
 
 // Base elements and typography
 @import "base-elements";
diff --git a/src/bpp/static/scss/graf_powiazan.scss b/src/bpp/static/scss/graf_powiazan.scss
new file mode 100644
index 000000000..358eba835
--- /dev/null
+++ b/src/bpp/static/scss/graf_powiazan.scss
@@ -0,0 +1,107 @@
+// Nakladka nawigacji po grafie powiazan (WCAG 2.5.7) oraz pierscien focusa
+// kontenera grafu (2.4.7). Aplikacja powiazania_autorow nie ma wlasnego
+// katalogu SCSS — graf.html opisuje wyglad atrybutami style="" — ale
+// :focus-visible wymaga arkusza, wiec komponent siedzi w calosci tutaj.
+
+.graf-nawigacja {
+    position: absolute;
+    right: 10px;
+    bottom: 10px;
+    z-index: 1001;
+
+    // Krzyz kierunkowy, nie kolejnosc czytania: "w gore" ma lezec NAD
+    // srodkiem, a nie obok "w lewo". Dla pomocy nawigacyjnej afordans jest
+    // istotny — uzytkownik trafia w przycisk bez czytania etykiet. Zoom
+    // stoi osobno, oddzielony pusta kolumna, zeby nie wpadal w krzyz.
+    //
+    // Kolejnosc w DOM (gora, lewo, dopasuj, prawo, dol, zoom+, zoom-) jest
+    // CELOWO nietknieta — daje sensowna kolejnosc Taba, a grid rozstawia
+    // przyciski niezaleznie od niej.
+    display: grid;
+    grid-template-columns: auto auto auto 8px auto;
+    grid-template-areas:
+        ".    gora     .      . zoom-in"
+        "lewo dopasuj  prawo  . zoom-out"
+        ".    dol      .      . .";
+    gap: 2px;
+
+    padding: 6px;
+    background: rgba(255, 255, 255, 0.92);
+    border: 1px solid #ddd;
+    border-radius: 4px;
+}
+
+#graf-nav-gora { grid-area: gora; }
+#graf-nav-lewo { grid-area: lewo; }
+#graf-nav-dopasuj { grid-area: dopasuj; }
+#graf-nav-prawo { grid-area: prawo; }
+#graf-nav-dol { grid-area: dol; }
+#graf-nav-zoom-in { grid-area: zoom-in; }
+#graf-nav-zoom-out { grid-area: zoom-out; }
+
+.graf-nawigacja__btn {
+    // WCAG 2.5.8 (Target Size Minimum): cel dotykowy nie mniejszy niz
+    // 24x24 px CSS. Naprawiajac 2.5.7 nie wolno zlamac sasiedniego
+    // kryterium.
+    min-width: 28px;
+    min-height: 28px;
+
+    padding: 0;
+    margin: 0;
+    font-size: 15px;
+    line-height: 1;
+
+    background: #fff;
+    border: 1px solid #ccc;
+    border-radius: 3px;
+    color: #333;
+    cursor: pointer;
+
+    &:hover {
+        background: #f0f0f0;
+    }
+
+    &:focus-visible {
+        outline: 2px solid #2c6cb0;
+        outline-offset: 1px;
+    }
+}
+
+// WCAG 2.4.7: uzytkownik klawiatury musi widziec, ze graf przejal focus —
+// inaczej nie wie, ze strzalki zaczely dzialac.
+#cytoscape-container:focus-visible {
+    outline: 3px solid #2c6cb0;
+    outline-offset: -3px;
+}
+
+// Waskie ekrany (Foundation small-only, ponizej 640 px).
+//
+// Graf ma CZTERY nakladki w naroznikach: #graf-panel (lewy gorny),
+// #graf-legenda (prawy gorny), #graf-notka (lewy dolny) i nawigacja (prawy
+// dolny). Przy 390 px legenda o szerokosci 260 px zaslaniala wiekszosc
+// obszaru rysowania, a notka (max-width 320 px inline) stykala sie
+// z nawigacja.
+//
+// Nakladek nie da sie przestawic z arkusza: `max-width` i `bottom` siedza
+// w atrybutach `style=""` w graf.html, a styl inline wygrywa. Zamiast
+// rozsiewac `!important` — wyprowadzamy nawigacje SPOD nakladek: na malych
+// ekranach przestaje byc pozycjonowana absolutnie i lezy pod grafem. Znika
+// kolizja ze wszystkimi czterema naroznikami naraz, a cele dotykowe robia
+// sie latwiejsze do trafienia niz przyciski nad plotnem.
+@media screen and (max-width: 39.9375em) {
+    // Legenda opisuje interakcje myszy ("Najedz na wezel…"), ktorych na
+    // ekranie dotykowym nie ma. Chowamy ja, zamiast sciskac.
+    #graf-legenda {
+        display: none;
+    }
+
+    .graf-nawigacja {
+        position: static;
+        margin-top: 8px;
+        justify-content: center;
+
+        background: none;
+        border: none;
+        padding: 0;
+    }
+}
diff --git a/src/bpp/templates/browse/uczelnia.html b/src/bpp/templates/browse/uczelnia.html
index e589ccb22..02cc7de13 100644
--- a/src/bpp/templates/browse/uczelnia.html
+++ b/src/bpp/templates/browse/uczelnia.html
@@ -100,7 +100,11 @@
         const dismissedDate = localStorage.getItem('searchBannerDismissedDate');
 
         // Show banner if not dismissed or if dismissed more than 30 days ago
-        if (!bannerDismissed || (dismissedDate && daysSince(dismissedDate) > 30)) {
+        // WCAG 2.1.4: nie reklamuj skrotu, ktory uzytkownik wylaczyl.
+        var skrotyWl = (typeof window.bppSkrotyWlaczone !== 'function'
+                        || window.bppSkrotyWlaczone());
+        if (skrotyWl
+            && (!bannerDismissed || (dismissedDate && daysSince(dismissedDate) > 30))) {
             setTimeout(function() {
                 banner.style.display = 'block';
             }, 500); // Small delay for better UX
@@ -132,7 +136,9 @@
 
     // Also close banner when user uses the shortcut
     document.addEventListener('keydown', function(e) {
-        if (e.key === '/' && !$(e.target).is('input, textarea, select')) {
+        var skrotyWl = (typeof window.bppSkrotyWlaczone !== 'function'
+                        || window.bppSkrotyWlaczone());
+        if (e.key === '/' && skrotyWl && !$(e.target).is('input, textarea, select')) {
             const banner = document.getElementById('search-shortcut-banner');
             if (banner && banner.style.display !== 'none') {
                 closeSearchBanner();
diff --git a/src/bpp/tests/test_wcag/test_skrot_szukania.py b/src/bpp/tests/test_wcag/test_skrot_szukania.py
new file mode 100644
index 000000000..611e3accb
--- /dev/null
+++ b/src/bpp/tests/test_wcag/test_skrot_szukania.py
@@ -0,0 +1,105 @@
+"""WCAG 2.1.4 — mechanizm wyłączania skrótu `/`.
+
+Skrót obsługiwany był w trzech publicznych miejscach naraz; dwa z nich
+(`base.html` i `global_search_modal.html`) otwierały wyszukiwarkę
+niezależnie, więc na jedno naciśnięcie `openGlobalSearch` wołane było
+dwukrotnie. Duplikat zlikwidowano — zostaje handler w modalu.
+
+Testy pilnują trzech rzeczy: modułu preferencji faktycznie podpiętego,
+przełącznika w stopce oraz braku powrotu usuniętego handlera.
+"""
+
+import re
+from pathlib import Path
+
+import pytest
+from django.template.loader import render_to_string
+
+import bpp
+
+SZABLONY = Path(__file__).resolve().parents[3] / "django_bpp" / "templates"
+
+# Kotwiczymy na katalogu pakietu, nie na `parents[n]` od `__file__` — ścieżka
+# liczona skokami w górę łamie się przy przeniesieniu pliku testowego.
+UCZELNIA = (
+    Path(bpp.__file__).resolve().parent / "templates" / "browse" / "uczelnia.html"
+)
+
+
+def _tresc(nazwa):
+    return (SZABLONY / nazwa).read_text(encoding="utf-8")
+
+
+def test_modul_skrotow_podpiety_w_base():
+    # Bez tego tagu przełącznik i warunki w handlerach przestają działać,
+    # a żaden inny test by tego nie wykrył.
+    assert "skroty-klawiszowe.js" in _tresc("base.html")
+
+
+def test_base_nie_ma_juz_wlasnego_handlera_skrotu():
+    # Dowód likwidacji duplikatu: handler żyje wyłącznie w modalu.
+    tresc = _tresc("base.html")
+    assert "e.key === '/'" not in tresc
+
+
+def test_modal_pyta_o_preferencje():
+    tresc = _tresc("global_search_modal.html")
+    assert "e.key === '/'" in tresc
+    assert "bppSkrotyWlaczone" in tresc
+
+
+def test_modal_ma_guard_typeof():
+    # Gdy moduł się nie załaduje, gołe wywołanie rzucałoby TypeError przy
+    # każdym naciśnięciu `/` i skrót umarłby po cichu.
+    assert "typeof window.bppSkrotyWlaczone" in _tresc("global_search_modal.html")
+
+
+# --- guardy w `browse/uczelnia.html` ---------------------------------------
+#
+# Strona uczelni ma WŁASNY, inline'owy skrypt (baner reklamujący skrót `/`
+# plus handler zamykający ten baner) — niezależny od `base.html` i modalu.
+# Oba miejsca musiały dostać ten sam warunek preferencji, bo inaczej strona
+# główna reklamowałaby i obsługiwała skrót, który użytkownik wyłączył.
+# Bez tych asercji usunięcie któregokolwiek guardu przechodzi CI: żaden test
+# Pythona nie renderuje tej strony, a Playwright jej nie odwiedza.
+
+
+def _skrypt_uczelni():
+    return UCZELNIA.read_text(encoding="utf-8")
+
+
+def test_uczelnia_baner_nie_reklamuje_wylaczonego_skrotu():
+    tresc = _skrypt_uczelni()
+    # Warunek pokazania banera musi być bramkowany preferencją — sam
+    # `bannerDismissed` nie wystarczy.
+    warunek = re.search(r"if\s*\(\s*skrotyWl\s*\n?\s*&&\s*\(!bannerDismissed", tresc)
+    assert warunek, (
+        "baner skrótu pokazuje się bez sprawdzenia preferencji — "
+        "reklamowalibyśmy skrót, który użytkownik wyłączył (2.1.4)"
+    )
+
+
+def test_uczelnia_handler_zamykajacy_pyta_o_preferencje():
+    tresc = _skrypt_uczelni()
+    handler = re.search(r"if\s*\(e\.key === '/'[^)]*\)", tresc)
+    assert handler, "zniknął handler `/` na stronie uczelni"
+    assert "skrotyWl" in handler.group(0), (
+        "handler `/` na stronie uczelni reaguje mimo wyłączonego skrótu"
+    )
+
+
+def test_uczelnia_oba_guardy_maja_typeof():
+    # Gdy moduł się nie załaduje, gołe wywołanie rzuciłoby TypeError i zabiło
+    # cały inline'owy skrypt strony głównej — nie tylko sam skrót.
+    assert _skrypt_uczelni().count("typeof window.bppSkrotyWlaczone") == 2, (
+        "oba guardy na stronie uczelni muszą tolerować brak modułu"
+    )
+
+
+@pytest.mark.django_db
+def test_stopka_ma_przelacznik(client):
+    html = render_to_string("base_footer.html", {})
+
+    assert 'id="bpp-przelacznik-skrotow"' in html
+    assert "aria-pressed" in html
+    assert 'type="button"' in html
diff --git a/src/django_bpp/templates/base.html b/src/django_bpp/templates/base.html
index 6470eb6ed..79f2fd985 100644
--- a/src/django_bpp/templates/base.html
+++ b/src/django_bpp/templates/base.html
@@ -13,6 +13,11 @@
     {% load session_security_tags %}
     {% load l10n %}
 
+    {# WCAG 2.1.4: modul preferencji skrotow jednoznakowych. Musi ladowac #}
+    {# sie bezwarunkowo — skrot "/" i przelacznik w stopce dzialaja tez #}
+    {# na stronach publicznych (np. browse/uczelnia.html) dla anonimowych. #}
+    <script src="{% static 'bpp/js/skroty-klawiszowe.js' %}"></script>
+
     {% if request.user.is_authenticated %}
         {# django-formdefaults: popup do edycji wartości domyślnych formularzy #}
         <link rel="stylesheet" type="text/css" href="{% static 'formdefaults/modal.css' %}"/>
@@ -34,20 +39,6 @@
 {% endblock %}
 
 {% block body %}
-    <script type="text/javascript">
-        // Global search hotkey handler
-        document.addEventListener('DOMContentLoaded', function() {
-            document.addEventListener('keydown', function(e) {
-                // Check if "/" key is pressed and not in an input field
-                if (e.key === '/' && !$(e.target).is('input, textarea, select')) {
-                    e.preventDefault(); // Prevent default search behavior
-                    if (typeof openGlobalSearch === 'function') {
-                        openGlobalSearch(null, true); // Pass true to indicate keyboard trigger
-                    }
-                }
-            });
-        });
-    </script>
     <script type="text/javascript">
         function adjustBreadcrumbsPosition() {
             var topBar = document.getElementById('example-menu');
diff --git a/src/django_bpp/templates/base_footer.html b/src/django_bpp/templates/base_footer.html
index b58529dd8..c89346717 100644
--- a/src/django_bpp/templates/base_footer.html
+++ b/src/django_bpp/templates/base_footer.html
@@ -1,6 +1,11 @@
 <div class="cell">
     <div class="hide-for-print cell">
         <div class="footer__content">
+            {# WCAG 2.1.4: mechanizm wylaczenia skrotow jednoznakowych. #}
+            {# Stopka, bo strona deklaracji dostepnosci jest opcjonalna #}
+            {# (Uczelnia.pokazuj_deklaracje_dostepnosci) i bywa zewnetrzna. #}
+            <button type="button" id="bpp-przelacznik-skrotow"
+                    class="footer__link-button" aria-pressed="true">Skróty klawiszowe: włączone</button> |
             {% if uczelnia.pokazuj_deklaracje_dostepnosci == 1 %}
                 <a href="{{ uczelnia.deklaracja_dostepnosci_url }}">deklaracja dostępności</a> |
             {% endif %}
@@ -37,3 +42,13 @@
         </div>
     </div>
 </div>
+
+<script type="text/javascript">
+    document.addEventListener('DOMContentLoaded', function () {
+        if (typeof window.bppPodepnijPrzelacznikSkrotow === 'function') {
+            window.bppPodepnijPrzelacznikSkrotow(
+                document.getElementById('bpp-przelacznik-skrotow')
+            );
+        }
+    });
+</script>
diff --git a/src/django_bpp/templates/global_search_modal.html b/src/django_bpp/templates/global_search_modal.html
index 45aa381f1..12d4c2998 100644
--- a/src/django_bpp/templates/global_search_modal.html
+++ b/src/django_bpp/templates/global_search_modal.html
@@ -1045,7 +1045,13 @@ <h3>Jak wyszukiwać?</h3>
             }
 
             // Check for "/" key (forward slash)
-            if (e.key === '/' && !$('#globalSearchModal').hasClass('show')) {
+            // WCAG 2.1.4: skrot jednoznakowy musi dac sie wylaczyc.
+            // Guard `typeof` — gdy modul sie nie zaladuje, degradujemy do
+            // zachowania dotychczasowego zamiast rzucac TypeError.
+            var skrotyWl = (typeof window.bppSkrotyWlaczone !== 'function'
+                            || window.bppSkrotyWlaczone());
+            if (e.key === '/' && skrotyWl
+                && !$('#globalSearchModal').hasClass('show')) {
                 e.preventDefault();
                 openGlobalSearch(null, true); // Pass true to indicate keyboard trigger
             }
diff --git a/src/integration_tests/test_wcag_skrot_i_graf.py b/src/integration_tests/test_wcag_skrot_i_graf.py
new file mode 100644
index 000000000..8ace17e0b
--- /dev/null
+++ b/src/integration_tests/test_wcag_skrot_i_graf.py
@@ -0,0 +1,480 @@
+"""WCAG 2.1.4 i 2.5.7/2.1.1 — testy zachowania w przeglądarce.
+
+Testy szablonowe (``src/bpp/tests/test_wcag/``) dowodzą, że kod jest w
+pliku; te dowodzą, że działa. Bez nich usunięcie warunku
+``bppSkrotyWlaczone()`` z handlera skrótu ``/``, albo ``preventDefault``
+z obsługi klawiatury grafu, albo samych handlerów kliknięcia przycisków
+nawigacji — nie wywaliłoby żadnego testu.
+
+Większość testów jedzie po stronie autora (``bpp:browse_autor``), bo nie
+wymaga obiektu ``Uczelnia`` w bazie (patrz też ``test_siec3d_bez_webgl.py``,
+który idzie tą samą drogą), a stopka i modal wyszukiwarki renderują się na
+niej tak samo.
+
+Wyjątkiem jest ``test_baner_skrotu_na_stronie_uczelni_slucha_preferencji``:
+strona uczelni ma WŁASNY, inline'owy skrypt reklamujący skrót, którego nie
+ma nigdzie indziej, więc tam trzeba zapłacić za seed ``Uczelnia``. Bez tego
+testu odwrócenie guardu (``|| !bppSkrotyWlaczone()``) przechodziło całą
+suitę: testy szablonowe sprawdzają regexem obecność, nie semantykę.
+
+WYMAGANIE WSTĘPNE: ``make assets`` — bez zbudowanego bundla strona nie ma
+czego wykonać i testy padną na braku elementów / błędnym zachowaniu JS.
+"""
+
+import pytest
+from django.urls import reverse
+from model_bakery import baker
+from playwright.sync_api import Page, expect
+
+from bpp.models import Autor, Uczelnia
+from powiazania_autorow.models import AuthorConnection
+
+
+def _url_autora(channels_live_server):
+    autor = baker.make(Autor, imiona="Jan", nazwisko="Kowalski", pokazuj=True)
+    return f"{channels_live_server.url}{reverse('bpp:browse_autor', args=[autor.slug])}"
+
+
+def _url_grafu(channels_live_server):
+    # Autor MUSI mieć co najmniej jednego współautora: sieć BFS o <=1 węźle
+    # trafia w gałąź "pusta sieć" w renderujSiec() (graph.js:172-178), która
+    # asynchronicznie chowa #cytoscape-container (`style.display = "none"`).
+    # Bez współautora testy klawiatury/kliknięć poniżej są wyścigiem: klawisz
+    # albo klik trafiały czasem w kontener tuż przed jego ukryciem, więc
+    # cy.pan()/cy.zoom() się nie zmieniało (~20-30% flaky, znalezisko z
+    # code review — patrz raport).
+    autor = baker.make(Autor, imiona="Jan", nazwisko="Kowalski", pokazuj=True)
+    wspolautor = baker.make(Autor, imiona="Anna", nazwisko="Nowak", pokazuj=True)
+    baker.make(
+        AuthorConnection,
+        primary_author=autor,
+        secondary_author=wspolautor,
+        shared_publications_count=3,
+    )
+    return (
+        f"{channels_live_server.url}"
+        f"{reverse('bpp:browse_autor_powiazania', args=[autor.pk])}"
+    )
+
+
+def _idz_na_strone(page: Page, url: str) -> None:
+    """Nawiguje na `url`, obchodząc dwa źródła flakiness NIEZWIĄZANE z
+    testowaną logiką (odkryte empirycznie przy pisaniu tego pliku):
+
+    1. Baner RODO (``#CookielawBanner``, ``fixed``, wysoki z-index) renderuje
+       się serwerowo, dopóki request nie niesie ciasteczka
+       ``cookielaw_accepted`` (patrz ``cookielaw.templatetags`` w pakiecie
+       ``cookielaw``) — bez tego ciasteczka przechwytuje kliknięcia na
+       ``#bpp-przelacznik-skrotow`` i przyciskach nawigacji grafu, więc
+       ustawiamy je PRZED nawigacją zamiast klikać "Zgadzam się" w każdym
+       teście.
+    2. Realne zdarzenia klawiatury (CDP ``Input.dispatchKeyEvent``) potrafią
+       trafić w nieaktywną kartę, gdy w kontekście przeglądarki istnieje
+       więcej niż jedna strona (współdzielony ``channels_live_server`` +
+       fixture ``page`` w wielu testach) — bez ``bring_to_front()``
+       ``document.activeElement`` po naciśnięciu klawisza gubi fokus
+       ustawiony chwilę wcześniej przez ``locator.focus()``.
+    """
+    page.context.add_cookies([{"name": "cookielaw_accepted", "value": "1", "url": url}])
+    page.goto(url, wait_until="domcontentloaded")
+    page.bring_to_front()
+
+
+# --- WCAG 2.1.4: skrót klawiszowy `/` i jego wyłącznik --------------------
+
+
+@pytest.mark.django_db(transaction=True)
+def test_skrot_otwiera_wyszukiwarke_domyslnie(
+    channels_live_server, page: Page, transactional_db
+):
+    _idz_na_strone(page, _url_autora(channels_live_server))
+
+    page.keyboard.press("/")
+
+    expect(page.locator("#globalSearchModal")).to_be_visible(timeout=5000)
+
+
+@pytest.mark.django_db(transaction=True)
+def test_wylaczenie_skrotu_dziala(channels_live_server, page: Page, transactional_db):
+    _idz_na_strone(page, _url_autora(channels_live_server))
+
+    page.locator("#bpp-przelacznik-skrotow").click()
+    page.keyboard.press("/")
+
+    # Handler "/" jest synchroniczny (brak fetchy/await), więc jeśli miałby
+    # otworzyć modal mimo wyłączenia, zrobiłby to natychmiast — `expect`
+    # sam odpytuje aż do timeoutu, więc twardy `wait_for_timeout` jest tu
+    # zbędny.
+    expect(page.locator("#globalSearchModal")).not_to_be_visible()
+
+
+@pytest.mark.django_db(transaction=True)
+def test_ponowne_wlaczenie_przywraca_skrot(
+    channels_live_server, page: Page, transactional_db
+):
+    _idz_na_strone(page, _url_autora(channels_live_server))
+
+    przelacznik = page.locator("#bpp-przelacznik-skrotow")
+    przelacznik.click()
+    przelacznik.click()
+    page.keyboard.press("/")
+
+    expect(page.locator("#globalSearchModal")).to_be_visible(timeout=5000)
+
+
+@pytest.mark.django_db(transaction=True)
+def test_przelacznik_aktualizuje_aria_pressed(
+    channels_live_server, page: Page, transactional_db
+):
+    _idz_na_strone(page, _url_autora(channels_live_server))
+
+    przelacznik = page.locator("#bpp-przelacznik-skrotow")
+    expect(przelacznik).to_have_attribute("aria-pressed", "true")
+
+    przelacznik.click()
+    expect(przelacznik).to_have_attribute("aria-pressed", "false")
+
+
+@pytest.mark.django_db(transaction=True)
+def test_preferencja_przezywa_przeladowanie(
+    channels_live_server, page: Page, transactional_db
+):
+    url = _url_autora(channels_live_server)
+    _idz_na_strone(page, url)
+
+    page.locator("#bpp-przelacznik-skrotow").click()
+    page.reload(wait_until="domcontentloaded")
+
+    expect(page.locator("#bpp-przelacznik-skrotow")).to_have_attribute(
+        "aria-pressed", "false"
+    )
+
+
+# --- WCAG 2.5.7 / 2.1.1: nawigacja po grafie powiązań ----------------------
+#
+# Samo sprawdzenie widoczności przycisku nie wystarczy: przycisk zostałby
+# widoczny, nawet gdyby ktoś odpiął mu handler kliknięcia. Cytoscape.js
+# przechowuje żywą instancję na `container._cyreg.cy` (wewnętrzny rejestr
+# biblioteki, ale stabilny w praktyce) — czytamy z niej realny stan widoku
+# (zoom/pan) PRZED i PO interakcji, więc test faktycznie pada, gdy handler
+# zniknie, a nie tylko gdy zniknie sam element z DOM.
+
+
+def _cy_zoom(page):
+    return page.evaluate(
+        "document.getElementById('cytoscape-container')._cyreg.cy.zoom()"
+    )
+
+
+def _cy_pan(page):
+    return page.evaluate(
+        "document.getElementById('cytoscape-container')._cyreg.cy.pan()"
+    )
+
+
+def _ustaw_zoom_z_zapasem(page):
+    """Ustawia zoom na 1 i sprawdza, że do `maxZoom` został zapas.
+
+    Po wyrenderowaniu sieci `renderujSiec()` woła `cy.fit()`, a przy
+    dwuwęzłowej sieci testowej dopasowanie dobija do `maxZoom` (4, patrz
+    ``powiazania/cy.js``). `zoomuj()` przycina wynik do `cy.maxZoom()`, więc
+    przybliżanie jest wtedy — całkiem poprawnie — operacją pustą i asercja
+    "zoom wzrósł" pada mimo sprawnego handlera. Zamiast dobierać liczbę
+    współautorów tak, żeby `fit()` przypadkiem zostawił zapas (kruche:
+    zależy od geometrii układu i rozmiaru viewportu), ustawiamy punkt
+    startowy jawnie.
+    """
+    page.evaluate("document.getElementById('cytoscape-container')._cyreg.cy.zoom(1)")
+    assert _cy_zoom(page) < page.evaluate(
+        "document.getElementById('cytoscape-container')._cyreg.cy.maxZoom()"
+    ), "brak zapasu do maxZoom -- test przybliżania nie mógłby niczego dowieść"
+
+
+def _czekaj_na_graf(page):
+    """Czeka, aż `renderujSiec()` (``powiazania/graph.js``) SKOŃCZY
+    renderowanie sieci — nie tylko na to, że instancja Cytoscape istnieje.
+
+    Samo `_cyreg.cy` powstaje synchronicznie przy starcie (`utworzCy()`),
+    ZANIM fetch `siec.json` w ogóle wystartuje, więc czekanie na nie było
+    czekaniem na nic: klawisz albo klik w oknie między "cy istnieje" a
+    "render się skończył" trafiał w pusty, jeszcze nieustawiony widok
+    i `cy.pan()`/`cy.zoom()` się nie zmieniało (~20-30% flaky).
+
+    Czekamy więc na sygnał POZYTYWNY — obecność węzłów. `cy.nodes()`
+    zapełnia dopiero `renderujSiec()`, przechodząc `data.nodes` już po
+    odpowiedzi z `siec.json`, więc niezerowa liczba węzłów dowodzi, że
+    asynchroniczna gałąź się zakończyła. Warunek "kontener nie jest
+    ukryty" byłby tu bezużyteczny: ``#cytoscape-container`` nie ma w
+    szablonie reguły ``display``, więc `getComputedStyle` zwraca "block"
+    od chwili sparsowania elementu — spełniałby się PRZED renderem,
+    a gałąź pustej sieci (`graph.js:172-178`) ustawia `display: none`
+    dopiero potem. `_url_grafu` seeduje współautora, żeby w tę gałąź
+    w ogóle nie wejść.
+    """
+    page.wait_for_function(
+        "() => {"
+        " const k = document.getElementById('cytoscape-container');"
+        " return !!(k && k._cyreg && k._cyreg.cy"
+        " && k._cyreg.cy.nodes().length > 0);"
+        "}",
+        timeout=15000,
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_ma_przyciski_nawigacji_i_jest_fokusowalny(
+    channels_live_server, page: Page, transactional_db
+):
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    kontener = page.locator("#cytoscape-container")
+    expect(kontener).to_have_attribute("tabindex", "0")
+    expect(page.locator("#graf-nav-dopasuj")).to_be_visible(timeout=10000)
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_przycisk_zoom_realnie_zmienia_widok(
+    channels_live_server, page: Page, transactional_db
+):
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    expect(page.locator("#graf-nav-zoom-in")).to_be_visible(timeout=10000)
+    _czekaj_na_graf(page)
+    _ustaw_zoom_z_zapasem(page)
+
+    zoom_przed = _cy_zoom(page)
+    page.locator("#graf-nav-zoom-in").click()
+    zoom_po = _cy_zoom(page)
+
+    assert zoom_po > zoom_przed, (
+        "klik #graf-nav-zoom-in nie zmienil cy.zoom() -- handler kliknięcia "
+        "odpiety albo usuniety?"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_przycisk_kierunkowy_realnie_przesuwa_widok(
+    channels_live_server, page: Page, transactional_db
+):
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    expect(page.locator("#graf-nav-gora")).to_be_visible(timeout=10000)
+    _czekaj_na_graf(page)
+
+    pan_przed = _cy_pan(page)
+    page.locator("#graf-nav-gora").click()
+    pan_po = _cy_pan(page)
+
+    assert pan_po != pan_przed, (
+        "klik #graf-nav-gora nie zmienil cy.pan() -- handler kliknięcia "
+        "odpiety albo usuniety?"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_strzalka_z_klawiatury_realnie_przesuwa_widok(
+    channels_live_server, page: Page, transactional_db
+):
+    # Dowód wiązania klawiatura -> nawigacja (WCAG 2.1.1): funkcja dostępna
+    # myszką jako "przesuń w górę" musi być dostępna też z klawiatury.
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    kontener = page.locator("#cytoscape-container")
+    kontener.focus()
+
+    pan_przed = _cy_pan(page)
+    page.keyboard.press("ArrowUp")
+    pan_po = _cy_pan(page)
+
+    assert pan_po != pan_przed, (
+        "ArrowUp na sfokusowanym #cytoscape-container nie zmienil cy.pan() "
+        "-- obsluzKlawisz odpiety od kontenera?"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_nie_jest_pulapka_klawiaturowa(
+    channels_live_server, page: Page, transactional_db
+):
+    # Handler robi preventDefault WYŁĄCZNIE dla obsłużonych klawiszy. Gdyby
+    # blokował wszystko, Tab przestałby wyprowadzać focus — czyli naprawiając
+    # 2.1.1 stworzylibyśmy pułapkę klawiaturową i złamalibyśmy 2.1.2.
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    kontener = page.locator("#cytoscape-container")
+    kontener.focus()
+    expect(kontener).to_be_focused()
+
+    page.keyboard.press("Tab")
+
+    assert page.evaluate("document.activeElement.id") != "cytoscape-container"
+
+
+def _url_grafu_bez_powiazan(channels_live_server):
+    """Autor BEZ współautorów — sieć jednowęzłowa, gałąź „pusta" w
+    ``renderujSiec()``. To nie jest przypadek egzotyczny: ``AuthorConnection``
+    liczy się raz na dobę, więc każdy świeżo dodany autor trafia tu zawsze.
+    """
+    autor = baker.make(Autor, imiona="Samotny", nazwisko="Badacz", pokazuj=True)
+    return (
+        f"{channels_live_server.url}"
+        f"{reverse('bpp:browse_autor_powiazania', args=[autor.pk])}"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_pusty_chowa_nawigacje(channels_live_server, page: Page, transactional_db):
+    # Po ukryciu płótna `#graf-wrapper` zapada się do wysokości akapitu,
+    # a nawigacja — pozycjonowana absolutnie względem niego — wychodziła
+    # PONAD wrapper i nachodziła na komunikat „Brak powiązań". Przyciski
+    # były przy tym martwe (`cy.width()` ukrytego kontenera to 0, więc
+    # `przesun` robi `panBy({x: 0, y: 0})`) i zostawały w kolejności Taba:
+    # siedem kontrolek, które nic nie robią, a audyt widzi je jako spełnienie
+    # 2.5.7.
+    _idz_na_strone(page, _url_grafu_bez_powiazan(channels_live_server))
+
+    expect(page.locator("#graf-empty")).to_be_visible(timeout=10000)
+    expect(page.locator("#graf-nawigacja")).not_to_be_visible()
+
+
+@pytest.mark.django_db(transaction=True)
+def test_przyciski_grafu_maja_cel_dotykowy_24px(
+    channels_live_server, page: Page, transactional_db
+):
+    # WCAG 2.5.8: cel nie mniejszy niż 24x24 px CSS. SCSS deklaruje
+    # `min-width/height: 28px`, ale nic tego nie pilnowało — zejście do
+    # 10px przechodziło całą suitę.
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    przyciski = page.locator(".graf-nawigacja__btn")
+    assert przyciski.count() == 7
+    for i in range(przyciski.count()):
+        bb = przyciski.nth(i).bounding_box()
+        nazwa = przyciski.nth(i).get_attribute("id")
+        assert bb["width"] >= 24 and bb["height"] >= 24, (
+            f"{nazwa}: cel {bb['width']}x{bb['height']} px, próg 2.5.8 to 24x24"
+        )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_przelacznik_skrotow_ma_cel_dotykowy_24px(
+    channels_live_server, page: Page, transactional_db
+):
+    # Ten sam próg dla przełącznika w stopce. `.footer__content` ma
+    # `font-size: 70%`, więc bez paddingu cel miał 15 px wysokości — a to
+    # JEDYNY sposób skorzystania z naprawy 2.1.4, adresowanej do osób ze
+    # sterowaniem głosem i zaburzeniami motoryki.
+    _idz_na_strone(page, _url_autora(channels_live_server))
+
+    bb = page.locator("#bpp-przelacznik-skrotow").bounding_box()
+    assert bb["height"] >= 24, (
+        f"przełącznik ma {bb['height']} px wysokości, próg 2.5.8 to 24"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_kontener_grafu_ma_widoczny_pierscien_focusa(
+    channels_live_server, page: Page, transactional_db
+):
+    # WCAG 2.4.7. Przy `role="application"` + `tabindex="0"` to nie jest
+    # ozdoba: bez widocznego focusa użytkownik nie wie, że strzałki zaczęły
+    # sterować grafem, a nie przewijaniem strony. Skasowanie bloku
+    # `:focus-visible` przechodziło wcześniej całą suitę.
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    page.locator("#cytoscape-container").focus()
+    obrys = page.evaluate(
+        "getComputedStyle(document.getElementById('cytoscape-container')).outlineWidth"
+    )
+
+    assert obrys not in ("", "0px"), (
+        f"kontener grafu nie ma pierścienia focusa (outline-width={obrys!r})"
+    )
+
+
+def _url_uczelni(channels_live_server):
+    uczelnia = baker.make(Uczelnia, nazwa="Uczelnia Testowa", skrot="UT")
+    return (
+        f"{channels_live_server.url}"
+        f"{reverse('bpp:browse_uczelnia', args=[uczelnia.slug])}"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_baner_skrotu_na_stronie_uczelni_slucha_preferencji(
+    channels_live_server, page: Page, transactional_db
+):
+    # Strona uczelni ma WŁASNY, inline'owy skrypt reklamujący skrót `/`.
+    # Testy szablonowe sprawdzają go regexem po źródle, więc przepuszczają
+    # odwróconą logikę (`|| !bppSkrotyWlaczone()`): guard nadal tam jest,
+    # nadal ma `typeof`, nadal nazywa się `skrotyWl` — a baner reklamuje
+    # skrót DOKŁADNIE wtedy, gdy użytkownik go wyłączył. Wyłapie to tylko
+    # test sprawdzający skutek, i to jest ten test.
+    url = _url_uczelni(channels_live_server)
+    _idz_na_strone(page, url)
+
+    baner = page.locator("#search-shortcut-banner")
+    expect(baner).to_be_visible(timeout=5000)
+
+    page.locator("#bpp-przelacznik-skrotow").click()
+    page.reload(wait_until="domcontentloaded")
+
+    # Baner wstaje przez `setTimeout(..., 500)`, więc dajemy mu szansę się
+    # pojawić i dopiero potem stwierdzamy, że go nie ma.
+    expect(page.locator("#bpp-przelacznik-skrotow")).to_have_attribute(
+        "aria-pressed", "false"
+    )
+    expect(baner).not_to_be_visible(timeout=2000)
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_na_waskim_ekranie_nawigacja_nie_zaslania_plotna(
+    channels_live_server, page: Page, transactional_db
+):
+    # Graf ma cztery nakładki w narożnikach. Przy 390 px legenda (260 px)
+    # zasłaniała większość obszaru rysowania, a notka (320 px) stykała się
+    # z nawigacją. Media query wyprowadza nawigację spod nakładek — poniżej
+    # płótna — i chowa legendę, która i tak opisuje interakcje myszy.
+    #
+    # Bez tego testu regresja w arkuszu przechodzi niezauważona: przyciski
+    # nadal istnieją i nadal działają, więc pozostałe testy są zielone.
+    page.set_viewport_size({"width": 390, "height": 844})
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    expect(page.locator("#graf-legenda")).not_to_be_visible()
+
+    # Legenda może zniknąć, ale klucz do ODCZYTU grafu — co znaczy wielkość
+    # koła i grubość linii — musi zostać. Chowanie treści na małym ekranie
+    # to strata informacji, nie dekoracji (1.3.1). Dlatego to zdanie żyje
+    # w `<small>` nad grafem, nie w chowanej nakładce.
+    expect(page.get_by_text("Wielkość koła odpowiada")).to_be_visible()
+
+    plotno = page.locator("#cytoscape-container").bounding_box()
+    nawigacja = page.locator("#graf-nawigacja").bounding_box()
+    assert nawigacja["y"] >= plotno["y"] + plotno["height"] - 1, (
+        "nawigacja nadal leży NA płótnie przy 390 px — media query nie działa"
+    )
+
+
+@pytest.mark.django_db(transaction=True)
+def test_graf_na_szerokim_ekranie_nawigacja_zostaje_na_plotnie(
+    channels_live_server, page: Page, transactional_db
+):
+    # Kontrola dla testu wyżej: na desktopie nakładka ma pozostać nakładką.
+    # Inaczej "naprawa" wąskich ekranów mogłaby po cichu przenieść przyciski
+    # pod graf na wszystkich rozdzielczościach.
+    page.set_viewport_size({"width": 1440, "height": 900})
+    _idz_na_strone(page, _url_grafu(channels_live_server))
+    _czekaj_na_graf(page)
+
+    expect(page.locator("#graf-legenda")).to_be_visible()
+
+    plotno = page.locator("#cytoscape-container").bounding_box()
+    nawigacja = page.locator("#graf-nawigacja").bounding_box()
+    assert nawigacja["y"] < plotno["y"] + plotno["height"], (
+        "nawigacja zjechała pod płótno na desktopie"
+    )
diff --git a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js
index fed8f256c..c7bce355f 100644
--- a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js
+++ b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/controls.js
@@ -3,6 +3,7 @@
 // źródeł/wydawców, opcje zaawansowane, metryka, układ, wyszukiwarka,
 // odśwież oraz eksport PNG/SVG. Debounce dla żądań sterowanych suwakami.
 import { pobierzPlik } from "./dom.js";
+import { podepnijNawigacje } from "./nawigacja.js";
 import {
     pokazPanelAutora,
     pokazTooltipAutor,
@@ -371,4 +372,11 @@ export function podepnijZdarzenia(ctx) {
     } else if (btnSvg) {
         btnSvg.style.display = "none"; // rozszerzenie SVG nie załadowane
     }
+
+    // --- nawigacja bez przeciagania (2.5.7) i klawiatura (2.1.1) ---
+    // Cale spoiwo DOM -> akcja siedzi w nawigacja.js, zeby dalo sie je
+    // przetestowac bez importowania tego modulu. Bez tego mapowanie
+    // przyciskow bylo nietestowane: zamiana "gora" z "dol" przechodzila
+    // cala suite.
+    podepnijNawigacje(cy);
 }
diff --git a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/graph.js b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/graph.js
index 80039822a..4ef78e9e9 100644
--- a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/graph.js
+++ b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/graph.js
@@ -173,11 +173,19 @@ export function renderujSiec(ctx, data) {
         ctx.container.style.display = "none";
         if (ctx.emptyEl) { ctx.emptyEl.style.display = "block"; }
         if (ctx.notkaEl) { ctx.notkaEl.style.display = "none"; }
+        // Nawigacja jest pozycjonowana absolutnie wzgledem #graf-wrapper.
+        // Po ukryciu plotna wrapper zapada sie do wysokosci akapitu, a panel
+        // (~100 px) wychodzi PONAD niego i nachodzi na komunikat "Brak
+        // powiazan". Przyciski sa przy tym martwe: cy.width() ukrytego
+        // kontenera to 0, wiec przesun() robi panBy({x: 0, y: 0}). Zostawaly
+        // tez w kolejnosci Taba — siedem kontrolek, ktore nic nie robia.
+        if (ctx.nawigacjaEl) { ctx.nawigacjaEl.style.display = "none"; }
         ctx.animujDodawanie = true;
         return;
     }
     ctx.container.style.display = "";
     if (ctx.emptyEl) { ctx.emptyEl.style.display = "none"; }
+    if (ctx.nawigacjaEl) { ctx.nawigacjaEl.style.display = ""; }
 
     const children = {};
     const levelOf = {};
diff --git a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js
new file mode 100644
index 000000000..1aaaa2984
--- /dev/null
+++ b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js
@@ -0,0 +1,168 @@
+// Nawigacja po grafie bez przeciagania (WCAG 2.5.7 Dragging Movements) oraz
+// z klawiatury (2.1.1 Keyboard). Kryterium 2.5.7 wymaga, zeby funkcje
+// dostepna przez przeciaganie dalo sie wykonac pojedynczym wskaznikiem —
+// stad przyciski. Te same funkcje obsluguja klawiature.
+//
+// Modul operuje wylacznie na publicznym API Cytoscape, wiec da sie go
+// przetestowac na atrapie, bez uruchamiania biblioteki.
+
+// Krok przesuniecia jako UDZIAL rozmiaru widoku, nie stala w pikselach:
+// przy duzym przyblizeniu stala byla by ledwo zauwazalna, przy oddaleniu
+// przeskakiwala by caly graf.
+const UDZIAL_KROKU = 0.2;
+
+export function przesun(cy, kierunek) {
+    const dx = cy.width() * UDZIAL_KROKU;
+    const dy = cy.height() * UDZIAL_KROKU;
+
+    // Znaki sa odwrocone wzgledem intuicji: `panBy` przesuwa PLOTNO,
+    // a przyciski opisuja ruch WIDOKU. "w prawo" = plotno w lewo.
+    switch (kierunek) {
+        case "prawo":
+            cy.panBy({ x: -dx, y: 0 });
+            break;
+        case "lewo":
+            cy.panBy({ x: dx, y: 0 });
+            break;
+        case "dol":
+            cy.panBy({ x: 0, y: -dy });
+            break;
+        case "gora":
+            cy.panBy({ x: 0, y: dy });
+            break;
+        default:
+            break;
+    }
+}
+
+export function zoomuj(cy, wspolczynnik) {
+    // Limity czytamy z instancji (utworzCy ustawia minZoom 0.1, maxZoom 4),
+    // zeby nie duplikowac ich w dwoch miejscach.
+    const docelowy = Math.min(
+        Math.max(cy.zoom() * wspolczynnik, cy.minZoom()),
+        cy.maxZoom()
+    );
+
+    cy.zoom({
+        level: docelowy,
+        renderedPosition: { x: cy.width() / 2, y: cy.height() / 2 }
+    });
+}
+
+export function dopasuj(cy) {
+    cy.fit();
+}
+
+// Mapuje zdarzenie keydown na akcje nawigacji po grafie (WCAG 2.1.1).
+// Zwraca true, jesli klawisz zostal obsluzony — wolajacy uzywa tego, zeby
+// zdecydowac, czy wywolac preventDefault (WYLACZNIE dla obsluzonych
+// klawiszy; inaczej Tab zostalby zablokowany w grafie — pulapka
+// klawiaturowa, zlamanie 2.1.2).
+//
+// Skroty z modyfikatorem naleza do przegladarki, nie do nas: Ctrl/Cmd +/-
+// to zoom strony (WCAG 1.4.4 Resize Text), Alt+strzalka to nawigacja
+// wstecz/wprzod, Ctrl+Home to przewijanie na gore. Przechwycenie ich
+// zlamaloby funkcje wazniejsze niz nawigacja po grafie — stad wczesne
+// wyjscie. `shiftKey` NIE wchodzi do tego warunku: na wielu ukladach
+// klawiatury `+` wymaga Shift, wiec jego zablokowanie zepsuloby
+// przyblizanie grafu tej samej klawiszologii, ktora ma dzialac.
+// Mapowanie identyfikatora przycisku na kierunek. Wyniesione z controls.js,
+// zeby dalo sie je sprawdzic testem — samo `przesun()` bylo przetestowane
+// porzadnie, ale SPOIWO miedzy DOM-em a nim nie bylo wcale, wiec zamiana
+// "gora" z "dol" przechodzila cala suite na zielono.
+export const KIERUNKI_PRZYCISKOW = {
+    "graf-nav-gora": "gora",
+    "graf-nav-dol": "dol",
+    "graf-nav-lewo": "lewo",
+    "graf-nav-prawo": "prawo"
+};
+
+export const KROK_ZOOMU = 1.2;
+
+// Podpina 7 przyciskow nawigacji i obsluge klawiatury. `dok` wstrzykiwany
+// dla testow (domyslnie globalny `document`).
+//
+// Zwraca element, do ktorego podpieto keydown — wolajacy i test moga sie
+// upewnic, ze to KONTENER GRAFU, a nie `document`. To nie jest kosmetyka:
+// `+` i `-` sa znakami drukowalnymi, wiec podlegaja 2.1.4, a spelniamy je
+// trzecim wariantem kryterium — "aktywne wylacznie gdy komponent ma focus".
+// Podpiecie tego handlera do `document` zamienilo by je w globalne skroty
+// jednoznakowe, czyli zlamalo dokladnie to kryterium, ktore ta galaz naprawia.
+export function podepnijNawigacje(cy, dok) {
+    const d = dok || document;
+
+    Object.keys(KIERUNKI_PRZYCISKOW).forEach(function (id) {
+        const btn = d.getElementById(id);
+        if (btn) {
+            btn.addEventListener("click", function () {
+                przesun(cy, KIERUNKI_PRZYCISKOW[id]);
+            });
+        }
+    });
+
+    [
+        ["graf-nav-zoom-in", KROK_ZOOMU],
+        ["graf-nav-zoom-out", 1 / KROK_ZOOMU]
+    ].forEach(function (para) {
+        const btn = d.getElementById(para[0]);
+        if (btn) {
+            btn.addEventListener("click", function () {
+                zoomuj(cy, para[1]);
+            });
+        }
+    });
+
+    const btnDopasuj = d.getElementById("graf-nav-dopasuj");
+    if (btnDopasuj) {
+        btnDopasuj.addEventListener("click", function () {
+            dopasuj(cy);
+        });
+    }
+
+    const kontener = d.getElementById("cytoscape-container");
+    if (kontener) {
+        kontener.addEventListener("keydown", function (e) {
+            // preventDefault WYLACZNIE dla obsluzonych klawiszy. Blokowanie
+            // wszystkiego zamknelo by Tab w grafie, czyli naprawiajac 2.1.1
+            // stworzylibysmy pulapke klawiaturowa i zlamali 2.1.2.
+            if (obsluzKlawisz(cy, e)) {
+                e.preventDefault();
+            }
+        });
+    }
+    return kontener;
+}
+
+export function obsluzKlawisz(cy, e) {
+    if (e.ctrlKey || e.metaKey || e.altKey) {
+        return false;
+    }
+
+    switch (e.key) {
+        case "ArrowUp":
+            przesun(cy, "gora");
+            return true;
+        case "ArrowDown":
+            przesun(cy, "dol");
+            return true;
+        case "ArrowLeft":
+            przesun(cy, "lewo");
+            return true;
+        case "ArrowRight":
+            przesun(cy, "prawo");
+            return true;
+        case "+":
+        case "=":
+            zoomuj(cy, 1.2);
+            return true;
+        case "-":
+        case "_":
+            zoomuj(cy, 1 / 1.2);
+            return true;
+        case "Home":
+            dopasuj(cy);
+            return true;
+        default:
+            return false;
+    }
+}
diff --git a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/state.js b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/state.js
index e5e0fe6c7..6a1098cc7 100644
--- a/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/state.js
+++ b/src/powiazania_autorow/static/powiazania_autorow/js/powiazania/state.js
@@ -30,6 +30,7 @@ export function utworzKontekst() {
         container: container,
         emptyEl: document.getElementById("graf-empty"),
         notkaEl: document.getElementById("graf-notka"),
+        nawigacjaEl: document.getElementById("graf-nawigacja"),
         tooltip: document.getElementById("graf-tooltip"),
         panel: document.getElementById("graf-panel"),
         slider: slider,
diff --git a/src/powiazania_autorow/templates/powiazania_autorow/graf.html b/src/powiazania_autorow/templates/powiazania_autorow/graf.html
index b2a24852c..dd33b3342 100644
--- a/src/powiazania_autorow/templates/powiazania_autorow/graf.html
+++ b/src/powiazania_autorow/templates/powiazania_autorow/graf.html
@@ -149,13 +149,25 @@ <h1>Sieć powiązań — {{ autor }}</h1>
             </button>
         </div>
     </div>
+    {# Klucz do odczytu grafu stoi TUTAJ, nie w nakladce #graf-legenda: #}
+    {# legenda jest chowana ponizej 640 px (graf_powiazan.scss), a bez tego #}
+    {# zdania uzytkownik telefonu widzi kola roznej wielkosci i linie roznej #}
+    {# grubosci, nie wiedzac, co znacza. Chowanie TRESCI na malym ekranie to #}
+    {# strata informacji, nie dekoracji — czyli dokladnie to, przed czym #}
+    {# stoi 1.3.1. W legendzie zostaja wylacznie podpowiedzi o najechaniu #}
+    {# kursorem, ktorych na ekranie dotykowym i tak nie ma. #}
     <small style="display: block; color: #666; margin: 6px 0 12px;">
         Na każdym węźle pokazujemy najpierw współautorów z największą liczbą
         wspólnych publikacji. Klik w węzeł dowija jego dalszych współautorów.
+        Wielkość koła odpowiada wybranej metryce (liczba prac / IF / PK),
+        a grubość linii — liczbie wspólnych publikacji.
     </small>
 
     <div id="graf-wrapper" style="position: relative;">
         <div id="cytoscape-container"
+             tabindex="0"
+             role="application"
+             aria-label="Graf powiązań autorów. Strzałki przesuwają widok, plus i minus przybliżają, klawisz Home dopasowuje graf do ekranu."
              data-autor-id="{{ autor.pk }}"
              data-autor-label="{{ autor.imiona }} {{ autor.nazwisko }}"
              data-dane-url-template="{% url 'bpp:browse_autor_powiazania_dane' 0 %}"
@@ -171,9 +183,7 @@ <h1>Sieć powiązań — {{ autor }}</h1>
                     color: #444; pointer-events: none; z-index: 1001;">
             Najedź na węzeł, aby zobaczyć autora; najedź na linię, aby zobaczyć
             liczbę wspólnych publikacji. Kliknij węzeł, aby rozwinąć jego
-            współautorów i otworzyć menu akcji. Wielkość koła odpowiada wybranej
-            metryce (liczba prac / IF / PK), a grubość linii — liczbie wspólnych
-            publikacji.
+            współautorów i otworzyć menu akcji.
         </div>
         <div id="graf-tooltip"
              style="position: absolute; display: none; pointer-events: none;
@@ -197,6 +207,25 @@ <h1>Sieć powiązań — {{ autor }}</h1>
             sieć przekroczyła limit węzłów. Zmniejsz głębokość lub liczbę
             współautorów, aby zobaczyć węższy, pełny wycinek.
         </div>
+        {# WCAG 2.5.7: nawigacja bez przeciagania. Prawy dolny rog to #}
+        {# jedyny wolny — lewy gorny zajmuje #graf-panel, prawy gorny #}
+        {# #graf-legenda, lewy dolny #graf-notka (przy przycietej sieci). #}
+        <div id="graf-nawigacja" class="graf-nawigacja">
+            <button type="button" id="graf-nav-gora" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w górę"><span aria-hidden="true">↑</span></button>
+            <button type="button" id="graf-nav-lewo" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w lewo"><span aria-hidden="true">←</span></button>
+            <button type="button" id="graf-nav-dopasuj" class="graf-nawigacja__btn"
+                    aria-label="Dopasuj graf do ekranu"><span aria-hidden="true">⤢</span></button>
+            <button type="button" id="graf-nav-prawo" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w prawo"><span aria-hidden="true">→</span></button>
+            <button type="button" id="graf-nav-dol" class="graf-nawigacja__btn"
+                    aria-label="Przesuń widok w dół"><span aria-hidden="true">↓</span></button>
+            <button type="button" id="graf-nav-zoom-in" class="graf-nawigacja__btn"
+                    aria-label="Przybliż"><span aria-hidden="true">+</span></button>
+            <button type="button" id="graf-nav-zoom-out" class="graf-nawigacja__btn"
+                    aria-label="Oddal"><span aria-hidden="true">−</span></button>
+        </div>
     </div>
 
     <script src="{% static 'powiazania_autorow/js/dist/cytoscape-bundle.js' %}"></script>
diff --git a/src/powiazania_autorow/test_graf_dostepnosc.py b/src/powiazania_autorow/test_graf_dostepnosc.py
new file mode 100644
index 000000000..6f1b95f87
--- /dev/null
+++ b/src/powiazania_autorow/test_graf_dostepnosc.py
@@ -0,0 +1,98 @@
+"""Dostępność grafu powiązań: nawigacja wskaźnikiem (2.5.7) i klawiaturą (2.1.1).
+
+Graf stoi na Cytoscape.js i do tej pory dawał się przesuwać wyłącznie
+przeciąganiem. Kryterium 2.5.7 wymaga alternatywy realizowanej pojedynczym
+wskaźnikiem — stąd przyciski. Sam kontener zyskuje `tabindex`, żeby te same
+funkcje dało się wywołać z klawiatury (2.1.1).
+"""
+
+from pathlib import Path
+
+import powiazania_autorow
+
+# Kotwiczymy na katalogu PAKIETU, nie na `__file__` testu: ścieżka liczona
+# przez `parents[n]` łamie się przy każdym przeniesieniu pliku testowego, a
+# ten plik już raz zmienił miejsce (mieszkał w `tests/`, która to nazwa
+# przesłaniała istniejący moduł `powiazania_autorow.tests` i wywalała
+# kolekcję pytesta).
+SZABLON = (
+    Path(powiazania_autorow.__file__).resolve().parent
+    / "templates"
+    / "powiazania_autorow"
+    / "graf.html"
+)
+
+PRZYCISKI = [
+    "graf-nav-gora",
+    "graf-nav-dol",
+    "graf-nav-lewo",
+    "graf-nav-prawo",
+    "graf-nav-zoom-in",
+    "graf-nav-zoom-out",
+    "graf-nav-dopasuj",
+]
+
+
+def _tresc():
+    return SZABLON.read_text(encoding="utf-8")
+
+
+def test_wszystkie_przyciski_nawigacji_obecne():
+    tresc = _tresc()
+    for identyfikator in PRZYCISKI:
+        assert f'id="{identyfikator}"' in tresc, f"brak przycisku {identyfikator}"
+
+
+def test_kazdy_przycisk_ma_aria_label():
+    # Sam glif strzałki nic nie mówi czytnikowi ekranu.
+    tresc = _tresc()
+    fragmenty = tresc.split("<button")
+    nawigacyjne = [f for f in fragmenty if "graf-nav-" in f]
+
+    assert len(nawigacyjne) == len(PRZYCISKI)
+    for fragment in nawigacyjne:
+        assert "aria-label=" in fragment
+
+
+def test_przyciski_sa_typu_button():
+    # Bez type="button" przycisk wewnątrz formularza wysyła go.
+    tresc = _tresc()
+    for fragment in tresc.split("<button")[1:]:
+        if "graf-nav-" in fragment:
+            assert 'type="button"' in fragment
+
+
+def test_glify_ukryte_przed_czytnikiem():
+    # Treść dla czytnika jest w aria-label; glif to dekoracja.
+    tresc = _tresc()
+    for fragment in tresc.split("<button")[1:]:
+        if "graf-nav-" in fragment:
+            assert 'aria-hidden="true"' in fragment
+
+
+def test_kontener_grafu_jest_fokusowalny():
+    # Bez tabindex użytkownik klawiatury nigdy nie dotrze do grafu.
+    tresc = _tresc()
+    fragment = tresc.split('id="cytoscape-container"')[1][:600]
+
+    assert 'tabindex="0"' in fragment
+
+
+def test_kontener_grafu_ma_role_application():
+    # Bez tego czytnik ekranu w trybie przeglądania sam obsłuży strzałki
+    # i nigdy nie dotrą one do grafu.
+    tresc = _tresc()
+    fragment = tresc.split('id="cytoscape-container"')[1][:600]
+
+    assert 'role="application"' in fragment
+
+
+def test_kontener_grafu_opisuje_dostepne_klawisze():
+    # role="application" wycisza tryb przeglądania, więc aria-label jest
+    # jedynym sposobem, w jaki użytkownik pozna dostępne klawisze.
+    tresc = _tresc()
+    fragment = tresc.split('id="cytoscape-container"')[1][:600]
+
+    assert "aria-label=" in fragment
+    for slowo in ("trzałk", "Home"):
+        assert slowo in fragment
diff --git a/tests/js/graf-klawiatura.test.js b/tests/js/graf-klawiatura.test.js
new file mode 100644
index 000000000..69969cb12
--- /dev/null
+++ b/tests/js/graf-klawiatura.test.js
@@ -0,0 +1,181 @@
+// Obsluga grafu powiazan klawiatura (WCAG 2.1.1) — mapowanie klawisza na
+// akcje (obsluzKlawisz) siedzi w nawigacja.js, wiec testujemy je na atrapie
+// cy (jak w nawigacja-grafu.test.js), bez importowania controls.js (ktory
+// ciagnie pol aplikacji).
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { obsluzKlawisz } from "../../src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js";
+
+function atrapaCy(opcje) {
+    opcje = opcje || {};
+    const stan = {
+        panBy: null,
+        zoomArg: null,
+        fitWolane: false,
+        poziomZoom: opcje.zoom === undefined ? 1 : opcje.zoom
+    };
+    return {
+        _stan: stan,
+        width: () => (opcje.width === undefined ? 1000 : opcje.width),
+        height: () => (opcje.height === undefined ? 500 : opcje.height),
+        minZoom: () => 0.1,
+        maxZoom: () => 4,
+        zoom: function (arg) {
+            if (arg === undefined) {
+                return stan.poziomZoom;
+            }
+            stan.zoomArg = arg;
+            stan.poziomZoom = arg.level;
+            return undefined;
+        },
+        panBy: function (arg) {
+            stan.panBy = arg;
+        },
+        fit: function () {
+            stan.fitWolane = true;
+        }
+    };
+}
+
+// Zdarzenie klawiatury jako zwykly obiekt — obsluzKlawisz nie wywoluje na
+// nim nic poza odczytem pol, wiec nie potrzeba prawdziwego KeyboardEvent.
+function zdarzenie(key, modyfikatory) {
+    modyfikatory = modyfikatory || {};
+    return {
+        key: key,
+        ctrlKey: modyfikatory.ctrlKey || false,
+        metaKey: modyfikatory.metaKey || false,
+        altKey: modyfikatory.altKey || false,
+        shiftKey: modyfikatory.shiftKey || false
+    };
+}
+
+describe("obsluzKlawisz — strzalki", () => {
+    let cy;
+    beforeEach(() => {
+        cy = atrapaCy();
+    });
+
+    it("ArrowUp przesuwa w gore i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("ArrowUp"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.panBy.y).toBeGreaterThan(0);
+        expect(cy._stan.panBy.x).toBe(0);
+    });
+
+    it("ArrowDown przesuwa w dol i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("ArrowDown"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.panBy.y).toBeLessThan(0);
+        expect(cy._stan.panBy.x).toBe(0);
+    });
+
+    it("ArrowLeft przesuwa w lewo i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("ArrowLeft"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.panBy.x).toBeGreaterThan(0);
+        expect(cy._stan.panBy.y).toBe(0);
+    });
+
+    it("ArrowRight przesuwa w prawo i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("ArrowRight"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.panBy.x).toBeLessThan(0);
+        expect(cy._stan.panBy.y).toBe(0);
+    });
+});
+
+describe("obsluzKlawisz — zoom", () => {
+    let cy;
+    beforeEach(() => {
+        cy = atrapaCy({ zoom: 1 });
+    });
+
+    it("'+' przyblizA (wspolczynnik > 1) i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("+"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.zoomArg.level).toBeGreaterThan(1);
+    });
+
+    it("'=' przyblizA i zwraca true (bez Shift na wiekszosci ukladow)", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("="));
+        expect(wynik).toBe(true);
+        expect(cy._stan.zoomArg.level).toBeGreaterThan(1);
+    });
+
+    it("'-' oddala (wspolczynnik < 1) i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("-"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.zoomArg.level).toBeLessThan(1);
+    });
+
+    it("'_' oddala i zwraca true", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("_"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.zoomArg.level).toBeLessThan(1);
+    });
+});
+
+describe("obsluzKlawisz — Home", () => {
+    it("Home dopasowuje graf (cy.fit()) i zwraca true", () => {
+        const cy = atrapaCy();
+        const wynik = obsluzKlawisz(cy, zdarzenie("Home"));
+        expect(wynik).toBe(true);
+        expect(cy._stan.fitWolane).toBe(true);
+    });
+});
+
+describe("obsluzKlawisz — klawisze nieobslugiwane (bez pulapki, 2.1.2)", () => {
+    let cy;
+    beforeEach(() => {
+        cy = atrapaCy();
+    });
+
+    it.each(["Tab", "Escape", "Enter", "a"])(
+        "%s zwraca false i nic nie wola",
+        (klawisz) => {
+            const wynik = obsluzKlawisz(cy, zdarzenie(klawisz));
+            expect(wynik).toBe(false);
+            expect(cy._stan.panBy).toBeNull();
+            expect(cy._stan.zoomArg).toBeNull();
+            expect(cy._stan.fitWolane).toBe(false);
+        }
+    );
+});
+
+describe("obsluzKlawisz — skroty przegladarki nie sa przechwytywane (1.4.4)", () => {
+    let cy;
+    beforeEach(() => {
+        cy = atrapaCy();
+    });
+
+    it("Ctrl+ArrowUp zwraca false i nic nie wola (skrot przegladarki)", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("ArrowUp", { ctrlKey: true }));
+        expect(wynik).toBe(false);
+        expect(cy._stan.panBy).toBeNull();
+    });
+
+    it("Cmd(meta)+'+' zwraca false (Cmd+Plus to zoom przegladarki)", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("+", { metaKey: true }));
+        expect(wynik).toBe(false);
+        expect(cy._stan.zoomArg).toBeNull();
+    });
+
+    it("Ctrl+Home zwraca false (przewijanie strony na gore)", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("Home", { ctrlKey: true }));
+        expect(wynik).toBe(false);
+        expect(cy._stan.fitWolane).toBe(false);
+    });
+
+    it("Alt+ArrowLeft zwraca false (nawigacja wstecz przegladarki)", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("ArrowLeft", { altKey: true }));
+        expect(wynik).toBe(false);
+        expect(cy._stan.panBy).toBeNull();
+    });
+
+    it("'+' z Shift zwraca true i przyblizA (Shift potrzebny do wpisania +)", () => {
+        const wynik = obsluzKlawisz(cy, zdarzenie("+", { shiftKey: true }));
+        expect(wynik).toBe(true);
+        expect(cy._stan.zoomArg.level).toBeGreaterThan(1);
+    });
+});
diff --git a/tests/js/nawigacja-grafu.test.js b/tests/js/nawigacja-grafu.test.js
new file mode 100644
index 000000000..2ec8ca3cf
--- /dev/null
+++ b/tests/js/nawigacja-grafu.test.js
@@ -0,0 +1,140 @@
+// Nawigacja po grafie powiazan bez przeciagania (WCAG 2.5.7) i z klawiatury
+// (2.1.1). Modul operuje na instancji Cytoscape przez jej publiczne API,
+// wiec testujemy go na atrapie — bez uruchamiania biblioteki.
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+    przesun,
+    zoomuj,
+    dopasuj
+} from "../../src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js";
+
+function atrapaCy(opcje) {
+    opcje = opcje || {};
+    const stan = {
+        panBy: null,
+        zoomArg: null,
+        fitWolane: false,
+        poziomZoom: opcje.zoom === undefined ? 1 : opcje.zoom
+    };
+    return {
+        _stan: stan,
+        width: () => (opcje.width === undefined ? 1000 : opcje.width),
+        height: () => (opcje.height === undefined ? 500 : opcje.height),
+        minZoom: () => 0.1,
+        maxZoom: () => 4,
+        zoom: function (arg) {
+            if (arg === undefined) {
+                return stan.poziomZoom;
+            }
+            stan.zoomArg = arg;
+            stan.poziomZoom = arg.level;
+            return undefined;
+        },
+        panBy: function (arg) {
+            stan.panBy = arg;
+        },
+        fit: function () {
+            stan.fitWolane = true;
+        }
+    };
+}
+
+describe("przesun", () => {
+    let cy;
+    beforeEach(() => {
+        cy = atrapaCy();
+    });
+
+    it("w prawo przesuwa widok w lewo (ujemny x)", () => {
+        przesun(cy, "prawo");
+        expect(cy._stan.panBy.x).toBeLessThan(0);
+        expect(cy._stan.panBy.y).toBe(0);
+    });
+
+    it("w lewo przesuwa widok w prawo (dodatni x)", () => {
+        przesun(cy, "lewo");
+        expect(cy._stan.panBy.x).toBeGreaterThan(0);
+        expect(cy._stan.panBy.y).toBe(0);
+    });
+
+    it("w dol przesuwa widok w gore (ujemny y)", () => {
+        przesun(cy, "dol");
+        expect(cy._stan.panBy.y).toBeLessThan(0);
+        expect(cy._stan.panBy.x).toBe(0);
+    });
+
+    it("w gore przesuwa widok w dol (dodatni y)", () => {
+        przesun(cy, "gora");
+        expect(cy._stan.panBy.y).toBeGreaterThan(0);
+        expect(cy._stan.panBy.x).toBe(0);
+    });
+
+    it("krok skaluje sie z szerokoscia widoku", () => {
+        const waski = atrapaCy({ width: 500 });
+        const szeroki = atrapaCy({ width: 2000 });
+        przesun(waski, "prawo");
+        przesun(szeroki, "prawo");
+        expect(Math.abs(szeroki._stan.panBy.x)).toBeGreaterThan(
+            Math.abs(waski._stan.panBy.x)
+        );
+    });
+
+    it("krok skaluje sie z wysokoscia widoku", () => {
+        // Osobny test dla osi Y, bo `przesun` liczy dy z `cy.height()`, a nie
+        // z `cy.width()`: pomylka w tej jednej literze przeszlaby test wyzej
+        // (tam wysokosc jest stala), a pionowy krok skalowalby sie szerokoscia.
+        const niski = atrapaCy({ height: 250 });
+        const wysoki = atrapaCy({ height: 1000 });
+        przesun(niski, "gora");
+        przesun(wysoki, "gora");
+        expect(Math.abs(wysoki._stan.panBy.y)).toBeGreaterThan(
+            Math.abs(niski._stan.panBy.y)
+        );
+    });
+
+    it("nieznany kierunek nic nie robi", () => {
+        przesun(cy, "wszedzie");
+        expect(cy._stan.panBy).toBeNull();
+    });
+});
+
+describe("zoomuj", () => {
+    it("przyblizanie zwieksza poziom", () => {
+        const cy = atrapaCy({ zoom: 1 });
+        zoomuj(cy, 1.2);
+        expect(cy._stan.zoomArg.level).toBeCloseTo(1.2);
+    });
+
+    it("oddalanie zmniejsza poziom", () => {
+        const cy = atrapaCy({ zoom: 1 });
+        zoomuj(cy, 1 / 1.2);
+        expect(cy._stan.zoomArg.level).toBeLessThan(1);
+    });
+
+    it("nie przekracza maxZoom", () => {
+        const cy = atrapaCy({ zoom: 3.9 });
+        zoomuj(cy, 1.2);
+        expect(cy._stan.zoomArg.level).toBe(4);
+    });
+
+    it("nie schodzi ponizej minZoom", () => {
+        const cy = atrapaCy({ zoom: 0.11 });
+        zoomuj(cy, 1 / 1.2);
+        expect(cy._stan.zoomArg.level).toBe(0.1);
+    });
+
+    it("zoomuje wokol srodka widoku", () => {
+        const cy = atrapaCy({ width: 1000, height: 500 });
+        zoomuj(cy, 1.2);
+        expect(cy._stan.zoomArg.renderedPosition).toEqual({ x: 500, y: 250 });
+    });
+});
+
+describe("dopasuj", () => {
+    it("wola cy.fit()", () => {
+        const cy = atrapaCy();
+        dopasuj(cy);
+        expect(cy._stan.fitWolane).toBe(true);
+    });
+});
diff --git a/tests/js/podepnij-nawigacje.test.js b/tests/js/podepnij-nawigacje.test.js
new file mode 100644
index 000000000..072c804ea
--- /dev/null
+++ b/tests/js/podepnij-nawigacje.test.js
@@ -0,0 +1,197 @@
+// @vitest-environment jsdom
+//
+// Spoiwo miedzy DOM-em a nawigacja po grafie: ktory przycisk wywoluje ktora
+// akcje i GDZIE wisi handler klawiatury.
+//
+// Ten plik powstal po przegladzie mutacyjnym, ktory pokazal, ze sama logika
+// (`przesun`, `zoomuj`, `obsluzKlawisz`) byla przetestowana porzadnie, ale
+// spoiwo nie bylo testowane WCALE. Cztery mutacje przechodzily wtedy cala
+// suite na zielono:
+//   * zamiana "gora" z "dol" w mapie kierunkow,
+//   * wszystkie cztery strzalki robiace to samo,
+//   * odpiety handler zoom-out albo "dopasuj",
+//   * podpiecie keydown do `document` zamiast do kontenera grafu,
+//   * usuniety `preventDefault`.
+// Ostatnia jest najgrozniejsza: `+` i `-` to znaki drukowalne, wiec podlegaja
+// 2.1.4, a spelniamy je trzecim wariantem kryterium ("aktywne wylacznie przy
+// focusie komponentu"). Handler na `document` zamienia je w globalne skroty
+// jednoznakowe — czyli lamie dokladnie to, co ta galaz naprawia.
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+    KIERUNKI_PRZYCISKOW,
+    podepnijNawigacje
+} from "../../src/powiazania_autorow/static/powiazania_autorow/js/powiazania/nawigacja.js";
+
+const PRZYCISKI = [
+    "graf-nav-gora",
+    "graf-nav-dol",
+    "graf-nav-lewo",
+    "graf-nav-prawo",
+    "graf-nav-zoom-in",
+    "graf-nav-zoom-out",
+    "graf-nav-dopasuj"
+];
+
+function atrapaCy() {
+    const stan = { panBy: [], zoom: [], fit: 0 };
+    return {
+        _stan: stan,
+        width: () => 1000,
+        height: () => 500,
+        zoom: (arg) => {
+            if (arg === undefined) {
+                return 1;
+            }
+            stan.zoom.push(arg);
+            return undefined;
+        },
+        minZoom: () => 0.1,
+        maxZoom: () => 4,
+        panBy: (arg) => stan.panBy.push(arg),
+        fit: () => (stan.fit += 1)
+    };
+}
+
+function zbudujDom() {
+    document.body.innerHTML =
+        '<div id="cytoscape-container"></div>' +
+        PRZYCISKI.map((id) => `<button id="${id}"></button>`).join("");
+    return document;
+}
+
+describe("podepnijNawigacje — mapowanie przyciskow", () => {
+    let cy;
+
+    beforeEach(() => {
+        cy = atrapaCy();
+        podepnijNawigacje(cy, zbudujDom());
+    });
+
+    // Znaki `panBy` sa odwrocone wzgledem intuicji: przesuwaja PLOTNO, a
+    // przycisk opisuje ruch WIDOKU. "w gore" => plotno w dol => dodatni y.
+    it.each([
+        ["graf-nav-gora", "y", 1],
+        ["graf-nav-dol", "y", -1],
+        ["graf-nav-lewo", "x", 1],
+        ["graf-nav-prawo", "x", -1]
+    ])("%s przesuwa wlasciwa os we wlasciwa strone", (id, os, znak) => {
+        document.getElementById(id).click();
+
+        expect(cy._stan.panBy).toHaveLength(1);
+        const ruch = cy._stan.panBy[0];
+        expect(Math.sign(ruch[os])).toBe(znak);
+        // druga os musi zostac nietknieta — inaczej "w gore" moglby
+        // jednoczesnie jechac w bok
+        expect(ruch[os === "x" ? "y" : "x"]).toBe(0);
+    });
+
+    it("kazdy kierunek daje INNY ruch niz pozostale", () => {
+        // Lapie mutacje "wszystkie strzalki robia to samo", ktorej testy
+        // per-przycisk osobno by nie zlapaly, gdyby akurat trafily w ten
+        // sam kierunek.
+        Object.keys(KIERUNKI_PRZYCISKOW).forEach((id) =>
+            document.getElementById(id).click()
+        );
+
+        const podpisy = cy._stan.panBy.map((r) => `${r.x}|${r.y}`);
+        expect(new Set(podpisy).size).toBe(4);
+    });
+
+    it("przyblizanie zwieksza, oddalanie zmniejsza", () => {
+        document.getElementById("graf-nav-zoom-in").click();
+        document.getElementById("graf-nav-zoom-out").click();
+
+        expect(cy._stan.zoom).toHaveLength(2);
+        expect(cy._stan.zoom[0].level).toBeGreaterThan(1);
+        expect(cy._stan.zoom[1].level).toBeLessThan(1);
+    });
+
+    it("dopasuj wola cy.fit()", () => {
+        // Jedyna akcja RATUNKOWA: uzytkownik klawiatury, ktory wyjechal
+        // widokiem poza graf, bez niej nie ma powrotu.
+        document.getElementById("graf-nav-dopasuj").click();
+
+        expect(cy._stan.fit).toBe(1);
+    });
+
+    it("kazdy z siedmiu przyciskow cos robi", () => {
+        // Strazniik przed odpieciem dowolnego handlera. Test szablonowy
+        // potwierdza tylko, ze przycisk ISTNIEJE w HTML-u, a martwy przycisk
+        // jest gorszy niz jego brak: audyt widzi kontrolke, uzytkownik nie
+        // dostaje funkcji (2.5.7 formalnie niespelnione).
+        PRZYCISKI.forEach((id) => {
+            const przed = cy._stan.panBy.length + cy._stan.zoom.length + cy._stan.fit;
+            document.getElementById(id).click();
+            const po = cy._stan.panBy.length + cy._stan.zoom.length + cy._stan.fit;
+
+            expect(po, `przycisk ${id} nie robi nic`).toBeGreaterThan(przed);
+        });
+    });
+});
+
+describe("podepnijNawigacje — gdzie wisi klawiatura (2.1.4)", () => {
+    let cy;
+    let kontener;
+
+    beforeEach(() => {
+        cy = atrapaCy();
+        kontener = podepnijNawigacje(cy, zbudujDom());
+    });
+
+    it("handler wisi na kontenerze grafu, nie na document", () => {
+        expect(kontener).toBe(document.getElementById("cytoscape-container"));
+    });
+
+    it("strzalka w kontenerze przesuwa widok", () => {
+        kontener.dispatchEvent(
+            new window.KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true })
+        );
+
+        expect(cy._stan.panBy).toHaveLength(1);
+    });
+
+    it("`+` POZA grafem nie zoomuje", () => {
+        // Sedno zgodnosci z 2.1.4 dla `+`/`-`. Gdyby handler wisial na
+        // `document`, to zdarzenie by go uruchomilo i skrot jednoznakowy
+        // dzialalby globalnie.
+        const obcy = document.createElement("input");
+        document.body.appendChild(obcy);
+
+        obcy.dispatchEvent(
+            new window.KeyboardEvent("keydown", { key: "+", bubbles: true })
+        );
+
+        expect(cy._stan.zoom).toHaveLength(0);
+    });
+
+    it("obsluzony klawisz dostaje preventDefault, nieobsluzony nie", () => {
+        // Bez preventDefault strzalka jednoczesnie przesuwa graf i przewija
+        // strone. Z preventDefault na WSZYSTKIM — Tab przestaje wyprowadzac
+        // focus i robi sie pulapka klawiaturowa (2.1.2).
+        const strzalka = new window.KeyboardEvent("keydown", {
+            key: "ArrowUp",
+            bubbles: true,
+            cancelable: true
+        });
+        const tab = new window.KeyboardEvent("keydown", {
+            key: "Tab",
+            bubbles: true,
+            cancelable: true
+        });
+
+        kontener.dispatchEvent(strzalka);
+        kontener.dispatchEvent(tab);
+
+        expect(strzalka.defaultPrevented).toBe(true);
+        expect(tab.defaultPrevented).toBe(false);
+    });
+
+    it("brak przyciskow w DOM nie wywala podpinania", () => {
+        document.body.innerHTML = "";
+        const cy2 = atrapaCy();
+
+        expect(() => podepnijNawigacje(cy2, document)).not.toThrow();
+    });
+});
diff --git a/tests/js/skroty-klawiszowe.test.js b/tests/js/skroty-klawiszowe.test.js
new file mode 100644
index 000000000..5183ddf3a
--- /dev/null
+++ b/tests/js/skroty-klawiszowe.test.js
@@ -0,0 +1,233 @@
+// @vitest-environment jsdom
+//
+// Preferencja skrotow jednoznakowych (WCAG 2.1.4). Kryterium wymaga, zeby
+// uzytkownik mogl skrot wylaczyc — BPP w czesci publicznej nie ma kont, wiec
+// preferencja siedzi w localStorage. Domyslka to "wlaczone": brak wpisu nie
+// moze zmieniac zachowania nikomu, kto nic nie ustawil.
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+const ZRODLO = readFileSync(
+    resolve(__dirname, "../../src/bpp/static/bpp/js/skroty-klawiszowe.js"),
+    "utf-8"
+);
+
+// Podmienia CALY obiekt `localStorage` na atrape z podanymi nadpisaniami
+// i zwraca funkcje przywracajaca oryginal.
+//
+// NIE wolno tu robic `window.localStorage.setItem = () => {...}`. W jsdom
+// `Storage` jest legacy platform object: przypisanie nieznanej wlasciwosci
+// nie przeslania metody, tylko ZAPISUJE POZYCJE o kluczu "setItem".
+// Prawdziwy `setItem` wykonuje sie wtedy dalej, a test przestaje sprawdzac
+// to, co deklaruje. Zachowanie zalezy od wersji jsdom: lokalnie testy
+// przechodzily, a na CI padl ten jeden, ktory FAKTYCZNIE potrzebowal
+// dzialajacego stubu (`expected '0' to be null`). Pozostale trzy
+// przechodzily niezaleznie od tego, czy stub zadzialal — czyli nie
+// pilnowaly niczego.
+function podmienStorage(nadpisania) {
+    const oryginalny = window.localStorage;
+    const atrapa = {
+        getItem: (k) => oryginalny.getItem(k),
+        setItem: (k, v) => oryginalny.setItem(k, v),
+        removeItem: (k) => oryginalny.removeItem(k),
+        clear: () => oryginalny.clear(),
+        ...nadpisania,
+    };
+    Object.defineProperty(window, "localStorage", {
+        value: atrapa,
+        configurable: true,
+        writable: true,
+    });
+    return function przywroc() {
+        Object.defineProperty(window, "localStorage", {
+            value: oryginalny,
+            configurable: true,
+            writable: true,
+        });
+    };
+}
+
+const RZUCAJACY_ZAPIS = {
+    setItem: () => {
+        throw new Error("QuotaExceededError");
+    },
+};
+
+function zaladuj() {
+    // Modul jest skryptem window-globalnym (IIFE), nie modulem ESM —
+    // wykonujemy go na biezacym window jsdom.
+    new Function(ZRODLO).call(window);
+    return window;
+}
+
+beforeEach(() => {
+    // Polyfill localStorage jeśli nie jest dostępny (jsdom 25+)
+    if (!window.localStorage) {
+        const store = {};
+        window.localStorage = {
+            getItem: (key) => store[key] || null,
+            setItem: (key, value) => {
+                store[key] = String(value);
+            },
+            removeItem: (key) => {
+                delete store[key];
+            },
+            clear: () => {
+                Object.keys(store).forEach((key) => delete store[key]);
+            },
+            key: (index) => Object.keys(store)[index] || null,
+            get length() {
+                return Object.keys(store).length;
+            },
+        };
+    }
+    window.localStorage.clear();
+    delete window.bppSkrotyWlaczone;
+    delete window.bppUstawSkroty;
+    delete window.bppPodepnijPrzelacznikSkrotow;
+});
+
+describe("bppSkrotyWlaczone", () => {
+    it("domyslnie wlaczone gdy brak wpisu", () => {
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(true);
+    });
+
+    it('"0" wylacza', () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "0");
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(false);
+    });
+
+    it('"1" wlacza', () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "1");
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(true);
+    });
+
+    it("smiec w localStorage traktowany jak brak wpisu", () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "tak");
+        expect(zaladuj().bppSkrotyWlaczone()).toBe(true);
+    });
+
+    it("nie rzuca gdy localStorage niedostepny", () => {
+        const przywroc = podmienStorage({
+            getItem: () => {
+                throw new Error("SecurityError");
+            },
+        });
+        try {
+            const w = zaladuj();
+            expect(w.bppSkrotyWlaczone()).toBe(true);
+        } finally {
+            przywroc();
+        }
+    });
+});
+
+describe("bppUstawSkroty", () => {
+    it("zapisuje wylaczenie i zwraca nowy stan", () => {
+        const w = zaladuj();
+        expect(w.bppUstawSkroty(false)).toBe(false);
+        expect(window.localStorage.getItem("bpp.skrotyJednoznakowe")).toBe("0");
+        expect(w.bppSkrotyWlaczone()).toBe(false);
+    });
+
+    it("zapisuje wlaczenie", () => {
+        const w = zaladuj();
+        w.bppUstawSkroty(false);
+        expect(w.bppUstawSkroty(true)).toBe(true);
+        expect(window.localStorage.getItem("bpp.skrotyJednoznakowe")).toBe("1");
+    });
+
+    it("nie rzuca gdy zapis niemozliwy", () => {
+        const przywroc = podmienStorage(RZUCAJACY_ZAPIS);
+        try {
+            const w = zaladuj();
+            expect(() => w.bppUstawSkroty(false)).not.toThrow();
+        } finally {
+            przywroc();
+        }
+    });
+
+    it("fallback: gdy setItem rzuca, stan trzyma się w sesji (nie w localStorage)", () => {
+        const przywroc = podmienStorage(RZUCAJACY_ZAPIS);
+        try {
+            const w = zaladuj();
+            w.bppUstawSkroty(false);
+            // localStorage jest puste (zapis się nie powiódł)
+            expect(window.localStorage.getItem("bpp.skrotyJednoznakowe")).toBe(
+                null
+            );
+            // ale bppSkrotyWlaczone() zwraca false (z fallback-u w pamięci)
+            expect(w.bppSkrotyWlaczone()).toBe(false);
+        } finally {
+            przywroc();
+        }
+    });
+
+    it("fallback: przełącznik działa w sesji nawet bez localStorage", () => {
+        const przywroc = podmienStorage(RZUCAJACY_ZAPIS);
+        try {
+            const w = zaladuj();
+            const el = window.document.createElement("button");
+            window.document.body.appendChild(el);
+            w.bppPodepnijPrzelacznikSkrotow(el);
+            // Initialnie włączone
+            expect(el.getAttribute("aria-pressed")).toBe("true");
+            // Klik wyłącza
+            el.click();
+            expect(el.getAttribute("aria-pressed")).toBe("false");
+            expect(el.textContent).toContain("wyłączone");
+            // Drugi klik włącza
+            el.click();
+            expect(el.getAttribute("aria-pressed")).toBe("true");
+            expect(el.textContent).toContain("włączone");
+        } finally {
+            przywroc();
+        }
+    });
+});
+
+describe("bppPodepnijPrzelacznikSkrotow", () => {
+    function przycisk() {
+        const el = window.document.createElement("button");
+        window.document.body.appendChild(el);
+        return el;
+    }
+
+    it("ustawia stan poczatkowy na wlaczony", () => {
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        expect(el.getAttribute("aria-pressed")).toBe("true");
+        expect(el.textContent).toContain("włączone");
+    });
+
+    it("klik wylacza skroty i aktualizuje etykiete", () => {
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        el.click();
+        expect(w.bppSkrotyWlaczone()).toBe(false);
+        expect(el.getAttribute("aria-pressed")).toBe("false");
+        expect(el.textContent).toContain("wyłączone");
+    });
+
+    it("drugi klik wraca do stanu wyjsciowego", () => {
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        el.click();
+        el.click();
+        expect(w.bppSkrotyWlaczone()).toBe(true);
+        expect(el.getAttribute("aria-pressed")).toBe("true");
+    });
+
+    it("odzwierciedla stan zapisany wczesniej", () => {
+        window.localStorage.setItem("bpp.skrotyJednoznakowe", "0");
+        const w = zaladuj();
+        const el = przycisk();
+        w.bppPodepnijPrzelacznikSkrotow(el);
+        expect(el.getAttribute("aria-pressed")).toBe("false");
+    });
+});