Memory

Private notes for you, a shared folder for your team — both file-based, both project-local, both plain git.

Overview

Claudin keeps a persistent, file-based memory alongside your project: a private directory just for you and the current project, and a shared team/ subfolder that any contributor can write to and that reaches everyone else through ordinary git push/pull/clone — no server, no Anthropic account, no special sync step. Both load at the start of every session, so the model shows up already knowing who you are, what the project's conventions are, and what the team has already decided.

On by default for any project inside a git repository.

Where it lives

Memory is project-local: it defaults to <gitRoot>/.claudin/memory/, the same pattern already used for .claudin/plans/. Private memory is one file per fact under that directory; team memory lives in its team/ subfolder. Resolution order, first match wins:

CLAUDE_COWORK_MEMORY_PATH_OVERRIDE environment variable (Cowork only)
autoMemoryDirectory in settings.json (trusted sources only)
<gitRoot>/.claudin/memory/, unless autoMemoryProjectLocal: false is set
<memoryBase>/projects/<sanitized-git-root>/memory/ — the legacy global path, used for non-git projects

If a project already had memory under the legacy global path, the first project-local resolution copies it across automatically — it never deletes or moves the original, so the old directory stays as a backup, and the copy only runs once.

Making `team/` actually git-trackable

Most projects' .gitignore blanket-excludes .claudin/, which would silently swallow .claudin/memory/team/ too. Claudin never edits .gitignore on its own — instead, when it detects this conflict, it shows you the minimal fix and asks before applying it:

/.claudin/*
!/.claudin/memory/
/.claudin/memory/*
!/.claudin/memory/team/

This carves out just memory/team/ as tracked, while your private memory/*.md, plans/, settings.local.json, rules/, skills/, and agents/ stay ignored, exactly as before.

What to write where

Each memory is one file holding one fact, with frontmatter (name, description, type) and an entry in a per-directory MEMORY.md index. The type also carries a recommended scope:

Type	Scope	Holds
`user`	Always private	Who the user is: role, expertise, goals, preferences.
`feedback`	Private by default; team only for a project-wide convention	Corrections and confirmed approaches — a testing policy or build invariant belongs to the team; personal style stays private.
`project`	Bias toward team	Ongoing work, decisions, bugs, or constraints not derivable from the code or git history.
`reference`	Usually team	Pointers to external systems — a tracker project, a chat channel, a dashboard.

Memories link to each other with [[name]], across private and team directories alike. Stale or duplicate memories get updated or deleted rather than piling up — see the tidy command below.

Secrets never reach team memory

This is enforced by code, not just by instruction. Every write or edit to a file under team/ is scanned for secret-shaped content (API keys and similar patterns) before it's allowed to land; a match is rejected with an explanation, because anything in team/ is shared with every collaborator on the repository the moment it's committed.

Keeping memory tidy

Run /memory tidy to merge duplicate memories and prune ones that no longer hold up — it works across both the private directory and the team folder.

Configuration

Setting	Effect
`autoMemoryProjectLocal: false`	Forces the legacy global-only location. Set in user/local/policy settings — never `projectSettings`, for security.
`autoMemoryDirectory`	Overrides the memory directory outright (trusted settings sources only).