Project memory lives in one folder per project, shared by every agent CLI. Resolve that folder in this order:
$LPM_MEMORY_DIR, which lpm sets for every terminal it opens — always use it when set.~/.lpm/memory/<project> where <project> comes from lpm project --json: its parentName, or its name when parentName is empty.- Without the
lpm CLI, ~/.lpm/memory/<project> where <project> is $LPM_PROJECT_NAME, else the main checkout's folder name (basename "$(dirname "$(cd "$(git rev-parse --git-common-dir)" && pwd)")", so a Git worktree resolves to the repository it belongs to), else the working directory's folder name.
A duplicate of a project shares the original's memory — same codebase, and the copy is disposable — so never derive a folder of its own from a copy's name or path. <session> is a kebab-case slug for one workstream (e.g. auth-refactor); each file is both the current handoff state and the work history.
Invocation:
/lpm-memory <session-id> — Recall that session and continue it. Unknown id: offer close matches, or create it.- No argument — Remember work already done in this conversation; at the very start of one, pick or create the session instead.
- Either way, keep the memory current from then on without being asked: append a timeline entry and refresh
## Current state after each milestone and when the user wraps up.
Remember (save / hand off)
Session slug: the user's name for it, else the one existing file that matches the work, else derive one and confirm it before writing.
Create the folder if missing. Seed a new file with:
# <Work title>
## Goal
<one or two lines>
## Current state
<where things stand, next steps, blockers>
## Timeline
Re-read the file right before writing — another agent may have saved meanwhile. If it changed since you last read it, keep their changes: append your timeline entry after theirs and fold both realities into ## Current state.
Rewrite ## Current state to match reality now.
Append a new entry at the end of ## Timeline. The timeline is strictly append-only: never edit or delete an existing entry — not even your own from earlier in the same conversation. Each entry covers only what happened since the previous save:
### <YYYY-MM-DD HH:MM> — <agent>
- Done: what shipped or changed, in outcome terms
- Decided: choices made and why, including approaches tried and dropped
- Learned: surprises and gotchas the next agent must know
- Open: unresolved questions / blockers
- Next: unfinished work / immediate next step
<agent> = your CLI name (claude, codex, ...), local time. Drop empty lines; keep it brief.
Compaction — the one exception to append-only: when the timeline exceeds ten entries, condense the oldest into a single digest entry ### Archived through <YYYY-MM-DD> kept first in ## Timeline; keep the newest five entries verbatim. Condense only — preserve every decision and gotcha that still matters, never reinterpret, and fold into the existing digest on later compactions.
Recall (continue / join)
- List the project memory folder's
*.md; read the named session, or show the list (name, last modified, goal line) and ask which one.
## Current state is the source of truth; the newest timeline entries carry the freshest detail. Read those first — reach for older entries and the archive digest only when the work needs that history.- State the next step you inferred, confirm direction, then continue — and Remember at the next stopping point.
1---2name: lpm-memory3description: Shared project memory for AI coding agents: save or recall work-session logs in `~/.lpm/memory/<project>/<session>.md` so another agent CLI (Claude Code, Codex, Gemini) or a future session can continue the work by session name. Invoke with a session id (e.g. `/lpm-memory auth-refactor`) to continue that session. Use when the user asks to remember or save the session or progress, hand off work, record what was done, or recall/continue/resume/join a named work session. This is per-project memory shared between agent CLIs — distinct from any CLI's own built-in memory.4---56Project memory lives in one folder per project, shared by every agent CLI. Resolve that folder in this order:781. `$LPM_MEMORY_DIR`, which lpm sets for every terminal it opens — always use it when set.92. `~/.lpm/memory/<project>` where `<project>` comes from `lpm project --json`: its `parentName`, or its `name` when `parentName` is empty.103. Without the `lpm` CLI, `~/.lpm/memory/<project>` where `<project>` is `$LPM_PROJECT_NAME`, else the main checkout's folder name (`basename "$(dirname "$(cd "$(git rev-parse --git-common-dir)" && pwd)")"`, so a Git worktree resolves to the repository it belongs to), else the working directory's folder name.1112A duplicate of a project shares the original's memory — same codebase, and the copy is disposable — so never derive a folder of its own from a copy's name or path. `<session>` is a kebab-case slug for one workstream (e.g. `auth-refactor`); each file is both the current handoff state and the work history.1314Invocation:1516- `/lpm-memory <session-id>` — Recall that session and continue it. Unknown id: offer close matches, or create it.17- No argument — Remember work already done in this conversation; at the very start of one, pick or create the session instead.18- Either way, keep the memory current from then on without being asked: append a timeline entry and refresh `## Current state` after each milestone and when the user wraps up.1920## Remember (save / hand off)21221. Session slug: the user's name for it, else the one existing file that matches the work, else derive one and confirm it before writing.232. Create the folder if missing. Seed a new file with:2425 ```markdown26 # <Work title>2728 ## Goal29 <one or two lines>3031 ## Current state32 <where things stand, next steps, blockers>3334 ## Timeline35 ```36373. Re-read the file right before writing — another agent may have saved meanwhile. If it changed since you last read it, keep their changes: append your timeline entry after theirs and fold both realities into `## Current state`.384. Rewrite `## Current state` to match reality now.395. Append a new entry at the end of `## Timeline`. The timeline is strictly append-only: never edit or delete an existing entry — not even your own from earlier in the same conversation. Each entry covers only what happened since the previous save:4041 ```markdown42 ### <YYYY-MM-DD HH:MM> — <agent>43 - Done: what shipped or changed, in outcome terms44 - Decided: choices made and why, including approaches tried and dropped45 - Learned: surprises and gotchas the next agent must know46 - Open: unresolved questions / blockers47 - Next: unfinished work / immediate next step48 ```4950 `<agent>` = your CLI name (claude, codex, ...), local time. Drop empty lines; keep it brief.51526. Compaction — the one exception to append-only: when the timeline exceeds ten entries, condense the oldest into a single digest entry `### Archived through <YYYY-MM-DD>` kept first in `## Timeline`; keep the newest five entries verbatim. Condense only — preserve every decision and gotcha that still matters, never reinterpret, and fold into the existing digest on later compactions.5354## Recall (continue / join)55561. List the project memory folder's `*.md`; read the named session, or show the list (name, last modified, goal line) and ask which one.572. `## Current state` is the source of truth; the newest timeline entries carry the freshest detail. Read those first — reach for older entries and the archive digest only when the work needs that history.583. State the next step you inferred, confirm direction, then continue — and Remember at the next stopping point.
gug007