Why does Claude Code forget my command history?

Claude Code forgets your command history because each invocation is an ephemeral session bound to one shell process, with no built-in store for prior commands, outputs, or the reasoning behind them. /resume and CLAUDE.md help inside a single repo, but neither persists structured command history across machines, teams, or projects. The fix is to give Claude Code an external memory layer it can read on every launch.

Claude Code is a CLI agent that runs inside your terminal. Three design choices in that model produce the forgetting you experience:

1. Sessions are tied to a shell process. When you start claude in a directory, the conversation lives in memory for that process. Close the terminal, lose power, or open a new tab and the working context is gone. Anthropic documents /resume and --continue for picking up the most recent session, but those rely on local transcripts that do not travel with you.

2. There is no first-class "command history" object. Claude Code stores raw transcripts of your messages and its responses, not a structured log of "command issued, output observed, decision made". Even with /resume, you get the chat text back, not a queryable record of which bash commands ran, which tests passed, and which approach you rejected.

3. `CLAUDE.md` is per-repo guidance, not memory. The CLAUDE.md file at the root of a repo is a static instruction sheet Claude Code reads on every launch. It is excellent for "use pnpm, not npm", and useless for "remember that yesterday we tried migrate:up and it failed on the postgres extension".

The result: the model that was your pair programmer at 6 pm becomes a polite stranger at 9 am.

Every fresh session burns 10–20 minutes on rediscovery, and the cost compounds across a real project:

• Repeated dead ends. You already proved pnpm build --filter web is the right invocation. The new session suggests npm run build from the root and fails the same way you failed at 2 am.
• Lost rationale. "We chose the env-var path over the config-file path because Vercel build cache" is reasoning you cannot reconstruct from your shell history alone. Without it, the agent re-litigates settled decisions.
• Team handoff breaks. A teammate cloning the same repo gets the CLAUDE.md but none of the command history that explains why three migrations are commented out.

The fix is not "remember to run /resume" — it is to detach project memory from any single shell session.

Anthropic has shipped three things that partly address persistence. None of them is project memory.

`/resume` and `--continue` let you reopen the last session's transcript. Useful for picking up an interrupted refactor in the same machine and the same shell, in the same hour. Useless when you switch laptops, hand off to a teammate, or want to recall what happened three weeks ago. Transcripts also accumulate quickly, so finding "the session where we fixed auth" is a manual scroll.

`CLAUDE.md` loads project conventions into every session — coding style, build commands, gotchas. It is the right tool for "always run typecheck before commit" and the wrong tool for command history, because it is hand-curated and static. If you want yesterday's bash history in there, you have to write it in yourself.

Native MCP support lets Claude Code attach to Model Context Protocol servers. This is the door you can actually walk through. The Claude Code docs cover MCP setup in the official guide at docs.anthropic.com/en/docs/claude-code. MCP is the integration point a memory layer plugs into.

The deeper issue is that command history is a project asset, not a session asset. You run Claude Code on a laptop, then on a desktop, then on a CI box. Your teammate runs it from a fresh clone. None of these shells share state, and CLAUDE.md cannot grow itself.

Claude Code also does not span tools. You may switch to Cursor, Cline, or a plain bash shell mid-project, and any context you wanted to carry over evaporates. Project memory needs to live outside the editor.

MemoryLake is a cross-model memory layer Claude Code reads from at launch. Instead of relying on /resume and a hand-written CLAUDE.md, you give the project its own memory and let every session — yours or your teammate's — open with the full command history loaded.

• Structured command and decision log. Every command run, every test result, and every "why we did it this way" note is stored as a Memory inside the project. Retrieval surfaces only the relevant slice per turn, so the agent stops re-suggesting things you already ruled out.
• Same memory across machines and teammates. Sign in on a new laptop and the project state is already there. A teammate running claude against the same repo gets the same history, no manual CLAUDE.md updates required.
• 10,000× the retrieval reach of raw prompting. MemoryLake reads from billions of tokens of project memory and feeds Claude Code only what matters this turn. You stop paying for re-pasted transcripts and stop hitting the context window.

MemoryLake scored 94.03% on the LoCoMo long-context benchmark, the top result published as of 2026, with millisecond retrieval and AES-256 end-to-end encryption.

1. Create a project and load your context. Sign in to MemoryLake, open Project Management, click Create Project, and name it something like "Claude Code — monorepo refactor". Drop your existing CLAUDE.md, ADRs, runbooks, and prior session transcripts into the Document Drive. Add standing rules and recent command outcomes through the Memories tab so they travel with the project.
2. Generate an MCP Server endpoint. Open the MCP Servers tab inside your project, click Add MCP Server, give it a name like "Claude Code integration", and click Generate. MemoryLake returns an API key ID, secret, and endpoint URL. Copy the Bearer token immediately — it is shown only once.
3. Connect Claude Code via native MCP. In your terminal run claude mcp add memorylake <endpoint> with the endpoint URL, or edit ~/.claude.json to add the MemoryLake server with your Bearer token. Restart Claude Code. Every new session now loads command history, decisions, and conventions from the project before the first prompt.