mema-kit 1.0.5 → 1.1.0

package/README.md

@@ -1,82 +1,129 @@
 # mema-kit
 
-Memory protocol kit for Claude Code skills. Give any skill persistent, curated memory across sessions.
+Full AI-assisted development lifecycle kit for Claude Code. From vague idea to shipped code — without switching tools.
 
-**What it does:** A `.mema/` directory in your project stores architecture decisions, requirements, lessons learned, and reusable patterns as curated markdown. Skills automatically load relevant context at the start of each session and save curated knowledge when done.
+**What it does:** Twelve built-in skills cover the entire development lifecycle: brainstorm and validate ideas, break them into features, plan and implement each feature, and persist curated knowledge across every session in a `.mema/` memory directory.
 
-**Key differentiator:** The memory protocol (AUTO-LOAD → WORK → AUTO-SAVE & CURATE → AUTO-INDEX) is a reusable pattern. Any skill you build can plug into it — not just the three that ship with mema-kit.
+**Key differentiator:** The memory protocol (AUTO-LOAD → WORK → AUTO-SAVE & CURATE → AUTO-INDEX) connects every phase. Skills read what previous skills wrote — a spec references research findings, a plan references architecture decisions, an implementation references the plan. Context compounds instead of resetting.
 
 ## Quick Start
 
-```bash
-# 1. Install skills into your project
-npx mema-kit
+### New project (starting from an idea)
 
-# 2. Open Claude Code and bootstrap memory
+```bash
+npx mema-kit          # install skills
 claude
-> /onboard
+> /mema.seed          # capture your idea
+> /mema.clarify       # refine with Q&A
+> /mema.research      # find what exists (uses web search)
+> /mema.challenge     # stress-test assumptions
+> /mema.roadmap       # create prioritized feature list
+> /mema.specify 001   # spec the first feature
+> /mema.plan 001      # technical design
+> /mema.tasks 001     # generate task list
+> /mema.implement 001 # build it, one task at a time
+```
 
-# 3. Next session: load memory into context
-> /recall
+### Existing project (starting from code)
+
+```bash
+npx mema-kit          # install skills
+claude
+> /mema.onboard       # scan project, create .mema/, populate memory
+> /mema.specify       # spec a feature
+> /mema.plan          # technical design
+> /mema.tasks         # generate task list
+> /mema.implement     # build it
 ```
 
-`/onboard` scans your project, creates the `.mema/` memory structure, populates initial architecture and requirements docs, and configures CLAUDE.md and `.gitignore`. `/recall` loads that memory into any future session.
+### Every new session
+
+```
+> /mema.recall        # reload context — active features, stack, next action
+```
 
 ## Built-in Skills
 
+### Discovery (new projects)
+
 | Command | Purpose |
 |---------|---------|
-| `/onboard` | Bootstrap memory for a project — scans codebase, creates `.mema/`, populates initial knowledge |
-| `/recall` | Load project memory into the current session — instant context on cold start |
-| `/create-skill` | Generate a new memory-aware skill with the correct lifecycle phases |
+| `/mema.seed` | Capture a raw idea → `product/seed.md` |
+| `/mema.clarify` | Refine with targeted Q&A → `product/clarify.md` |
+| `/mema.research` | Web search: competitors, market, tech options → `product/research.md` |
+| `/mema.challenge` | Stress-test: assumptions, risks, blind spots → `product/challenge.md` |
+| `/mema.roadmap` | Synthesize into prioritized feature list → `product/roadmap.md` |
 
-## How Memory Works
+### Feature Workflow
 
-mema-kit uses a `.mema/` directory in your project to persist knowledge between sessions:
+| Command | Purpose |
+|---------|---------|
+| `/mema.specify` | Feature spec (what + why) → `features/NNN-name/spec.md` |
+| `/mema.plan` | Technical design → `features/NNN-name/plan.md` |
+| `/mema.tasks` | Ordered task list → `features/NNN-name/tasks.md` |
+| `/mema.implement` | Execute one task at a time, track progress |
+
+### Utilities
+
+| Command | Purpose |
+|---------|---------|
+| `/mema.onboard` | Bootstrap memory for an existing project (also migrates old mema-kit structure) |
+| `/mema.recall` | Load memory into current session — shows active features first |
+| `/mema.create-skill` | Generate a new memory-aware skill with the correct lifecycle phases |
+
+## How Memory Works
 
 ```
 .mema/
-├── index.md             # Memory map — agent reads this first
-├── project-memory/      # Architecture, requirements, decisions
-│   └── decisions/       # Individual decision records with reasoning
-├── task-memory/         # Per-task context, plans, active work
-├── agent-memory/        # Lessons learned, reusable patterns
-└── archive/             # Completed task memories
+├── index.md               # Pointer map — read first
+├── product/               # Discovery phase outputs
+│   ├── seed.md
+│   ├── clarify.md
+│   ├── research.md
+│   ├── challenge.md
+│   └── roadmap.md
+├── features/              # One directory per feature
+│   └── 001-feature-name/
+│       ├── spec.md        # What + why
+│       ├── plan.md        # Technical design
+│       ├── tasks.md       # Implementation task list
+│       └── status.md      # Progress tracking
+├── project/               # Stable project knowledge
+│   ├── architecture.md
+│   ├── requirements.md
+│   └── decisions/
+├── agent/                 # Cross-session knowledge
+│   ├── lessons.md
+│   └── patterns.md
+└── archive/               # Completed features
 ```
 
-- **Auto-load**: Skills read `index.md` and load only the files relevant to the current task.
-- **Auto-save**: After work, the agent curates findings into the right memory files.
-- **Auto-prune**: Noise is removed; only actionable knowledge is kept.
-- **Self-healing**: If `index.md` gets out of sync, the next skill rebuilds it from the directory structure.
-
 Memory is just markdown. Open any file to see what the agent knows. Edit directly if something's wrong.
 
 ## The Memory Protocol
 
-Every memory-aware skill follows four phases:
+Every skill follows four phases defined in `_memory-protocol.md`:
 
-1. **AUTO-LOAD** — Read `index.md`, decide what's relevant, load only those files
-2. **WORK** — Execute the skill's core purpose with loaded context
-3. **AUTO-SAVE & CURATE** — For each piece of knowledge, decide: ADD / UPDATE / DELETE / NOOP
-4. **AUTO-INDEX** — Update `index.md` to reflect all changes
+1. **AUTO-LOAD** — Read `index.md`, load only relevant files
+2. **WORK** — Execute with loaded context
+3. **AUTO-SAVE & CURATE** — ADD / UPDATE / DELETE / NOOP for each piece of knowledge
+4. **AUTO-INDEX** — Update `index.md` to reflect changes
 
-The protocol is defined in `_memory-protocol.md` and shared across all skills (never duplicated). See [docs/guide.md](docs/guide.md) for the full protocol reference.
+The protocol is shared across all skills (never duplicated). Any skill you build can plug into it — not just the twelve that ship with mema-kit.
 
 ## Building Your Own Skills
 
-Use `/create-skill` to generate memory-aware skills:
-
 ```
-> /create-skill
+> /mema.create-skill
 
-Skill name: review
+Name: review
 Purpose: Review code changes for quality and consistency
 Complexity: standard
 ```
 
-This creates `.claude/skills/review/SKILL.md` with the full 4-phase memory lifecycle wired in. Three complexity levels are available:
+Creates `.claude/skills/review/SKILL.md` with the full 4-phase memory lifecycle. Three complexity levels:
 
-- **Simple** (3 phases) — Read-only skills like code review, linting
+- **Simple** (3 phases) — Read-only skills: code review, linting, quick lookups
 - **Standard** (4 phases) — Most skills that read and write memory
 - **Advanced** (4 phases + task management) — Multi-step workflows with archiving
 
@@ -88,6 +135,8 @@ npx mema-kit --update
 
 Updates skill files only. Never touches `.mema/`, CLAUDE.md, or `.gitignore`.
 
+If upgrading from an earlier version of mema-kit (with `project-memory/`, `agent-memory/`, `task-memory/` directories), run `/mema.onboard` after updating — it migrates the old structure automatically.
+
 ## Requirements
 
 - Node.js >= 16.7.0
@@ -95,7 +144,7 @@ Updates skill files only. Never touches `.mema/`, CLAUDE.md, or `.gitignore`.
 
 ## Documentation
 
-See [docs/guide.md](docs/guide.md) for the full usage guide with worked examples and protocol reference.
+See [docs/guide.md](docs/guide.md) for the full usage guide with worked examples.
 
 ## Links
 

package/bin/cli.js

@@ -47,10 +47,10 @@ function runInstall() {
 
   console.log('✓ mema-kit skills installed to .claude/skills/');
   console.log('');
-  console.log('Next step: Open your project in Claude Code and run /onboard');
+  console.log('Next step: Open your project in Claude Code and run /mema.onboard');
   console.log('');
   console.log('  claude');
-  console.log('  > /onboard');
+  console.log('  > /mema.onboard');
   console.log('');
 }
 
@@ -123,7 +123,7 @@ Usage:
   npx mema-kit --update   Update skills to the latest version
   npx mema-kit --help     Show this help message
 
-After installing, open your project in Claude Code and run /onboard.
+After installing, open your project in Claude Code and run /mema.onboard.
 
 Learn more: https://github.com/simonv15/mema-kit
   `.trim());

package/docs/guide.md

@@ -1,8 +1,8 @@
 # mema-kit — Usage Guide
 
-**A memory protocol kit for Claude Code skills.**
+**A full AI-assisted development lifecycle kit for Claude Code.**
 
-Five built-in skills. Persistent memory across sessions. A protocol for building your own.
+Twelve built-in skills. Persistent memory across sessions. From vague idea to shipped code, without switching tools.
 
 ---
 
@@ -11,266 +11,191 @@ Five built-in skills. Persistent memory across sessions. A protocol for building
 Claude Code has a **context window** — everything it "knows" during a conversation. mema-kit works within that window, not outside it.
 
 ```
-"Load memory"   = Read .mema/ files → contents enter the context window
-"Save memory"   = Write .mema/ files → knowledge persists for next session
+"Load memory"     = Read .mema/ files → contents enter the context window
+"Save memory"     = Write .mema/ files → knowledge persists for next session
 "What's relevant" = Read index.md (~20 lines) → choose which files to load
 ```
 
 **Without mema-kit:** every session starts blank. You re-explain everything, or the agent explores your entire codebase (slow, expensive).
 
-**With mema-kit:** the agent reads `index.md`, instantly knows your architecture and recent decisions, loads only the 2-3 files relevant to your task, and gets to work.
-
-Think of it like a developer's notebook — it doesn't give you a bigger brain, it gives you the right information faster.
+**With mema-kit:** the agent reads `index.md`, instantly knows your architecture, active features, and recent decisions — and gets to work.
 
 ---
 
-## Quick Start
+## The Two Starting Points
+
+### Starting from a vague idea (new project)
 
 ```bash
 npx mema-kit          # install skills to .claude/skills/
 claude
-> /onboard            # scan project, create .mema/, populate initial memory
-> /recall             # next new session: load memory into context
+> /mema.seed          # capture your idea
+> /mema.clarify       # refine with Q&A
+> /mema.research      # find what exists (web search)
+> /mema.challenge     # stress-test assumptions
+> /mema.roadmap       # create feature list
+> /mema.specify 001   # spec the first feature
+> /mema.plan 001      # technical design
+> /mema.tasks 001     # generate task list
+> /mema.implement 001 # build it, one task at a time
 ```
 
-`/onboard` reads your package.json, README, directory structure, and representative source files, then writes real content to `architecture.md` and `requirements.md`. Idempotent — safe to re-run.
+### Starting from an existing project
 
-`/recall` loads your project memory into the current session — use it at the start of every new conversation to restore context instantly.
+```bash
+npx mema-kit          # install skills
+claude
+> /mema.onboard       # scan project, create .mema/, populate memory
+> /mema.specify       # spec a new feature
+> /mema.plan          # technical design
+> /mema.tasks         # generate task list
+> /mema.implement     # build it
+```
 
 ---
 
-## Recalling Memory: /recall
-
-Every new Claude Code session starts with a blank context. `/recall` fixes the cold-start problem by reading `.mema/` and printing a formatted summary into the conversation.
-
-### Modes
-
-| Mode | Command | What you get |
-|------|---------|--------------|
-| **Minimal** (default) | `/recall` or `/recall minimal` | Purpose, stack, architecture, current status, memory map |
-| **Full** | `/recall full` | Everything in Minimal + recent decisions, lessons, patterns, active context & plans |
+## Discovery Skills (New Projects)
 
-### When to use which
+### `/mema.seed [optional: inline idea]`
 
-| Situation | Mode |
-|-----------|------|
-| Starting a new session, need quick context | Minimal |
-| Picking up a multi-day task | Full |
-| Onboarding a teammate to the project | Full |
-| Quick check on what decisions exist | Full |
-| Daily development work | Minimal |
+Captures your raw idea exactly as described — no editing, no judgment. Use stream of consciousness, bullet points, half-formed thoughts. Saves to `.mema/product/seed.md`.
 
-`/recall` is **read-only** — it never modifies memory files. Safe to run at any time.
+```
+> /mema.seed I want to build a tool that helps remote teams do async standups
+```
 
----
+### `/mema.clarify`
 
-## Planning Work: /plan
+Asks 3–5 targeted questions to turn a seed into a crisp problem statement: who is it for, what problem does it solve, what's in scope, what's the motivation. Saves to `.mema/product/clarify.md`.
 
-`/plan` takes a high-level goal, explores your codebase, and produces a structured implementation plan with step-by-step specs. Plans are saved to `.mema/task-memory/` so `/implement` can execute them.
+### `/mema.research [optional: focus area]`
 
-### Usage
+Uses web search to investigate existing solutions, market context, and technical options. Saves findings with source links to `.mema/product/research.md`. Add a focus area to narrow the search:
 
 ```
-> /plan add user authentication
-> /plan refactor the database layer
-> /plan add search functionality to the API
+> /mema.research competitors
+> /mema.research tech stack options
 ```
 
-### What it does
-
-1. **Loads memory** — architecture, requirements, decisions, lessons, patterns
-2. **Explores the codebase** — reads relevant source files, understands current patterns
-3. **Asks clarifying questions** (1-2 max) if the goal is ambiguous
-4. **Produces a plan** — general approach + detailed steps with file paths and specifics
-5. **Saves to task-memory** — creates `context.md`, `plan.md`, and `status.md` in `task-memory/[task-name]/`
-
-### Example output
-
-```
-## Plan: User Authentication
+### `/mema.challenge`
 
-### Approach
-Add JWT-based authentication using the existing Fastify plugin system.
-Follows the controller → service → repository pattern already in the codebase.
+Plays devil's advocate. Identifies risky assumptions, builds a risk register with severity/likelihood/mitigation, and surfaces blind spots. Critical risks are flagged explicitly. Saves to `.mema/product/challenge.md`.
 
-### Steps (5 total)
-1. Create auth database schema and migration
-2. Implement auth service (register, login, token refresh)
-3. Create auth route handlers
-4. Add authentication middleware (Fastify plugin)
-5. Add auth integration tests
+### `/mema.roadmap`
 
-### Out of Scope
-- OAuth/social login
-- Role-based access control
-- Password reset flow
+Synthesizes all discovery outputs into a prioritized feature list with a problem statement and MVP scope. Creates numbered feature directories (`features/001-name/`, `features/002-name/`, etc.) ready for specification. Saves to `.mema/product/roadmap.md`.
 
 ---
-Plan saved to task-memory/user-authentication/
-To start implementing: /implement user-authentication
-```
-
-### Revising plans
 
-If you run `/plan` for a task that already has a plan, it will offer to revise the existing plan rather than starting from scratch. This makes `/plan` idempotent — safe to re-run.
-
----
+## Feature Workflow Skills
 
-## Implementing Plans: /implement
+These work on any project — with or without the discovery phase.
 
-`/implement` picks up steps from an existing plan, implements them one at a time, verifies the result, and tracks progress. It's designed to give you control — one step at a time by default.
+### `/mema.specify [feature number or description]`
 
-### Usage
+Creates the "what and why" spec for a feature. If a roadmap exists, presents the feature list and asks which to specify. Otherwise, takes a description directly. Saves to `.mema/features/NNN-name/spec.md`.
 
 ```
-> /implement user-authentication          # implement next incomplete step
-> /implement user-authentication step 3   # implement a specific step
-> /implement user-authentication all      # implement all remaining steps
-> /implement                              # list active tasks, then pick one
+> /mema.specify 001
+> /mema.specify "add user authentication"
 ```
 
-### What it does
+### `/mema.plan [feature]`
 
-1. **Loads the plan** — reads `plan.md`, `status.md`, and `context.md` from the task
-2. **Picks the next step** — first incomplete step, or the one you specified
-3. **Implements the step** — creates/modifies files following the plan's spec
-4. **Verifies** — runs tests, checks for errors, validates against the plan
-5. **Updates progress** — marks the step complete in `status.md`
-6. **Reports** — shows what was done, what's next, overall progress
+Creates the technical implementation design: approach, file changes, key decisions. Reads the feature spec and explores the existing codebase to ensure the plan fits established patterns. Saves to `.mema/features/NNN-name/plan.md`.
 
-### Progress tracking
-
-After each step, you'll see a progress summary:
-
-```
-## Progress: User Authentication
+### `/mema.tasks [feature]`
 
-Step 2/5 complete: Implement auth service
+Generates an ordered, checkable task list from the plan. Each task starts with a verb and includes a file path — specific enough to execute without additional context. Saves to `.mema/features/NNN-name/tasks.md`.
 
-Verified: All tests passing (4 new tests)
+### `/mema.implement [feature] [optional: step N | all]`
 
-### Overall Progress
-[====------] 2/5 steps
-Next: Step 3 — Create auth route handlers
+Executes one task at a time by default. Reads the task list, implements the next incomplete task, verifies it, and updates progress. When all tasks are done, offers to archive the feature.
 
-To continue: /implement user-authentication
+```
+> /mema.implement 001         # implement next task
+> /mema.implement 001 step 3  # implement a specific task
+> /mema.implement 001 all     # implement all remaining tasks
 ```
 
-### Task completion
-
-When all steps are done, `/implement` offers to archive the task:
+---
 
-- Marks `status.md` as complete
-- Moves `task-memory/[task-name]/` to `archive/[task-name]/`
-- Removes the task from active tasks in `index.md`
-- Records any lessons learned and patterns discovered
+## Utility Skills
 
-### Learning from implementation
+### `/mema.onboard`
 
-After each step, `/implement` reflects on the work:
-- Unexpected issues become **lessons** in `agent-memory/lessons.md`
-- Effective approaches become **patterns** in `agent-memory/patterns.md`
-- Decisions made during implementation are saved to `project-memory/decisions/`
+Bootstraps memory for an existing project. Scans the codebase (package.json, README, source files) and populates `.mema/` with real content. Generates or updates `CLAUDE.md`. Safe to re-run — updates stale content, leaves accurate content untouched.
 
-This means your memory grows smarter with every implementation cycle.
+For projects with the old mema-kit structure (`project-memory/`, `agent-memory/`, `task-memory/`): automatically migrates to the new layout on re-run.
 
----
+### `/mema.recall [optional: full]`
 
-## The plan → implement Workflow
-
-`/plan` and `/implement` form a complete spec-driven development workflow:
+Loads project memory into the current session. Shows active features and their status at the top — the most important context for a returning developer. Use at the start of every session.
 
 ```
-/plan                              /implement
-  │                                    │
-  ├─ reads:                            ├─ reads:
-  │   architecture                     │   plan.md (from /plan)
-  │   requirements                     │   status.md
-  │   decisions                        │   context.md
-  │   lessons & patterns               │   architecture, decisions
-  │                                    │   lessons & patterns
-  ├─ writes:                           │
-  │   task-memory/[task]/context.md    ├─ writes:
-  │   task-memory/[task]/plan.md       │   status.md (mark steps done)
-  │   task-memory/[task]/status.md     │   decisions/ (if any)
-  │                                    │   lessons.md (if any)
-  │                                    │   patterns.md (if any)
-  │                                    │   archive/ (on completion)
-  ▼                                    ▼
-       both flow through .mema/index.md
+> /mema.recall        # minimal — active features + project identity + next action
+> /mema.recall full   # everything + decisions + lessons + product discovery
 ```
 
-### Full workflow example
+### `/mema.create-skill`
 
-```bash
-# Session 1: Explore and plan
-> /recall                                    # load project context
-> /plan add user authentication              # explore codebase, produce plan
-
-# Session 2: Implement (pick up where you left off)
-> /recall                                    # load context + active tasks
-> /implement user-authentication             # implement step 1
-> /implement user-authentication             # implement step 2
-
-# Session 3: Finish up
-> /recall
-> /implement user-authentication all         # implement remaining steps
-# → task archived, lessons saved
-```
+Generates a new memory-aware Claude Code skill. Interviews you on the skill's name, purpose, and complexity level, generates a SKILL.md with proper memory lifecycle phases, shows you a preview before writing, and offers to enhance existing skills if you re-run with an existing skill name.
 
 ---
 
-## Extending with Custom Skills
-
-mema-kit ships with five built-in skills (`/onboard`, `/recall`, `/plan`, `/implement`, `/create-skill`). You can create your own skills to extend the workflow.
-
-### Example: Create `/explore`
-
-```
-> /create-skill
-  Name: explore
-  Purpose: Research technical decisions and save findings
-  Complexity: standard
-```
-
-Creates `.claude/skills/explore/SKILL.md` — a 4-phase skill that loads existing architecture and decisions, helps you research options, then saves new decisions and context to `.mema/`.
-
-**Using it:**
+## The Full Lifecycle in One View
 
 ```
-> /explore what auth strategy should we use?
+vague idea
+    │
+    ├── /mema.seed       → .mema/product/seed.md
+    ├── /mema.clarify    → .mema/product/clarify.md
+    ├── /mema.research   → .mema/product/research.md
+    ├── /mema.challenge  → .mema/product/challenge.md
+    └── /mema.roadmap    → .mema/product/roadmap.md
+                                  │
+                          pick a feature
+                                  │
+    ├── /mema.specify    → .mema/features/NNN-name/spec.md
+    ├── /mema.plan       → .mema/features/NNN-name/plan.md
+    ├── /mema.tasks      → .mema/features/NNN-name/tasks.md
+    └── /mema.implement  → source code + .mema/features/NNN-name/status.md
+                                  │
+                         /mema.recall (next session)
 ```
 
-The agent loads your stack from memory, researches JWT vs sessions vs OAuth, and saves the decision:
+Every skill reads what previous skills wrote. The index ties it all together.
 
-```
-.mema/project-memory/decisions/2026-02-24-auth-strategy.md
-  → "JWT with refresh tokens. Why: stateless, fits our REST API, team has experience."
-```
-
-Next session, any skill that loads memory will know this decision exists — including `/plan`, which can incorporate it into implementation plans.
+---
 
-### How custom skills connect with built-ins
+## Memory Structure
 
 ```
-/explore          /plan             /implement
-   │                 │                  │
-   ├─ reads:         ├─ reads:          ├─ reads:
-   │  architecture   │  architecture    │  plan
-   │  requirements   │  decisions       │  lessons
-   │                 │  context         │  patterns
-   ├─ writes:        ├─ writes:         │
-   │  decisions      │  plan            ├─ writes:
-   │  context        │  status          │  lessons
-   │                 │                  │  patterns
-   │                 │                  │  status → archive
-   ▼                 ▼                  ▼
-        all flow through .mema/index.md
-```
-
-Each skill reads what previous skills wrote. The index ties it all together.
-
-> **Tip:** Start every new session with `/recall` to load project context before using other skills. It takes seconds and saves minutes of re-exploration.
+.mema/
+├── index.md               # Pointer map — read this first
+├── product/               # Discovery phase outputs
+│   ├── seed.md            # Raw idea
+│   ├── clarify.md         # Refined intent
+│   ├── research.md        # Competitor and market findings
+│   ├── challenge.md       # Risk register
+│   └── roadmap.md         # Prioritized feature list
+├── features/              # One directory per feature
+│   └── 001-feature-name/
+│       ├── spec.md        # What + why
+│       ├── plan.md        # Technical design
+│       ├── tasks.md       # Implementation task list
+│       └── status.md      # Progress tracking
+├── project/               # Stable project knowledge
+│   ├── architecture.md
+│   ├── requirements.md
+│   └── decisions/
+├── agent/                 # Cross-session knowledge
+│   ├── lessons.md
+│   └── patterns.md
+└── archive/               # Completed features
+```
+
+The index is a **rebuildable cache** — if it gets out of sync, any skill rebuilds it from the directory structure.
 
 ---
 
@@ -288,39 +213,17 @@ Every skill follows four phases, defined in `_memory-protocol.md`:
 | Action | When |
 |--------|------|
 | **ADD** | New decision, finding, lesson, or pattern |
-| **UPDATE** | Existing knowledge changed (refined reasoning, new example) |
+| **UPDATE** | Existing knowledge changed |
 | **DELETE** | Wrong, superseded, or redundant |
 | **NOOP** | Still accurate — leave it alone (most files, most of the time) |
 
-Different file types have different curation styles:
-- **Decisions** — conservative (rarely delete, even reversed decisions teach)
-- **Context** — aggressive (prune dead ends, consolidate overlaps)
-- **Plans** — replace (keep final version only)
-- **Lessons/Patterns** — consolidate (merge similar entries)
-
----
-
-## Memory Structure
-
-```
-.mema/
-├── index.md               # Pointer map — read this first
-├── project-memory/        # Architecture, requirements, decisions
-│   └── decisions/         # YYYY-MM-DD-short-name.md
-├── task-memory/           # Per-task context, plans, status
-├── agent-memory/          # Lessons learned, reusable patterns
-├── archive/               # Completed tasks
-└── _templates/            # File templates
-```
-
-The index is a **rebuildable cache** — if it gets out of sync, the next skill rebuilds it from the directory structure. The actual `.mema/` files are the source of truth.
-
 ---
 
 ## Tips
 
 - **Memory is just markdown.** Open any file to see what the agent knows. Edit directly if something's wrong.
-- **`.mema/` is gitignored by default.** To share decisions with your team, uncomment `!.mema/project-memory/` in `.gitignore`.
-- **Curate, don't hoard.** The value of memory is its signal-to-noise ratio. Prune aggressively.
-- **Any skill can use the protocol.** Use `/create-skill` or manually follow the 4-phase lifecycle.
-- **One step at a time.** `/implement` defaults to one step per invocation. This gives you a chance to review each change before continuing.
+- **`.mema/` is gitignored by default.** To share decisions with your team, uncomment `!.mema/project/` in `.gitignore`.
+- **Discovery is optional.** You can jump straight to `/mema.specify` if you already know what to build.
+- **One task at a time.** `/mema.implement` defaults to one step per invocation — review each change before continuing.
+- **Curate, don't hoard.** The value of memory is signal-to-noise ratio. Prune aggressively.
+- **Start every session with `/mema.recall`.** It takes seconds and saves minutes of re-explanation.