mema-kit 1.0.5 → 1.0.6

package/README.md

@@ -14,21 +14,21 @@ npx mema-kit
 
 # 2. Open Claude Code and bootstrap memory
 claude
-> /onboard
+> /mema.onboard
 
 # 3. Next session: load memory into context
-> /recall
+> /mema.recall
 ```
 
-`/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.
+`/mema.onboard` scans your project, creates the `.mema/` memory structure, populates initial architecture and requirements docs, and configures CLAUDE.md and `.gitignore`. `/mema.recall` loads that memory into any future session.
 
 ## Built-in Skills
 
 | 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.onboard` | Bootstrap memory for a project — scans codebase, creates `.mema/`, populates initial knowledge |
+| `/mema.recall` | Load project memory into the current session — instant context on cold start |
+| `/mema.create-skill` | Generate a new memory-aware skill with the correct lifecycle phases |
 
 ## How Memory Works
 
@@ -64,10 +64,10 @@ The protocol is defined in `_memory-protocol.md` and shared across all skills (n
 
 ## Building Your Own Skills
 
-Use `/create-skill` to generate memory-aware skills:
+Use `/mema.create-skill` to generate memory-aware skills:
 
 ```
-> /create-skill
+> /mema.create-skill
 
 Skill name: review
 Purpose: Review code changes for quality and consistency

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

@@ -29,26 +29,26 @@ Think of it like a developer's notebook — it doesn't give you a bigger brain,
 ```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.onboard            # scan project, create .mema/, populate initial memory
+> /mema.recall             # next new session: load memory into context
 ```
 
-`/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.
+`/mema.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.
 
-`/recall` loads your project memory into the current session — use it at the start of every new conversation to restore context instantly.
+`/mema.recall` loads your project memory into the current session — use it at the start of every new conversation to restore context instantly.
 
 ---
 
-## Recalling Memory: /recall
+## Recalling Memory: /mema.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.
+Every new Claude Code session starts with a blank context. `/mema.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 |
+| **Minimal** (default) | `/mema.recall` or `/mema.recall minimal` | Purpose, stack, architecture, current status, memory map |
+| **Full** | `/mema.recall full` | Everything in Minimal + recent decisions, lessons, patterns, active context & plans |
 
 ### When to use which
 
@@ -60,20 +60,20 @@ Every new Claude Code session starts with a blank context. `/recall` fixes the c
 | Quick check on what decisions exist | Full |
 | Daily development work | Minimal |
 
-`/recall` is **read-only** — it never modifies memory files. Safe to run at any time.
+`/mema.recall` is **read-only** — it never modifies memory files. Safe to run at any time.
 
 ---
 
-## Planning Work: /plan
+## Planning Work: /mema.plan
 
-`/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.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 `/mema.implement` can execute them.
 
 ### Usage
 
 ```
-> /plan add user authentication
-> /plan refactor the database layer
-> /plan add search functionality to the API
+> /mema.plan add user authentication
+> /mema.plan refactor the database layer
+> /mema.plan add search functionality to the API
 ```
 
 ### What it does
@@ -107,26 +107,26 @@ Follows the controller → service → repository pattern already in the codebas
 
 ---
 Plan saved to task-memory/user-authentication/
-To start implementing: /implement user-authentication
+To start implementing: /mema.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.
+If you run `/mema.plan` for a task that already has a plan, it will offer to revise the existing plan rather than starting from scratch. This makes `/mema.plan` idempotent — safe to re-run.
 
 ---
 
-## Implementing Plans: /implement
+## Implementing Plans: /mema.implement
 
-`/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.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.
 
 ### Usage
 
 ```
-> /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.implement user-authentication          # implement next incomplete step
+> /mema.implement user-authentication step 3   # implement a specific step
+> /mema.implement user-authentication all      # implement all remaining steps
+> /mema.implement                              # list active tasks, then pick one
 ```
 
 ### What it does
@@ -153,12 +153,12 @@ Verified: All tests passing (4 new tests)
 [====------] 2/5 steps
 Next: Step 3 — Create auth route handlers
 
-To continue: /implement user-authentication
+To continue: /mema.implement user-authentication
 ```
 
 ### Task completion
 
-When all steps are done, `/implement` offers to archive the task:
+When all steps are done, `/mema.implement` offers to archive the task:
 
 - Marks `status.md` as complete
 - Moves `task-memory/[task-name]/` to `archive/[task-name]/`
@@ -167,7 +167,7 @@ When all steps are done, `/implement` offers to archive the task:
 
 ### Learning from implementation
 
-After each step, `/implement` reflects on the work:
+After each step, `/mema.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/`
@@ -178,20 +178,20 @@ This means your memory grows smarter with every implementation cycle.
 
 ## The plan → implement Workflow
 
-`/plan` and `/implement` form a complete spec-driven development workflow:
+`/mema.plan` and `/mema.implement` form a complete spec-driven development workflow:
 
 ```
-/plan                              /implement
+/mema.plan                              /mema.implement
   │                                    │
   ├─ reads:                            ├─ reads:
-  │   architecture                     │   plan.md (from /plan)
+  │   architecture                     │   plan.md (from /mema.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]/mema.plan.md       │   status.md (mark steps done)
   │   task-memory/[task]/status.md     │   decisions/ (if any)
   │                                    │   lessons.md (if any)
   │                                    │   patterns.md (if any)
@@ -204,17 +204,17 @@ This means your memory grows smarter with every implementation cycle.
 
 ```bash
 # Session 1: Explore and plan
-> /recall                                    # load project context
-> /plan add user authentication              # explore codebase, produce plan
+> /mema.recall                                    # load project context
+> /mema.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
+> /mema.recall                                    # load context + active tasks
+> /mema.implement user-authentication             # implement step 1
+> /mema.implement user-authentication             # implement step 2
 
 # Session 3: Finish up
-> /recall
-> /implement user-authentication all         # implement remaining steps
+> /mema.recall
+> /mema.implement user-authentication all         # implement remaining steps
 # → task archived, lessons saved
 ```
 
@@ -222,12 +222,12 @@ This means your memory grows smarter with every implementation cycle.
 
 ## 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.
+mema-kit ships with five built-in skills (`/mema.onboard`, `/mema.recall`, `/mema.plan`, `/mema.implement`, `/mema.create-skill`). You can create your own skills to extend the workflow.
 
 ### Example: Create `/explore`
 
 ```
-> /create-skill
+> /mema.create-skill
   Name: explore
   Purpose: Research technical decisions and save findings
   Complexity: standard
@@ -248,12 +248,12 @@ The agent loads your stack from memory, researches JWT vs sessions vs OAuth, and
   → "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.
+Next session, any skill that loads memory will know this decision exists — including `/mema.plan`, which can incorporate it into implementation plans.
 
 ### How custom skills connect with built-ins
 
 ```
-/explore          /plan             /implement
+/explore          /mema.plan             /mema.implement
    │                 │                  │
    ├─ reads:         ├─ reads:          ├─ reads:
    │  architecture   │  architecture    │  plan
@@ -270,7 +270,7 @@ Next session, any skill that loads memory will know this decision exists — inc
 
 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.
+> **Tip:** Start every new session with `/mema.recall` to load project context before using other skills. It takes seconds and saves minutes of re-exploration.
 
 ---
 
@@ -322,5 +322,5 @@ The index is a **rebuildable cache** — if it gets out of sync, the next skill
 - **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.
+- **Any skill can use the protocol.** Use `/mema.create-skill` or manually follow the 4-phase lifecycle.
+- **One step at a time.** `/mema.implement` defaults to one step per invocation. This gives you a chance to review each change before continuing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mema-kit",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Memory protocol kit for Claude Code skills",
   "bin": {
     "mema-kit": "bin/cli.js"

package/skills/{create-skill → mema.create-skill}/SKILL.md

@@ -2,7 +2,7 @@
 description: Generate a new memory-aware Claude Code skill. Creates a SKILL.md file with the correct memory lifecycle phases based on the skill's complexity.
 ---
 
-# /create-skill — Generate Memory-Aware Skills
+# /mema.create-skill — Generate Memory-Aware Skills
 
 You are creating a new Claude Code skill that integrates with mema-kit's memory protocol. Follow these steps carefully.
 
@@ -48,7 +48,7 @@ You are executing the /[skill-name] skill. Follow these steps carefully.
 ## Phase 1: AUTO-LOAD
 
 1. Read `.mema/index.md` to understand current project state
-2. If `index.md` is missing or empty, inform the user to run `/onboard` first
+2. If `index.md` is missing or empty, inform the user to run `/mema.onboard` first
 3. Based on the user's request, identify and read relevant memory files
 4. Read only what's needed — don't load everything
 

package/skills/{implement → mema.implement}/SKILL.md

@@ -1,18 +1,18 @@
 ---
-description: Execute implementation plan steps one at a time. Picks up the next step from an existing plan, implements it, verifies the result, and tracks progress. Run /plan first to create a plan.
+description: Execute implementation plan steps one at a time. Picks up the next step from an existing plan, implements it, verifies the result, and tracks progress. Run /mema.plan first to create a plan.
 ---
 
-# /implement — Plan Step Execution
+# /mema.implement — Plan Step Execution
 
-You are executing the /implement skill. Follow these steps carefully.
+You are executing the /mema.implement skill. Follow these steps carefully.
 
-This skill picks up a step from an existing plan (created by `/plan`), implements it, verifies the result, and updates progress tracking. By default, it implements **one step at a time** to give the user control over the process.
+This skill picks up a step from an existing plan (created by `/mema.plan`), implements it, verifies the result, and updates progress tracking. By default, it implements **one step at a time** to give the user control over the process.
 
 ## Phase 1: AUTO-LOAD
 
 1. Read `.mema/index.md` to understand current project state
 2. If `index.md` is missing or `.mema/` does not exist:
-   - Tell the user: "No memory found. Run `/onboard` first to set up mema-kit for this project."
+   - Tell the user: "No memory found. Run `/mema.onboard` first to set up mema-kit for this project."
    - **Stop here** — do not continue to further steps.
 3. If `index.md` is empty, run the **Rebuild Procedure** from `_memory-protocol.md`
 4. Scan `## Active Tasks` in `index.md` to find tasks with plans
@@ -28,13 +28,13 @@ This skill picks up a step from an existing plan (created by `/plan`), implement
 
 Parse the user's input to determine which task to implement:
 
-- **Task specified:** `/implement user-auth` → look for `task-memory/user-auth/`
-- **Task + step specified:** `/implement user-auth step 3` → load that specific step
-- **No task specified:** `/implement` → list active tasks from index.md and ask which one
-- **"all" modifier:** `/implement user-auth all` → implement all remaining steps sequentially (see 2e)
+- **Task specified:** `/mema.implement user-auth` → look for `task-memory/user-auth/`
+- **Task + step specified:** `/mema.implement user-auth step 3` → load that specific step
+- **No task specified:** `/mema.implement` → list active tasks from index.md and ask which one
+- **"all" modifier:** `/mema.implement user-auth all` → implement all remaining steps sequentially (see 2e)
 
 If the specified task directory doesn't exist:
-- Tell the user: "No plan found for '[task-name]'. Run `/plan [goal]` first to create an implementation plan."
+- Tell the user: "No plan found for '[task-name]'. Run `/mema.plan [goal]` first to create an implementation plan."
 - **Stop here.**
 
 ### 2b: Load Task Context
@@ -45,7 +45,7 @@ Read the task's files from `task-memory/[task-name]/`:
 2. **`status.md`** — current progress (which steps are done)
 3. **`context.md`** — exploration findings relevant to this task
 
-If `plan.md` is missing, tell the user: "Task directory exists but has no plan. Run `/plan [goal]` to create one."
+If `plan.md` is missing, tell the user: "Task directory exists but has no plan. Run `/mema.plan [goal]` to create one."
 
 ### 2c: Select Step
 
@@ -77,7 +77,7 @@ Follow the plan's specification for this step:
 
 ### 2e: Implement All Remaining (if requested)
 
-If the user requested "all" (e.g., `/implement user-auth all`):
+If the user requested "all" (e.g., `/mema.implement user-auth all`):
 
 1. Implement steps sequentially, starting from the first incomplete step
 2. After each step, verify before moving to the next
@@ -115,7 +115,7 @@ Suggested fix: [how to resolve]
 [====------] [completed]/[total] steps
 Next: Step [N+1] — [description]
 
-To continue: /implement [task-name]
+To continue: /mema.implement [task-name]
 ```
 
 ### 2g: Task Completion

package/skills/{onboard → mema.onboard}/SKILL.md

@@ -2,7 +2,7 @@
 description: Bootstrap the mema-kit memory system for this project. Creates .mema/ directory, scans the project, populates initial memory, and configures CLAUDE.md and .gitignore.
 ---
 
-# /onboard — Project Memory Bootstrap
+# /mema.onboard — Project Memory Bootstrap
 
 You are setting up the mema-kit memory system for this project. Follow these steps carefully. This command is idempotent — safe to re-run. Never overwrite existing data.
 
@@ -437,9 +437,9 @@ Include dev, test, build, and lint commands at minimum (if they exist). If no co
 If no skills are found (shouldn't happen since we just installed them, but as a fallback):
 
 ```
-- `/onboard` — Bootstrap the mema-kit memory system
-- `/recall` — Recall project memory into current session
-- `/create-skill` — Generate a new memory-aware skill
+- `/mema.onboard` — Bootstrap the mema-kit memory system
+- `/mema.recall` — Recall project memory into current session
+- `/mema.create-skill` — Generate a new memory-aware skill
 ```
 
 **Memory System:** Append the standard Memory System section (same text as Path A).

package/skills/{plan → mema.plan}/SKILL.md

@@ -1,18 +1,18 @@
 ---
-description: Break a high-level goal into a structured implementation plan. Explores the codebase, produces step-by-step specs, and saves them to task-memory/ for use by /implement.
+description: Break a high-level goal into a structured implementation plan. Explores the codebase, produces step-by-step specs, and saves them to task-memory/ for use by /mema.implement.
 ---
 
-# /plan — Implementation Planning
+# /mema.plan — Implementation Planning
 
-You are executing the /plan skill. Follow these steps carefully.
+You are executing the /mema.plan skill. Follow these steps carefully.
 
-This skill takes a user's goal (e.g., `/plan add user authentication`), explores the codebase, and produces a detailed implementation plan saved to `.mema/task-memory/[task-name]/`.
+This skill takes a user's goal (e.g., `/mema.plan add user authentication`), explores the codebase, and produces a detailed implementation plan saved to `.mema/task-memory/[task-name]/`.
 
 ## Phase 1: AUTO-LOAD
 
 1. Read `.mema/index.md` to understand current project state
 2. If `index.md` is missing or `.mema/` does not exist:
-   - Tell the user: "No memory found. Run `/onboard` first to set up mema-kit for this project."
+   - Tell the user: "No memory found. Run `/mema.onboard` first to set up mema-kit for this project."
    - **Stop here** — do not continue to further steps.
 3. If `index.md` is empty, run the **Rebuild Procedure** from `_memory-protocol.md`
 4. Load relevant memory files:
@@ -28,10 +28,10 @@ Read only what's needed — don't load everything.
 
 ### 2a: Parse the Goal
 
-Extract the task goal from the user's input. The goal is everything after `/plan`.
+Extract the task goal from the user's input. The goal is everything after `/mema.plan`.
 
-- Example: `/plan add user authentication` → goal is "add user authentication"
-- Example: `/plan refactor the database layer` → goal is "refactor the database layer"
+- Example: `/mema.plan add user authentication` → goal is "add user authentication"
+- Example: `/mema.plan refactor the database layer` → goal is "refactor the database layer"
 
 If no goal is provided, ask the user: "What would you like to plan? Describe your goal in a sentence or two."
 
@@ -78,11 +78,11 @@ Using your exploration findings and loaded memory, produce the plan in three par
 **Detailed Steps** — Step-by-step implementation specs. Each step must include:
 - **Action:** What to do (create file, modify function, add test, etc.)
 - **Files:** Specific file paths to create or modify
-- **Details:** Enough detail that `/implement` can execute the step without ambiguity
+- **Details:** Enough detail that `/mema.implement` can execute the step without ambiguity
 - **Dependencies:** Which prior steps must be complete first (if any)
 
 Rules for steps:
-- Each step should be small enough to implement in a single `/implement` invocation
+- Each step should be small enough to implement in a single `/mema.implement` invocation
 - Order steps logically (foundations first, then features, then tests, then cleanup)
 - Be specific about file paths — use the actual paths discovered during exploration
 - Include test steps where appropriate (not just at the end)
@@ -180,7 +180,7 @@ Print a summary to the user:
 
 ---
 Plan saved to task-memory/[task-name]/
-To start implementing: /implement [task-name]
+To start implementing: /mema.implement [task-name]
 ```
 
 ## Phase 3: AUTO-SAVE & CURATE

package/skills/{recall → mema.recall}/SKILL.md

@@ -2,9 +2,9 @@
 description: Recall project memory into the current session. Loads .mema/ knowledge (architecture, decisions, lessons, patterns) and prints a formatted summary. Use at the start of a session to restore context.
 ---
 
-# /recall — Session Memory Recall
+# /mema.recall — Session Memory Recall
 
-You are executing the /recall skill. This is a **read-only** skill — it loads memory and prints a summary into the conversation. It never writes to any files.
+You are executing the /mema.recall skill. This is a **read-only** skill — it loads memory and prints a summary into the conversation. It never writes to any files.
 
 Follow these steps carefully.
 
@@ -23,7 +23,7 @@ If the user provides an unrecognized argument (not `minimal`, `full`, or empty):
 
 1. Read `.mema/index.md`
 2. If `index.md` is missing or `.mema/` does not exist:
-   - Tell the user: "No memory found. Run `/onboard` first to set up mema-kit for this project."
+   - Tell the user: "No memory found. Run `/mema.onboard` first to set up mema-kit for this project."
    - **Stop here** — do not continue to further steps.
 3. Parse the index to identify available memory files and their summaries.
 
@@ -85,7 +85,7 @@ Use the format below based on the current mode.
 - Agent Lessons: [N] lessons, [N] patterns
 
 ---
-*Showing minimal recall. Use `/recall full` for decisions, lessons, and patterns.*
+*Showing minimal recall. Use `/mema.recall full` for decisions, lessons, and patterns.*
 ```
 
 ---
@@ -132,4 +132,4 @@ Use the format below based on the current mode.
 
 ---
 
-**Important:** This skill is purely informational. If you notice memory files are missing or out of date, suggest the user run `/onboard` or the relevant skill — do not attempt to fix memory yourself.
+**Important:** This skill is purely informational. If you notice memory files are missing or out of date, suggest the user run `/mema.onboard` or the relevant skill — do not attempt to fix memory yourself.