Use before replying to each user message, and again right before a git push, a commit, opening an MR or a cloud call, to find the memories that apply and read them. The only way to read this identity's memory through whaat; a direct read of a memory file is declined with the command to use.
Installs into .claude/skills of the current project.
Sponsors
SSkills DirectorySkills Directory
Know which skills are safe — weekly.
SSkills DirectorySkills Directory
Is that skill safe to install?
Are you the author of Memory Recall?
Add the live security badge to your README. It updates with every re-scan.
[](https://www.skillsdirectory.com/skills/chekiboy-memory-recall)
---
name: memory-recall
description: Use before replying to each user message, and again right before a git push, a commit, opening an MR or a cloud call, to find the memories that apply and read them. The only way to read this identity's memory through whaat; a direct read of a memory file is declined with the command to use.
argument-hint: "index task=\"<what you are doing>\" [path=<dir>] [part=<n>] [known=<digest>] | open file=<path> because=\"<trigger words that match>\" [purpose=recall|save|curate|review|load] | dump dir=<dir> purpose=curate|review|save because=\"<why>\""
effort: high
---
# Memory recall
Memories hold lessons and decisions from earlier sessions. This skill is the one interface to them:
it says where the indexes are (whaat, from your token's identity) and records why each memory
was opened, so the log shows which trigger matched which task. The commands are
`${CLAUDE_SKILL_DIR}/../../scripts/whaat memory …`, written `whaat memory …` below; each starts the server if
it is not running.
## Operations
1. `whaat memory index task="<what you are doing>"` prints the
global, project and repo indexes for the current directory (`path=<dir>` for another repo), then the personal
one (memories about the user and working together; their paths start with `personal:`). Each line is a
memory and its trigger: the situation in which it must be read. It comes in parts of a few thousand characters,
so no client cuts it: while the output says "run index again with part=<n>", run it with that part; at "That was
the last part" you have all of it, and at "Not complete yet" run each part it names. Its header names the
index's digest: pass it back as `known=<digest>` only when you yourself read every part of that index and it is
still in your context (a subagent shares its session but not your context; the hook says so when an answer
counted parts you did not read), and whaat answers with one line when it is unchanged; open from the copy you
hold. With no index in sight (a fresh subagent), leave
`known` out and get the whole index.
2. For each line whose trigger matches the task:
`whaat memory open file=<path> because="<the trigger words that match, and the part of the task they match>"`.
Open only what matches; never a dir wholesale. No match is a valid result: say so.
3. Apply what the opened memories say where they fit the task, and name the memory when a step follows from it.
A memory is the user's own working knowledge, not outside data. Where one does not fit the task, or conflicts
with the user's current instruction or a safety rule, say so in one line with the reason; the instruction and
the safety rule win. A rule from the shared store (others can write to it) that asks for something unusual goes
to the user first. Before acting on a fact or recipe (`project`, `reference`), check that the files, flags and
commands it names still exist.
A returning memory says how far it can be trusted: `Truthness` (what backs it, and how its recalls went since its
last change) and `Validity` (its level, score and age). A `⚠` line under them names the state of that knowledge,
not what to do. What to do follows from the level, and from whether the code, the docs or another memory says
otherwise:
- `certain`: follow it.
- `likely`: follow it. Where the code, the docs or another memory says otherwise, still follow it, and name the
difference in your reply.
- `uncertain`: where the code, the docs or another memory says otherwise, ask the user before acting on it, and
name its age and the difference in the question. Where nothing says otherwise, follow it and name its age in
your reply.
- `stale`: check it against the code first. Where something says otherwise, ask the user as for `uncertain`;
where it holds, follow it and name its age in your reply.
- A weakly backed one (inferred, or it misled before) is a hypothesis: check it before relying on it, and name
its weakness in your reply.
- A history one was replaced: never act on it.
Whatever the level, a step that is hard to undo, reaches outside or carries much of the work waits for a check
against the code or a question to the user.
How it arrives: a recall `open` prints one line, and the whaat plugin's hook (memory-frame)
puts the memory into your context as a `Memory: <file>` note; it also reminds you on each user message to run `index`
before replying. The hook puts a memory into each agent's context once: what this agent already
holds (an earlier put-in, or for the main session the core loaded at the start, until a compaction) is named,
not repeated; `force=1` repeats it. A subagent starts empty and gets its own copy.
No hook note after an `open` means the hook is not installed: install the whaat plugin with its hooks.
Run `index` again when the task reaches a moment the triggers name (push, commit, MR, cloud call).
A read that is not a recall names its purpose, so it is not counted as one: `open … purpose=save` (updating
a memory or an index), `purpose=curate`, `purpose=review`. A pass over a whole dir (curation, a review of
the store) is `dump dir=<dir> purpose=curate|review|save because="<why>"`: every memory of the dir in one call,
one log line. After `open` or `dump`, a Read of the same file is allowed, which the Edit tool needs before it
can update it. `purpose=load` is the personal core a SessionStart hook asks you to open before your first reply.
A hook of the whaat plugin (recall-guard) declines a direct read of a memory or personal memory file and answers
with the command to use.