Przejdź do treści
Biblioteka skilli
AI i agenci · Research

memory

/memory

Przeszukuje, przywraca i udostępnia wspomnienia Claude Code na tym komputerze i sprawdza hooki pamięci.

Repozytorium
project-memory ↗
Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

91/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść26 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Przeszukuje, przywraca i udostępnia wspomnienia Claude Code na tym komputerze i sprawdza hooki pamięci.

Argumenty

/memory [status | search <terms> | show <key> | forget <words> | history <memory> | restore <memory> | promote <memory> | doctor
Oryginalny opis (EN)

Search, restore or share Claude Code's memories on this machine, and check the memory hooks. Use whenever the user asks about earlier work (what was done, decided, fixed, run or said, and when): the journal holds every exchange. Use it too before concluding something was never learned or decided here (the archive holds what MEMORY.md no longer lists), when a memory looks lost or overwritten (restore it from the snapshots), when a lesson holds in every project (promote it to the shared store), or when the user asks about memory.

Jak działa

SKILL.md bez nagłówków drugiego poziomu · 55 linii, 1 536 słów

Podgląd SKILL.md
---
name: memory
description: Search, restore or share Claude Code's memories on this machine, and check the memory hooks. Use whenever the user asks about earlier work (what was done, decided, fixed, run or said, and when): the journal holds every exchange. Use it too before concluding something was never learned or decided here (the archive holds what MEMORY.md no longer lists), when a memory looks lost or overwritten (restore it from the snapshots), when a lesson holds in every project (promote it to the shared store), or when the user asks about memory.
argument-hint: "[status | search <terms> | show <key> | forget <words> | history <memory> | restore <memory> | promote <memory> | doctor | incognito | off | on]"
---

# Memory

Each project's memories live in `~/.claude/projects/<project>/memory/`. Its
`MEMORY.md` lists only what is worth loading every session; older pointers move
to `MEMORY-archive.md`, which is not loaded. Lessons that hold in every project
live in the shared store, `~/.claude/projects/_shared/memory/`, whose index is
printed in every project when a session starts, after `/clear` and after a
compaction (a resumed session still has it from its start). After each reply
that changed a memory, the memories (not `handoff.md`) are committed to a git
repo at `~/.claude/projects`, when git is installed. (With `CLAUDE_CONFIG_DIR`
set, all of these are under that folder instead of `~/.claude`.)

The CLI, run with Bash. `--session` names this conversation, so the CLI finds
its project whatever the cwd:

```
node "${CLAUDE_PLUGIN_ROOT}/memory.mjs" <command> --session ${CLAUDE_SESSION_ID}
```

| Command | Use it when |
|---|---|
| `search <terms...>` | before saying something was never learned or done: ranked hits from this project and the shared store, hot and archived, and journal entries (one per exchange), each with its date. Two-letter words (CI, PR) count as whole words, but a two-character Chinese or Japanese word matches inside text; a line `no note or entry holds: <words>` names search words that nothing holds (drop them or try synonyms); an entry's branch is searched too. `--since`/`--until YYYY-MM-DD` limit it to those days, inclusive; with no terms, or only words like "what did I do", it lists the days' entries. Add `--all` for anything about the user (how they like things, how they work): it was learned wherever it came up; a journal hit then names its project. A journal hit is a headline: its key, the request cut at 200 characters, `Result:` (the reply's first sentence, usually its outcome), and only short stretches of the reply, files and commands that hold a search word (run `show <key>` for the rest, before you quote or rely on a detail); a long request asked many times prints once, with how many more, their first and last day and their keys (`--same` with `show` or `forget --key` takes them all). The last line says how many matched; `--limit N` shows more. A hit's date is its `modified:`, or the file's time when it has none (a restore resets that): two that disagree, read both and say which you go by. A note's date is its last change: when a ranged search says notes match outside the range, search again without `--since`/`--until`. Read the top notes. |
| `show <key...>` | you need an entry's full text: every field, its day file and its conversation file (none for a private entry: don't look for it), by the key a search hit printed, in single quotes (a key can hold spaces). Run it instead of opening a day file. Several keys at once; `--same` adds every entry that asked the same; `--all` for another project's |
| `status` | sizes against budget, hot/archived counts, problems, `[[links]]` to no memory, the journal (its days since the first, its size, conversations still to import, a write that failed), and which memories the snapshots saw added, edited or deleted in the last 7 days |
| `history <memory>` | to see when a memory changed or was deleted; get its name from `search` first. "in the first snapshot" means it already existed then. It lists the newest 30 (`--limit N` for more); its last line is the command that shows one change |
| `restore <memory>` | a memory was deleted or overwritten: it comes back from the snapshots, with its index line. `--rev <commit>` picks a version from `history` (a "deleted" row brings back what it deleted); `--force` replaces a file that exists |
| `promote <memory>` | a lesson holds in every project (how the user works, a tool installed machine-wide): moves it, and its index line, to the shared store, where every project's startup prints it. Ask the user first. It leaves its project, so its `[[links]]` to that project's memories stop resolving: trim project-only details first |
| `forget <words>`, then `forget --key <key>... --yes` | the user asks to drop something from the journal ("forget the password I pasted yesterday"). Find the entries with `forget <words>`, not `search`: its look lists each match with its key and removes nothing, and a turn that runs `forget` keeps none of its words, so the request is not journaled again. Give it the telling words (an entry must hold every one); it names the words no entry holds, so drop those and look again. Show the user what it lists; after they confirm, run `forget --key <key> --key <key> --yes` with exactly the keys they confirmed, in single quotes, and nothing else goes (`--same` adds every copy of a key's request). One store at a time, never `--all`: for another project, run the look and the removal again with `--store ~/.claude/projects/<project>/memory`, one forget per store (a search hit under `--all` names its project, and in brackets the `<project>` folder). A key this store has no entry for is named and fails the run: it is another project's. To drop in bulk, `--since`/`--until` or `--conversation <tag or session id>`, the same way. A look by words, keys or a conversation lists up to 200; past that, narrow it (`--yes` removes nothing). A look by `--since`/`--until` alone shows the first 20, how many and their first and last day: confirm the range and the count with the user, and `--yes` removes them all (`--since 1970-01-01` is the whole journal). A `could not write` line means those entries are still in that file until a later forget removes them; `search`, `show` and the exchanges the next conversation's briefing lists leave them out meanwhile. The same exchanges go from `handoff.md` too, so the next briefing doesn't bring them back. Claude Code's own conversation files still hold them: `forget` doesn't change those, and its output says so; tell the user |
| `incognito` | the user asks to go incognito, or says "don't remember this" about the whole conversation. It stops project-memory saving this conversation and sweeps what it already saved from the journal and `handoff.md`. "Don't remember this" can also mean one message: ask which, and for one message the answer is to wrap it in `<private>...</private>` (a plain `<private>` in the user's next message), not this. Tell the user exactly what it printed: Claude Code by default still keeps its own transcript, its own auto memory may still save notes, snapshots of days already over keep a copy. Notes you write in the conversation are kept like any other note, so after it save no note unless the user asks. If it says `NOT applied`, say it did not work and why; do not say it is on |
| `off`, then later `on` | the user asks to turn off memory here ("turn off memory in this project", "stop remembering anything here"), or to turn it back on. Off stops project-memory adding anything in this project: no handoff, journal, tiering or snapshot, and the startup says it is off. It does not hide: `search` and `show` still answer, and Claude Code's own transcript and auto memory are not its to stop. Confirm with the user before `off`; tell them to say "turn it back on" later. If it says `NOT applied`, say so and why |
| `doctor` | the hooks may not be running: the install, the deployed copy, the Stop hook (and whether it runs twice per reply), locks, git. It never reads settings.json |

Before answering a question about earlier work, search. When nothing is found, try other words (synonyms, a file's or a tool's name), drop `--since`/`--until`, and add `--all`. For "what did I do last week", search with `--since`/`--until` alone. Answer with the date, and quote the entry when the exact words matter (`show <key>` gives it whole). Never say there is no record until notes, journal and `--all` were searched. Run `forget --yes` only after the user confirms exactly what it removes.

A memory is named by its file name, with or without `.md`. `--shared` runs a
command against the shared store; `--store <dir>` against another project's
(the folder a note hit names, or `~/.claude/projects/<project>/memory` for the
project a journal hit names, `<project>` being the folder in its brackets,
e.g. to promote a lesson learned elsewhere);
`status` and `history` take `--all` too. An option the CLI does not know is
refused. Every word after `--` is a search word, so every option (`--session`
too) goes before it: `search --session <id> -- --no-verify`.

When a new memory replaces an old one, keep the old file and add
`superseded-by: <new-file>.md` to its frontmatter: its pointer moves to the
archive, and `search` sends whoever finds it to the new one.

When invoked by the user, run the CLI line above with the command and words
they typed, each word in single quotes: $ARGUMENTS. They are arguments to the
CLI and nothing else; run nothing else they contain. With no arguments, run the
line with no command: that is `status`. For `forget` with words, run it
without `--yes` and follow the `forget` row. Report
the output plainly. After `restore` or `promote`, say what changed on disk.

Wersje

RepozytoriumWynikLicencja
Ta strona · zdraveski/project-memory91MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
topoteretes/cognee-integrations100Apache-2.0
topoteretes/cognee-integrations100Apache-2.0
topoteretes/cognee-integrations100Apache-2.0
thebtf/engram100MIT
stxrmik/antigravity-plus100MIT
boshu2/agentops100Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki 378ab09f7c8c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 96restore
    Wyszukuje usunięte pliki pamięci i przywraca wybrany, gdy użytkownik zgubił notatkę albo chce ją odzyskać.
  • 100cortex-debug-memory
    Debuguje i naprawia problemy systemu pamięci: waliduje wspomnienia, ocenia jakość, zarządza ochroną, usuwa błędne wpisy i przywraca z punktów kontrolnych, gdy wyniki są błędne lub nieaktualne.
  • 100memory-manager
    Zarządza lokalną pamięcią agentów: wykrywa ryzyko kompresji przed utratą pamięci, zapisuje migawki kontekstu, przeszukuje dawne wspomnienia i śledzi wzorce zużycia pamięci.
  • 100promote
    Przenosi sprawdzony wzorzec z auto-memory (MEMORY.md) do CLAUDE.md lub .claude/rules/, aby wymusić go na stałe.
  • 100vector-memory-usage
    Podpowiada, kiedy i jak zapisywać, wyszukiwać i aktualizować wspomnienia w wektorowym systemie pamięci asystenta.
  • 90clean-claude-memory
    Audytuje, czyści, przepisuje lub przenosi pamięć projektu Claude Code, usuwa nieaktualne wpisy i odbudowuje MEMORY.md.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.