# Trwała pamięć agentów: claude-mem, planning-with-files i serwery MCP pamięci

URL: https://developertoolkit.ai/pl/ecosystem/plugins/memory-plugins/
Description: Utrzymaj wielodniowe zadanie agenta mimo /clear dzięki planning-with-files, a claude-mem, serwer MCP Memory i basic-memory dodaj tylko tam, gdzie się opłacają.

Trwała pamięć agentów występuje w dwóch odmianach: jako plan zadania na dysku, który przetrwa `/clear` i kompakcję (planning-with-files), oraz jako magazyn wspomnień z wcześniejszymi decyzjami (claude-mem, serwer Memory MCP, basic-memory). Jeśli prowadzisz zadanie agenta przez kilka sesji, zacznij od planu na dysku, a magazyn wspomnień dodaj dopiero wtedy, gdy potrzebujesz odpowiedzi z wielu tygodni.

Drugi dzień pracy nad funkcją. Wczoraj sesja doszła do 80% kontekstu, uruchomiłeś `/clear`, a dziś rano agent przez dwadzieścia minut czyta repozytorium od nowa, proponuje projekt ponawiania, który odrzuciłeś pierwszego dnia, i nie wie, które testy już przechodzą. Ta strona jest dla programistów, których zadania dla agenta trwają dłużej niż jedno okno kontekstu, i dla liderów technicznych, którzy decydują, jakie narzędzia pamięci mogą mieć kontakt z kodem firmy.

## Co daje trwała pamięć przy wielodniowym zadaniu

- Tabelę decyzyjną pięciu miejsc, w których może żyć pamięć agenta: ile kosztuje każde i dokąd trafiają twoje dane
- planning-with-files zainstalowany w Claude Code, Codeksie albo Cursorze i sprawdzenie, że jego hooki naprawdę się uruchamiają
- Przykład krok po kroku: wznowienie niedokończonego zadania po `/clear` bez ponownego tłumaczenia
- Wielodniowy przepływ pracy nad funkcją oparty na `task_plan.md`, `findings.md` i `progress.md`, z bramką weryfikacji na każdej fazie
- Bezpieczne instalacje claude-mem, referencyjnego serwera Memory i basic-memory oraz pułapki każdego z nich

## Które narzędzie pamięci pasuje do którego zadania?

Zacznij od tego, co agent już ma. `CLAUDE.md`, `.claude/rules/` i auto memory w Claude Code oraz `AGENTS.md` w Codeksie przenoszą trwałą wiedzę o projekcie przez recenzowane commity; opisują je strony o [systemie pamięci Claude Code](/pl/claude-code/build/memory-system/) i [wzorcach długoterminowego zachowania kontekstu](/pl/workflows/context/memory-patterns/). Codex ma też funkcję `memories`, stabilną, ale domyślnie wyłączoną (sprawdzone przez `codex features list` w wersji 0.157.1). Narzędzia z tej strony rozwiązują dwa inne problemy, których te pliki nie rozwiązują.

| Narzędzie | Co przechowuje | Gdzie | Stały koszt | Czy dane opuszczają maszynę? | Najlepsze do |
| --------- | -------------- | ----- | ----------- | ---------------------------- | ------------ |
| planning-with-files | Bieżący plan jednego zadania: fazy, ustalenia, postęp | Trzy pliki Markdown w projekcie | ~1124 tokeny (plugin 3.20.8) | Nie; skill nie ma ścieżki wysyłania | Zadań, które trwają kilka sesji lub dni |
| claude-mem | Skompresowane obserwacje z każdej sesji, z wyszukiwaniem | SQLite (`~/.claude-mem/claude-mem.db`) i Chroma | ~2000 tokenów (13.25.3) plus wstrzykiwany kontekst | Zależy od `--provider`; domyślnie proponowany jest hostowany observer | Przypominania sobie ustaleń z wielu zadań i tygodni |
| Referencyjny serwer Memory | Graf wiedzy: encje, relacje, obserwacje | Jeden plik JSONL (`MEMORY_FILE_PATH`) | Tylko schematy narzędzi MCP | Nie | Małych, jawnych faktów, które ma pamiętać klient czatu |
| basic-memory | Notatki Markdown powiązane w graf | Domyślnie `~/basic-memory` | Tylko schematy narzędzi MCP | Nie, chyba że skierujesz projekt do jego chmury | Czytelnych notatek współdzielonych z Obsidianem |
| `CLAUDE.md`, `AGENTS.md`, auto memory | Konwencje i decyzje dla repozytorium albo dla ciebie | Repozytorium albo `~/.claude/projects/` | Rozmiar pliku | Nie | Wszystkiego, co powinien wiedzieć cały zespół |

Koszty w tokenach to wyniki `claude plugin details` z Claude Code 2.1.283 z 2026-09-26, zebrane w badaniach do tej strony. Wynik claude-mem zmierzono na wersji 13.25.3; aktualna jest 13.28.0, więc po instalacji uruchom ponownie `claude plugin details claude-mem@thedotmack`. Hooki nie zużywają kontekstu, chyba że wstrzykują tekst, a hook `SessionStart` w claude-mem to robi.

**Popularność na dzień 2026-09-26** (gwiazdki GitHub odczytane tego dnia przez API GitHub): thedotmack/claude-mem 94,7 tys., OthmanAdi/planning-with-files 27,1 tys., basicmachines-co/basic-memory 4,0 tys. Serwer Memory znajduje się w repozytorium modelcontextprotocol/servers (90,6 tys. gwiazdek dla całego repozytorium, nie dla samego Memory). Gwiazdki mierzą zainteresowanie repozytorium, a nie dopasowanie do twojego kodu.

**Plan i pamięć to różne rzeczy**

planning-with-files zarządza stanem zadania, które wykonujesz teraz: która faza jest aktywna, jaki jest następny krok, co przeszło. Magazyn wspomnień odpowiada na pytania o przeszłość. README planning-with-files mówi, że te dwa podejścia się uzupełniają. Większość zespołów najpierw potrzebuje planu.

## Zainstaluj planning-with-files w swoim agencie

O skuteczności planning-with-files decydują hooki: wstrzykują plan przy każdym prompcie i po `/clear`. Każda z poniższych ścieżek zachowuje hooki; jednolinijkowa instalacja samego skilla ich nie daje, dlatego jest na końcu.

**Claude Code**

Jeśli pluginy i marketplace'y są dla ciebie nowe, przeczytaj najpierw, [jak działają pluginy w trzech agentach](/pl/ecosystem/plugins/). Uruchom w sesji Claude Code:

```text
/plugin marketplace add OthmanAdi/planning-with-files
/plugin install planning-with-files@planning-with-files
```

Potem w terminalu sprawdź, co plugin ładuje do każdej sesji:

```bash
claude plugin details planning-with-files@planning-with-files
```

W wersji 3.20.8 wynik to 14 skilli, 6 hooków i około 1124 stałe tokeny; 2026-09-26 README podawało już v3.21.0, więc powtarzaj to polecenie po każdej aktualizacji. Wróć do sesji i uruchom `/planning-with-files:plan-doctor`: wypisze po jednej linii PASS, WARN albo FAIL dla rozwiązywania planu, wstrzykiwania, atestacji, ścieżek instalacji i opóźnienia hooków.

**Codex**

Przewodnik autora dla Codeksa instaluje skill w repozytorium i samodzielne hooki. Uruchom w katalogu głównym projektu:

```bash
git clone https://github.com/OthmanAdi/planning-with-files.git /tmp/planning-with-files
mkdir -p .agents/skills .codex
cp -r /tmp/planning-with-files/.agents/skills/planning-with-files .agents/skills/
cp /tmp/planning-with-files/.codex/hooks.json .codex/hooks.json
cp -r /tmp/planning-with-files/.codex/hooks .codex/hooks
rm -rf /tmp/planning-with-files
```

Hooki są w codex-cli 0.157.1 i 0.162.1 stabilne i domyślnie włączone (`codex features list`, sprawdzone 2026-10-12), ale Codex uruchamia nowy hook dopiero wtedy, gdy mu zaufasz: otwórz TUI, wpisz `/hooks` i przejrzyj każdy wpis. Jeśli `.codex/hooks.json` już istnieje, scal wpisy zamiast nadpisywać plik. Repozytorium zawiera też pakiet pluginu dla Codeksa; nie włączaj go razem z samodzielnymi hookami, bo Codex uruchamia każdy pasujący hook z każdego źródła.

**Cursor**

Przewodnik autora dla Cursora kopiuje katalog `.cursor` ze skillem, plikiem `hooks.json` i skryptami hooków:

```bash
git clone https://github.com/OthmanAdi/planning-with-files.git /tmp/planning-with-files
mkdir -p .cursor
cp -r /tmp/planning-with-files/.cursor/skills /tmp/planning-with-files/.cursor/hooks .cursor/
cp /tmp/planning-with-files/.cursor/hooks.json .cursor/hooks.json
rm -rf /tmp/planning-with-files
```

Jeśli projekt ma już `hooks.json`, scal go ręcznie. W Cursorze plan trafia do kontekstu na starcie rozmowy (`sessionStart`), a nie przy każdym prompcie, więc po zresetowaniu kontekstu zacznij nowy czat. Według przewodnika autora Cursor Cloud Agents nie uruchamiają `sessionStart`, więc przebieg w chmurze nie dostaje planu z hooka. Te szczegóły pochodzą z pliku `docs/cursor.md` projektu; cursor.com był 2026-09-26 nieosiągalny z naszego środowiska.

Dla każdego innego agenta ścieżka Agent Skills instaluje skill jednym poleceniem:

```bash
npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g
```

README opisuje tę ścieżkę jako wzorzec „bez hooków cyklu życia”: bez komend z ukośnikiem, bez wstrzykiwania planu przy każdym prompcie i bez odzyskiwania w `SessionStart`. Używaj jej, gdy agent nie ma ścieżki pluginu, i po resecie proś o plan wprost.

## Wznów zadanie po /clear z planning-with-files

Przykład dotyczy Claude Code. Opisane wyżej ścieżki dla Codeksa i Cursora nie instalują komend z ukośnikiem, więc tam plan zaczynasz prośbą (pierwszy prompt poniżej już ją zawiera), pomijasz komendy `/planning-with-files:*`, a kontekst resetujesz przez `/new` w Codeksie albo nowy czat w Cursorze.

1. Zacznij plan. Uruchom `/planning-with-files:plan`, potem wklej prompt z zadaniem podany niżej. Agent zapisze `task_plan.md`, `findings.md` i `progress.md` w katalogu głównym projektu. Wpisz komendę z przestrzenią nazw: w Claude Code samo `/plan` włącza wbudowany tryb planowania.

2. Przejdź pierwsze fazy. W trakcie pracy agent dopisuje wyniki rozpoznania do `findings.md`, loguje polecenia i wyniki testów w `progress.md` i odhacza punkty w `task_plan.md`. `/planning-with-files:status` pokazuje bieżącą fazę i podsumowanie postępu.

3. Zapisz punkt kontrolny przed resetem. Gdy kontekst się zapełnia, wklej prompt punktu kontrolnego podany niżej, żeby trzy pliki zawierały wszystko, czego potrzebuje następna sesja.

4. Uruchom `/clear`. Rozmowa znika, pliki zostają.

5. Wklej prompt wznowienia. Hook `UserPromptSubmit` wstrzykuje nagłówek planu, zanim model zobaczy twoją wiadomość.

6. Sprawdź, co widzisz. Pierwsza odpowiedź agenta podaje bieżącą fazę i następny krok dokładnie tak, jak zapisano je w `task_plan.md`, a przed edycją kodu agent uruchamia ostatnie zapisane polecenie testowe. Jeśli zamiast tego zaczyna od nowa przeglądać repozytorium, uruchom `/planning-with-files:plan-doctor`.

**Prompt do skopiowania: plan z weryfikowalnymi fazami**

```text
Plan this task with planning-with-files before writing any code.

Task: move webhook retries from in-process setTimeout calls to a D1-backed outbox table,
so a Worker restart never drops a retry.

In task_plan.md, write 4-6 phases. Every phase must end with an exit check that is a
command I can run (a test file, a typecheck, a SQL query against local D1), not a
description. Record constraints in findings.md: no schema change without a numbered
migration, no Date objects bound to D1, existing webhook tests must keep passing.
Stop after the plan is written and show me the phases.
```

**Prompt do skopiowania: wznowienie po /clear**

```text
Resume the active plan. Before you touch any code:
1. Tell me the current phase and the Next Step from task_plan.md, word for word.
2. Summarise the last three entries in progress.md, including which checks passed.
3. Run the exit check of the last completed phase and show me the result.
If the check fails or the files disagree with the code, stop and tell me what differs.
```

## Prowadź wielodniową funkcję na plikach planu, ustaleń i postępu

Przykład powyżej obejmuje jeden reset. Funkcja rozciągnięta na tydzień wymaga, żeby pliki niosły całą pętlę, od planu do scalenia, i żeby niosły dowody, a nie tylko intencje.

1. **Plan (dzień 1).** Uzgodnij podejście w trybie planowania, a potem każ agentowi zapisać je w `task_plan.md` jako fazy, każdą z wykonywalnym warunkiem wyjścia. Przy większych funkcjach najpierw napisz specyfikację; zobacz [rozwój sterowany specyfikacją](/pl/workflows/plan/spec-driven-development/). Zatwierdzony plan zablokuj przez `/planning-with-files:plan-attest`: hooki przestają wtedy wstrzykiwać plan (i zgłaszają `[PLAN TAMPERED]`), jeśli `task_plan.md` nie zgadza się z zatwierdzonym SHA-256, co wyłapuje ciche nadpisania.

2. **Budowa (dni 1–4).** Jedna faza naraz. Agent zapisuje każdą decyzję w `findings.md` razem z uzasadnieniem („odrzucony wykładniczy backoff w pamięci: ginie przy restarcie”), więc późniejsza sesja nie zaproponuje jej ponownie.

3. **Weryfikacja na każdej granicy fazy.** Faza przechodzi w stan `complete` dopiero wtedy, gdy jej warunek wyjścia przechodzi, a wynik trafia do `progress.md`. Na dłuższe odcinki bez nadzoru tryb bramkowany (uruchom `/planning-with-files:pwf` i poproś o tryb bramkowany w treści zadania albo zainicjuj sesję skryptem `init-session.sh --gated` ze skilla) wstrzymuje zakończenie pracy agenta, dopóki któraś faza jest `in_progress`, z limitem kolejnych blokad (`PWF_GATE_CAP`, domyślnie 20), żeby niedokończony plan nie uwięził sesji.

4. **Punkt kontrolny na koniec każdego dnia.** Wklej prompt punktu kontrolnego podany niżej i zamknij sesję. Jutro zaczniesz od promptu wznowienia.

5. **Przegląd.** Daj recenzentowi, człowiekowi albo agentowi, diff razem z `task_plan.md` i `progress.md`. Pytanie nie brzmi już „czy każda linia jest dobra?”, tylko „czy każda faza ma dowód przejścia i czy diff mieści się w planie?”.

6. **Wydanie i przeniesienie wiedzy.** Pliki planu to pamięć robocza: według README są domyślnie w `.gitignore`, a następne zadanie nadpisuje plan w katalogu głównym. Przed scaleniem wynieś z nich trwałą wiedzę: decyzje architektoniczne do ADR, konwencje do `CLAUDE.md` albo `AGENTS.md`. Potem usuń pliki.

**Prompt do skopiowania: punkt kontrolny na koniec dnia**

```text
We stop for today. Update the planning files so a fresh session can continue without me:
- task_plan.md: set Current Phase and Next Step to the exact next action, mark finished items.
- findings.md: add every decision made today with its reason, and every approach we rejected.
- progress.md: log the commands you ran today and paste the result of the last test run.
Then list anything that exists only in this conversation and is not yet in the files.
```

Dwa lub więcej zadań w jednym repozytorium potrzebuje osobnych planów. `init-session.sh "<nazwa>"` tworzy `.planning/YYYY-MM-DD-<slug>/` z tymi samymi trzema plikami, a `PLAN_ID` przypina terminal do jednego z nich. W ścieżce Codeksa i samodzielnych hooków kilka nazwanych planów bez `PLAN_ID` oznacza, że hooki odmawiają wstrzyknięcia kontekstu, zamiast zgadywać. W Cursorze hooki bashowe czytają tylko główny `task_plan.md`, więc tam używaj jednego głównego planu na worktree. Prostszą alternatywą są osobne worktree gita, po jednym na zadanie; zobacz [równoległą pracę agentów](/pl/ecosystem/agent-tools/parallel-agents/).

## Dodaj pamięć między sesjami z claude-mem

claude-mem przez hooki zapisuje, co dzieje się w każdej sesji, kompresuje to modelem i pozwala późniejszej sesji przeszukiwać te zapisy skillem `mem-search` i serwerem MCP z narzędziami `search`, `timeline` i `get_observations`. Odpowiada na pytania, na które nie odpowie żaden plan zadania, i to w skali tygodni i wielu zadań.

Domyślny instalator kończy konfigurację, a potem prosi o zalogowanie do hostowanego „claude-mem observer” (według README z 30-dniowym bezpłatnym okresem próbnym, po którym wraca do twojego planu Anthropic, chyba że wykupisz subskrypcję). Przy kodzie firmy wybierz dostawcę sam. Uruchom w terminalu:

```bash
npx claude-mem install --provider claude     # compress with your own Anthropic plan; no sign-in
npx claude-mem telemetry disable             # anonymous telemetry is on by default
npx claude-mem doctor                        # checks Bun, uv and the worker
```

`--provider` przyjmuje `claude`, `gemini`, `openrouter` albo `host` (`npx claude-mem --help`, 13.28.0, wersja `latest` w npm 2026-09-26). Ta sama pomoc wymienia `--ide codex-cli` i `--ide cursor` dla Codeksa i Cursora; tych ścieżek nie uruchamialiśmy. Flaga instalatora `--disable-auto-memory` wyłącza wbudowaną auto memory Claude Code; zdecyduj świadomie, czy chcesz, żeby notatki zapisywały oba magazyny. Wszystko, czego nie wolno zapisać, otocz tagami `<private>`.

**Prompt do skopiowania: przypomnienie decyzji z dowodem**

```text
Search claude-mem for what we decided about webhook retry backoff in the last two weeks.
Use search first, then get_observations only for the relevant IDs.
Quote each decision with its observation ID and date, then check it against the current
code and git log. Tell me which decisions still hold and which the code has since changed.
```

## Użyj serwera MCP pamięci: referencyjnego Memory albo basic-memory

Serwer MCP pamięci udostępnia pamięć jako narzędzia, które agent wywołuje celowo, a konfiguracja we wszystkich trzech narzędziach opiera się na tym samym pomyśle. Referencyjny serwer Memory trzyma graf wiedzy w jednym pliku JSONL; ustaw `MEMORY_FILE_PATH`, bo inaczej plik trafi do pamięci podręcznej pakietów `npx`. basic-memory zapisuje zwykłe notatki Markdown w `~/basic-memory`, czytelne w każdym edytorze i w Obsidianie; ma licencję AGPL-3.0, a synchronizacja z chmurą jest opcjonalna.

**Claude Code**

```bash
claude mcp add memory -e MEMORY_FILE_PATH=$HOME/.agent-memory/memory.jsonl -- npx -y @modelcontextprotocol/server-memory
claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp
```

**Codex**

```bash
codex mcp add memory --env MEMORY_FILE_PATH=$HOME/.agent-memory/memory.jsonl -- npx -y @modelcontextprotocol/server-memory
codex mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp
```

**Cursor**

Dodaj do `.cursor/mcp.json` (projekt) albo `~/.cursor/mcp.json` (globalnie), z własną ścieżką bezwzględną:

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"],
      "env": { "MEMORY_FILE_PATH": "/Users/me/.agent-memory/memory.jsonl" }
    },
    "basic-memory": {
      "command": "uvx",
      "args": ["--prerelease=allow", "basic-memory", "mcp"]
    }
  }
}
```

Wersje z 2026-09-26: npm `@modelcontextprotocol/server-memory` 2026.8.31, PyPI `basic-memory` 0.23.2. W zespole programistów fakt, który musi znać cały zespół, należy do `CLAUDE.md` albo `AGENTS.md`, gdzie zmienia się przez review; strona o [referencyjnych serwerach MCP](/pl/ecosystem/mcp/reference-servers/) wyjaśnia, kiedy serwer Memory w ogóle warto uruchamiać.

**Pułapki pamięci sprawdzone 2026-09-26**

- `npm install -g claude-mem` instaluje tylko SDK. Nie rejestruje hooków i nie uruchamia workera. Użyj `npx claude-mem install` albo ścieżki `/plugin`.
- Interaktywne `npx claude-mem install` bez `--provider` proponuje logowanie do hostowanego observera. Pomoc wersji 13.28.0 mówi, że nieinteraktywna świeża instalacja domyślnie używa `claude`; zachowanie zmieniało się między wydaniami, więc w obu przypadkach podawaj `--provider` jawnie.
- planning-with-files zainstalowany przez `npx skills add` nie ma komend z ukośnikiem ani odzyskiwania w `SessionStart`. Jeśli odzyskiwanie ma znaczenie, użyj pluginu albo instalacji hooków dla danego narzędzia i uruchom `/planning-with-files:plan-doctor`.
- Codex nie uruchamia nowego hooka, dopóki nie zaufasz mu w `/hooks`, i uruchamia obie kopie, jeśli włączysz jednocześnie pakiet pluginu i samodzielne hooki.
- `PLANNING_DISABLED=1` chroni jednorazową sesję w tym samym katalogu przed wciągnięciem w niedokończony plan.
- Serwer Memory bez `MEMORY_FILE_PATH` zapisuje do pamięci podręcznej `npx`, a jej wyczyszczenie kasuje graf.

## Jak udowodnić, że pamięć agenta pomaga?

Pamięć to kontekst, a nie dowód. Każdy przypomniany fakt może być nieaktualny, dlatego tam, gdzie pamięć wraca do pracy, stawiaj tanią kontrolę:

- **Test wznowienia.** Po `/clear` pierwsza odpowiedź musi powtórzyć bieżącą fazę i następny krok z `task_plan.md` oraz ponownie uruchomić ostatni warunek wyjścia. Odpowiedź, która tego nie robi, oznacza nieudaną instalację, a nie zły prompt.
- **Dowód na każdą fazę.** Faza jest ukończona dopiero wtedy, gdy `progress.md` zawiera przechodzący wynik jej warunku wyjścia. Recenzent albo [agent przeglądający kod](/pl/ecosystem/observability/ai-code-review-bots/) porównuje diff z planem i tym dowodem, zamiast czytać każdą linię.
- **Cytowania przy przypominaniu.** Odpowiedź z claude-mem zawiera identyfikatory i daty obserwacji, a odpowiedź z basic-memory ścieżki notatek; prompt każe potem sprawdzić twierdzenie z kodem i `git log`.
- **Koszt kontekstu.** Uruchom `/context` w Claude Code przed instalacją narzędzia pamięci i po niej. Jeśli magazyn wspomnień wstrzykuje więcej, niż oszczędza, usuń go.
- **Kto zatwierdza.** Programista odpowiada za plan i jego warunki wyjścia. Lider techniczny decyduje, które magazyny mogą przechowywać kod firmy, zwłaszcza gdy dostawca narzędzia wysyła treść sesji do strony trzeciej.

## Co psuje się w trwałej pamięci agenta?

- **Agent ignoruje plan po `/clear`.** Hooki się nie uruchamiają: ścieżka samego skilla, niezaufany hook Codeksa albo Cursor Cloud Agent. W Claude Code uruchom `/planning-with-files:plan-doctor` i napraw linię z błędem; w Codeksie otwórz `/hooks` i zaufaj każdemu hookowi planning-with-files; w Cursorze zacznij nowy czat, żeby uruchomił się `sessionStart`. Potem wklej ponownie prompt wznowienia. W przebiegu Cursor Cloud Agent nie uruchamia się żaden hook: zacznij przebieg od instrukcji "Read task_plan.md, findings.md and progress.md first".
- **Wstrzykiwany jest zły plan.** Istnieją dwa nazwane plany, a wskaźnik się przesunął. Uruchom `set-active-plan.sh --list` z pluginu, a potem zacznij sesję z `PLAN_ID` ustawionym na właściwy plan.
- **Agent ponownie proponuje odrzucony projekt.** Odrzucenie istniało tylko w rozmowie. Dopisz je do `findings.md` z uzasadnieniem, a punkt kontrolny na koniec dnia zrób stałym nawykiem.
- **Wspomnienie przeczy kodowi.** claude-mem albo graf Memory przechowuje decyzję, którą późniejszy commit odwrócił. Ufaj kodowi i `git log`, usuń albo popraw nieaktualną obserwację i zostaw „sprawdź z kodem” w każdym prompcie przypominającym.
- **Sesje zrobiły się drogie.** Dwa narzędzia pamięci plus auto memory wstrzykują nakładający się kontekst. Zostaw jeden magazyn wspomnień, zmierz go przez `/context` i odinstaluj resztę (dla claude-mem: `npx claude-mem uninstall`).
- **Kod firmy trafił do usługi hostowanej.** Ktoś zaakceptował logowanie w claude-mem. Uruchom instalator ponownie z jawnym `--provider`, a lider techniczny niech dopisze zatwierdzone polecenie instalacji do zespołowych notatek konfiguracyjnych.

## Dokąd dalej z pamięcią agenta

- [System pamięci Claude Code](/pl/claude-code/build/memory-system/) — CLAUDE.md, reguły, importy i auto memory: wbudowana warstwa, którą konfigurujesz najpierw.
- [Skille do dyscypliny kontekstu i tokenów](/pl/ecosystem/skills/context-and-token-skills/) — handoff, caveman i karpathy-guidelines do długich zadań w jednym oknie kontekstu.
- [Wzorce długoterminowego zachowania kontekstu](/pl/workflows/context/memory-patterns/) — Co utrwalać, gdzie i co zostawić ulotne we wszystkich trzech narzędziach.
- [Pluginy warte instalacji](/pl/ecosystem/plugins/top-plugins/) — Zmierzony koszt kontekstu i jeden przykład dla każdego popularnego pluginu.
