@hir4ta/mneme 0.23.2 → 0.24.1

package/skills/harvest/SKILL.md

@@ -83,8 +83,8 @@ Use explicit section markers and XML-style tags for hard constraints:
 4. Deduplicate/conflict-check against existing sources.
 5. Save source artifacts with `prSource` metadata.
 6. Run source validation gate:
-   - `npm run validate:sources`
-   - If failed: fix artifacts and rerun.
+   - Call MCP tool `mneme_validate_sources`
+   - If failed (`valid: false`): fix artifacts and rerun.
 7. Regenerate units from sources.
 8. Show pending units for approval.
 
@@ -94,6 +94,6 @@ Use explicit section markers and XML-style tags for hard constraints:
 - extracted source item counts by type
 - duplicate/conflict summary
 - priority distribution (`p0/p1/p2` for added/updated rules)
-- validation result (`validate:sources`)
+- validation result (`mneme_validate_sources`)
 - regenerated units count
 - pending units count

package/skills/init-mneme/SKILL.md

@@ -9,99 +9,25 @@ disable-model-invocation: true
 # Initialize mneme
 
 <instructions>
-Create the `.mneme` directory structure in the current project.
+Initialize mneme in the current project by running the CLI command.
 
 <required>
 - Never overwrite existing user data under `.mneme/` without explicit confirmation.
-- Create JSON files with valid schema fields.
-- Ensure `.mneme/local.db` is gitignored.
+- Check if `.mneme` already exists first - if so, inform the user it's already initialized.
 </required>
 
-1. Check if `.mneme` already exists - if so, inform the user it's already initialized
-2. Create the directory structure:
-   - `.mneme/sessions/`
-   - `.mneme/rules/`
-   - `.mneme/patterns/`
-   - `.mneme/decisions/`
-3. Copy default tags from the plugin's `hooks/default-tags.json` to `.mneme/tags.json`
-4. Create `.mneme/.gitignore` to exclude local database:
-   ```
-   # Local SQLite database (private interactions)
-   local.db
-   local.db-wal
-   local.db-shm
-   ```
-5. Create empty rules files:
-   - `.mneme/rules/dev-rules.json`
-   - `.mneme/rules/review-guidelines.json`
-6. Initialize local SQLite database at `.mneme/local.db`
-   - Note: Data is stored locally within the project
-   - The local.db is gitignored (private interactions)
+Run the following command:
 
-Use this JSON template for the rules files:
-```json
-{
-  "schemaVersion": 1,
-  "createdAt": "<current ISO timestamp>",
-  "updatedAt": "<current ISO timestamp>",
-  "items": []
-}
-```
-
-For SQLite initialization (local database):
 ```bash
-# Local database location
-MNEME_DIR=".mneme"
-
-# Initialize with schema
-sqlite3 "$MNEME_DIR/local.db" < /path/to/mneme/lib/schema.sql
-```
-
-Or if schema.sql is not available, create minimal schema:
-```bash
-MNEME_DIR=".mneme"
-
-sqlite3 "$MNEME_DIR/local.db" "
-CREATE TABLE IF NOT EXISTS interactions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id TEXT NOT NULL,
-    project_path TEXT NOT NULL,
-    repository TEXT,
-    repository_url TEXT,
-    repository_root TEXT,
-    owner TEXT NOT NULL,
-    role TEXT NOT NULL,
-    content TEXT NOT NULL,
-    thinking TEXT,
-    tool_calls TEXT,
-    timestamp TEXT NOT NULL,
-    is_compact_summary INTEGER DEFAULT 0,
-    created_at TEXT DEFAULT (datetime('now'))
-);
-CREATE INDEX IF NOT EXISTS idx_interactions_session ON interactions(session_id);
-CREATE INDEX IF NOT EXISTS idx_interactions_owner ON interactions(owner);
-CREATE INDEX IF NOT EXISTS idx_interactions_project ON interactions(project_path);
-CREATE INDEX IF NOT EXISTS idx_interactions_repo ON interactions(repository);
-
-CREATE TABLE IF NOT EXISTS pre_compact_backups (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id TEXT NOT NULL,
-    project_path TEXT NOT NULL,
-    owner TEXT NOT NULL,
-    interactions TEXT NOT NULL,
-    created_at TEXT DEFAULT (datetime('now'))
-);
-CREATE INDEX IF NOT EXISTS idx_backups_session ON pre_compact_backups(session_id);
-CREATE INDEX IF NOT EXISTS idx_backups_project ON pre_compact_backups(project_path);
-
-CREATE TABLE IF NOT EXISTS migrations (
-    project_path TEXT PRIMARY KEY,
-    migrated_at TEXT DEFAULT (datetime('now'))
-);
-"
+npx @hir4ta/mneme --init
 ```
 
-**Note:** The local database stores interactions for this project only. It is gitignored to keep conversations private.
+This single command handles all initialization:
+- Creates `.mneme/` directory structure (sessions, rules, patterns)
+- Copies default tags to `.mneme/tags.json`
+- Creates empty rule files (dev-rules.json, review-guidelines.json)
+- Creates `.gitignore` for local database files
+- Initializes SQLite database at `.mneme/local.db`
 
-After creation, confirm success and explain that mneme will now track sessions in this project.
+After the command completes, confirm success and explain that mneme will now track sessions in this project.
 </instructions>

package/skills/reflect/SKILL.md

@@ -0,0 +1,267 @@
+---
+name: reflect
+description: |
+  Analyze accumulated knowledge to detect patterns, contradictions, and stale items.
+  Use when: (1) reviewing knowledge health, (2) finding promotion candidates,
+  (3) detecting contradictions between decisions.
+disable-model-invocation: true
+context: fork
+allowed-tools: Read, Glob, Grep, AskUserQuestion
+---
+
+# /mneme:reflect
+
+Analyze accumulated mneme knowledge across sessions, decisions, patterns, and rules. Produce a meta-analysis report identifying recurring themes, contradictions, promotion candidates, stale items, and overall knowledge health.
+
+## Language
+
+Generate report content in the user's language (detect from conversation context).
+
+## Execution Phases
+
+### Phase 1: Period Selection
+
+Use `AskUserQuestion` to let the user choose the analysis scope:
+
+```
+Question: "分析の対象期間を選択してください"
+Options:
+  - "全期間 (Recommended)" -> all data
+  - "過去90日" -> 90 days
+  - "過去30日" -> 30 days
+```
+
+### Phase 2: Data Collection
+
+Read all data from the project's `.mneme/` directory. Filter by period using `createdAt` / `updatedAt` timestamps.
+
+**Sessions** -- Read all `.mneme/sessions/YYYY/MM/*.json`:
+```
+Key fields:
+  - id, title, tags, createdAt, updatedAt
+  - summary.sessionType
+  - discussions[].topic, discussions[].decision
+  - errors[].error, errors[].solution
+```
+
+**Decisions** -- Read all `.mneme/decisions/YYYY/MM/*.json`:
+```
+Key fields:
+  - id, title, decision, reasoning, alternatives[]
+  - tags, status (draft/active/superseded/deprecated)
+  - createdAt, updatedAt
+  - relatedSessions[]
+```
+
+**Patterns** -- Read `.mneme/patterns/*.json` (each file has `items[]` or `patterns[]` array):
+```
+Key fields:
+  - id, type (good/bad/error-solution), title/description
+  - tags, status (draft/active/approved)
+  - sourceId, createdAt, updatedAt
+```
+
+**Rules** -- Read `.mneme/rules/dev-rules.json` and `.mneme/rules/review-guidelines.json`:
+```
+Key fields:
+  - id, key, text/rule, category, priority (p0/p1/p2)
+  - tags, status (draft/approved/active/rejected)
+  - sourceRef: { type, id }
+  - appliedCount, acceptedCount, lastAppliedAt
+  - createdAt, updatedAt
+```
+
+**Tags** -- Read `.mneme/tags.json` for the full tag definitions.
+
+### Phase 3: Analysis (5 Categories)
+
+Analyze the collected data and produce findings for each category.
+
+#### Category 1: Recurring Themes
+
+Aggregate tags across ALL artifact types (sessions, decisions, patterns, rules).
+
+For tags appearing in 3+ artifacts:
+- Count artifacts per tag, grouped by type
+- Calculate "knowledge density" = (decisions + patterns + rules) / sessions for each tag
+- High density (>0.5) = well-documented topic
+- Low density (<0.2) = frequently worked on but under-documented
+
+Output as a table:
+
+```markdown
+| Theme (Tags) | Sessions | Decisions | Patterns | Rules | Density |
+|---|---|---|---|---|---|
+| auth | 5 | 2 | 1 | 1 | 0.80 |
+| refactor | 8 | 1 | 1 | 0 | 0.25 |
+```
+
+Flag low-density topics as candidates for knowledge extraction.
+
+#### Category 2: Contradiction Detection
+
+Compare active decisions that share the same tags or categories:
+
+1. Group active/approved decisions by their primary tags
+2. For each group with 2+ decisions, compare their `decision` and `reasoning` fields
+3. Flag potential contradictions where:
+   - Decisions reference the same technology/pattern but reach different conclusions
+   - One decision recommends X while another recommends avoiding X
+   - Decisions with overlapping `alternatives` where one chose what another rejected
+
+<required>
+- Use your judgment as an AI to detect semantic contradictions, not just keyword matches.
+- A contradiction is when two active decisions give conflicting guidance for the same situation.
+- Different decisions for genuinely different contexts are NOT contradictions.
+</required>
+
+Output:
+```markdown
+## 2. Potential Contradictions
+
+### Found N potential contradiction(s)
+
+**[dec-xxx] vs [dec-yyy]**
+- dec-xxx: "Chose A because ..."
+- dec-yyy: "Chose B because ..."
+- Shared tags: [tag1, tag2]
+- Assessment: [Genuine contradiction / Different contexts / Superseded]
+- Recommendation: [Supersede one / Clarify scope / Keep both with context notes]
+```
+
+If no contradictions found, output: "No contradictions detected among active decisions."
+
+#### Category 3: Promotion Candidates
+
+Find approved patterns that could be promoted to rules:
+
+1. Read all patterns with `status === "approved"` or `status === "active"`
+2. Read all rules and build a set of `sourceRef.id` values
+3. For each approved pattern NOT referenced by any rule's `sourceRef`:
+   - Check if it represents a broadly applicable practice (not context-specific)
+   - Suggest promotion with a draft rule text
+
+Output:
+```markdown
+## 3. Promotion Candidates
+
+### Patterns -> Rules
+
+- **[pat-xxx]** "{description}"
+  - Type: {good/bad/error-solution}
+  - Tags: {tags}
+  - Suggested rule: "{imperative rule text}"
+  - Suggested priority: {p1/p2}
+```
+
+Also check for approved decisions that represent broadly applicable guidance:
+- Decisions where the reasoning applies beyond the original context
+- Decisions referenced by 2+ sessions
+
+#### Category 4: Staleness Check
+
+Flag potentially outdated knowledge:
+
+**Stale Decisions** (createdAt > 90 days ago AND no updatedAt):
+```
+- [dec-xxx] "{title}" - created {N} days ago, never updated
+```
+
+**Unused Rules** (appliedCount === 0 AND createdAt > 30 days ago):
+```
+- [rule-xxx] "{text}" - created {N} days ago, never applied
+```
+
+**Forgotten Drafts** (status === "draft" AND createdAt > 30 days ago):
+```
+- [dec-xxx] "{title}" - draft for {N} days, consider approving or deleting
+- [pat-xxx] "{description}" - draft for {N} days
+```
+
+**Low Effectiveness Rules** (appliedCount > 3 AND acceptedCount/appliedCount < 0.3):
+```
+- [rule-xxx] "{text}" - applied {N} times, accepted only {M} times ({ratio}%)
+  Consider revising or deprecating
+```
+
+#### Category 5: Knowledge Health Report
+
+Generate aggregate metrics:
+
+```markdown
+## 5. Knowledge Health
+
+### Overview
+| Metric | Count |
+|---|---|
+| Total Sessions | N |
+| Total Decisions | N (active: N, draft: N, superseded: N) |
+| Total Patterns | N (approved: N, draft: N) |
+| Total Rules | N (active: N, draft: N, rejected: N) |
+
+### Priority Distribution (Active Rules)
+| Priority | Count | % |
+|---|---|---|
+| p0 (critical) | N | X% |
+| p1 (important) | N | X% |
+| p2 (advisory) | N | X% |
+
+### Approval Pipeline
+- Draft -> Approved rate: X% (N/M items)
+- Average age of drafts: N days
+- Oldest unapproved draft: [id] ({N} days)
+
+### Tag Coverage
+- Defined tags (in tags.json): N
+- Used tags: N
+- Unused tags: [list]
+
+### Rule Effectiveness (active rules with appliedCount > 0)
+- Average acceptance rate: X%
+- Most effective: [rule-xxx] ({ratio}%)
+- Least effective: [rule-xxx] ({ratio}%)
+```
+
+### Phase 4: Report Output
+
+Output the complete report to the console in Markdown format.
+
+Structure:
+```markdown
+# mneme Reflection Report
+
+**Project**: {projectName}
+**Period**: {period description}
+**Generated**: {date}
+
+---
+
+## 1. Recurring Themes
+{Category 1 output}
+
+## 2. Potential Contradictions
+{Category 2 output}
+
+## 3. Promotion Candidates
+{Category 3 output}
+
+## 4. Stale Knowledge
+{Category 4 output}
+
+## 5. Knowledge Health
+{Category 5 output}
+
+---
+
+## Summary & Recommendations
+
+{AI-generated 3-5 bullet points with actionable recommendations based on ALL findings above}
+```
+
+## Important Notes
+
+- This skill is READ-ONLY: do not modify any files
+- Do not access `.mneme/local.db` (SQLite) -- privacy constraint; use only shared JSON files
+- If the project has very few artifacts (< 3 sessions), note this and provide a minimal report
+- Focus on actionable insights, not just raw numbers
+- For contradiction detection, use AI judgment -- don't just pattern-match keywords

package/skills/report/SKILL.md

@@ -38,7 +38,7 @@ Options:
 
 Read all data from the project's `.mneme/` directory. Filter by period using `createdAt` / `updatedAt` timestamps.
 
-**Sessions** — Read all `.mneme/sessions/YYYY/MM/*.json`:
+**Sessions** — Read all `.mneme/sessions/YYYY/MM/*.json` (also collect `context.user.name` for team attribution):
 ```
 Key fields:
   - title, sessionType, tags, createdAt
@@ -128,6 +128,46 @@ Get `projectName` and `repository` from any session's `context` field.
 4 KPIs: Sessions, Decisions, Patterns, Rule Changes.
 Use `data-type` attribute for color coding.
 
+#### Section 2.5: Team Contributions (conditional)
+
+**Condition**: Only render this section if there are 2 or more unique users found in session `context.user.name` fields. For solo projects (1 user), skip this section entirely.
+
+Collect per-user counts by iterating sessions (`context.user.name`), decisions (`user.name`), and pattern files (filename convention `{user}.json`).
+
+```html
+<section class="section">
+  <h2>
+    <span data-i18n="teamEn">Team Contributions</span>
+    <span data-i18n="teamJa">チーム貢献</span>
+  </h2>
+  <div class="team-grid">
+    <article class="team-card">
+      <div class="team-name">{userName}</div>
+      <div class="team-stats">
+        <span class="team-stat">
+          <span class="team-stat-value">{sessionCount}</span>
+          <span class="team-stat-label">Sessions</span>
+        </span>
+        <span class="team-stat">
+          <span class="team-stat-value">{decisionCount}</span>
+          <span class="team-stat-label">Decisions</span>
+        </span>
+        <span class="team-stat">
+          <span class="team-stat-value">{patternCount}</span>
+          <span class="team-stat-label">Patterns</span>
+        </span>
+      </div>
+      <div class="team-bar">
+        <div class="team-bar-fill" style="width:{sessionPercentage}%; background: var(--session);"></div>
+      </div>
+    </article>
+    <!-- Repeat for each team member -->
+  </div>
+</section>
+```
+
+Sort members by session count descending.
+
 #### Section 3: Development Activity Summary (AI-generated)
 
 ```html
@@ -147,6 +187,7 @@ Analyze ALL sessions and generate a 3-5 paragraph narrative summary:
 - Key outcomes and achievements
 - Notable technical challenges and how they were resolved
 - Trends (e.g., "refactoring was the main focus" or "multiple bug fixes across modules")
+- **Team contributions** (if multiple users): who worked on what, collaboration patterns (same branch/tags), notable individual contributions
 
 Write in a style that is informative for junior engineers — explain WHY things were done, not just WHAT.
 Make the summary bilingual using `data-i18n-item="en"` / `data-i18n-item="ja"` spans.

package/skills/report/report-template.html

@@ -64,6 +64,17 @@
     .kpi .label { color: var(--ink-subtle); font-size: 12px; text-transform: uppercase; letter-spacing: 0.08em; }
     .kpi .value { font-size: 30px; font-weight: 700; margin-top: 6px; }
 
+    /* Team Contributions */
+    .team-grid { display: grid; gap: 12px; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); }
+    .team-card { background: var(--card); border: 1px solid var(--line); border-radius: 12px; padding: 14px; box-shadow: 0 2px 8px var(--shadow); }
+    .team-name { font-weight: 700; font-size: 15px; margin-bottom: 10px; }
+    .team-stats { display: flex; gap: 12px; }
+    .team-stat { display: flex; flex-direction: column; align-items: center; }
+    .team-stat-value { font-size: 22px; font-weight: 700; }
+    .team-stat-label { font-size: 11px; color: var(--ink-subtle); text-transform: uppercase; letter-spacing: 0.06em; }
+    .team-bar { height: 6px; background: var(--chip); border-radius: 999px; margin-top: 8px; overflow: hidden; }
+    .team-bar-fill { height: 100%; border-radius: 999px; }
+
     /* Sections */
     .section { margin-top: 26px; }
     .section h2 { margin: 0 0 12px; font-size: 22px; letter-spacing: -0.01em; }

package/skills/save/SKILL.md

@@ -60,6 +60,9 @@ Always render missing required fields as blocking errors before write.
 
 3. **Session summary extraction (required MCP)**
 - Extract from the conversation: `title`, `goal`, `outcome`, `description`, `tags`, `sessionType`.
+- Extract **file and technology context** (critical for search and session recommendations):
+  - `filesModified`: files changed during session (path + action: create/edit/delete/rename)
+  - `technologies`: technologies, frameworks, and libraries used (e.g., "React", "Hono", "SQLite")
 - Additionally extract **structured context** (data likely lost during auto-compact):
   - `plan`: session goals, task list (completed tasks use `[x] ` prefix), remaining tasks
   - `discussions`: design discussions (topic, decision, reasoning, alternatives)
@@ -71,7 +74,7 @@ Always render missing required fields as blocking errors before write.
 - **Then call `mneme_mark_session_committed`** to finalize the commit.
 
 <required>
-- Call `mneme_update_session_summary` with: `claudeSessionId`, `title`, `summary` (`goal`, `outcome`), `tags`, `sessionType`
+- Call `mneme_update_session_summary` with: `claudeSessionId`, `title`, `summary` (`goal`, `outcome`), `tags`, `sessionType`, `filesModified`, `technologies`
 - Call `mneme_mark_session_committed` AFTER `mneme_update_session_summary` succeeds
 - Do NOT skip this step even for short/research sessions
 </required>
@@ -81,6 +84,17 @@ Always render missing required fields as blocking errors before write.
 Auto-compact triggers at ~80% context window usage, replacing older messages with summaries.
 The following data is easily lost in summaries, so save it explicitly as structured data.
 
+**filesModified** — always extract when implementation occurred:
+- Extract from tool usage (Read, Edit, Write, Bash) in the conversation
+- Use relative paths from project root
+- Actions: "create" (new file), "edit" (modified), "delete" (removed), "rename" (moved)
+- Exclude: node_modules, dist, .git, lock files
+
+**technologies** — always extract:
+- List frameworks, languages, libraries actively used (not just imported)
+- Examples: "TypeScript", "React", "Hono", "SQLite", "Zod", "Tailwind CSS"
+- Keep concise: 3-10 items typical
+
 **plan** — when applicable:
 - `goals`: goals set at session start
 - `tasks`: task list. Completed: `[x] task name`, incomplete: `[ ] task name`
@@ -236,20 +250,18 @@ Recommended controlled tags:
 
 ## Validation gate (must pass)
 
-After writing sources and before rule generation, run:
+After writing sources and before rule generation, call MCP tool:
 
-```bash
-npm run validate:sources
-```
+`mneme_validate_sources`
 
-If validation fails, fix artifacts first, then continue.
+If validation fails (`valid: false`), fix artifacts first, then continue.
 
 ## Output to user
 
 Report at minimum:
 - interactions saved count
 - created/updated counts for decisions/patterns/rules
-- validation result (`validate:sources`)
+- validation result (`mneme_validate_sources`)
 - rule linter result (`mneme_rule_linter`)
 - search benchmark result (`mneme_search_eval`)
 - saved decisions/patterns/rules summary

package/skills/search/SKILL.md

@@ -28,25 +28,53 @@ Search sessions + approved units.
 /mneme:search <query> --type unit
 ```
 
-## Execution
+## Execution — Progressive Disclosure (3-Layer)
+
+Use a 3-layer progressive disclosure pattern to minimize token usage:
+
+### Layer 1: Compact Index (default)
+
+Call `mneme_search` with `detail: "compact"` (default) to get a lightweight index:
+- Returns: `id`, `title`, `score`, `matchedFields`, `tags`, `createdAt`
+- No snippet — ~50 tokens per result
+- Use this to identify relevant results quickly
+
+### Layer 2: Summary
+
+If more context is needed, call `mneme_search` with `detail: "summary"`:
+- Returns: all Layer 1 fields + `snippet`, `goal`
+- ~150 tokens per result
+
+### Layer 3: Full Details
+
+For specific items that need deep investigation:
+- `mneme_get_session({ sessionId })` — full session JSON
+- Use only for 1-2 items that are most relevant
+
+### Recommended Flow
 
 1. Call `mneme_search` with `$ARGUMENTS` as the query (or prompt user if empty).
-2. Show scored results.
-3. If response includes `page.nextOffset`, allow paging:
+2. Show compact results (Layer 1).
+3. If user wants more detail on specific items, call Layer 2 or 3.
+4. If response includes `page.nextOffset`, allow paging:
    - next call: `mneme_search({ ..., offset: page.nextOffset })`
-4. If details are needed:
-   - `mneme_get_session({ sessionId })`
-   - `mneme_get_unit({ unitId })`
 
 ### MCP examples
 
 ```typescript
+// Layer 1: Compact (default)
 mneme_search({ query: "JWT auth", limit: 10 })
-mneme_search({ query: "JWT auth", types: ["session", "unit"] })
+mneme_search({ query: "JWT auth", detail: "compact" })
+
+// Layer 2: Summary
+mneme_search({ query: "JWT auth", detail: "summary", limit: 10 })
+
+// Layer 3: Full details for a specific session
+mneme_get_session({ sessionId: "abc123" })
+
+// Pagination
 mneme_search({ query: "JWT auth", limit: 50, offset: 0 })
 mneme_search({ query: "JWT auth", limit: 50, offset: 50 })
-mneme_get_session({ sessionId: "abc123" })
-mneme_get_unit({ unitId: "mc-decision-jwt-auth-001" })
 ```
 
 ## Search targets
@@ -67,9 +95,28 @@ mneme_get_unit({ unitId: "mc-decision-jwt-auth-001" })
 - `tags`
 - `sourceType`
 
+## Query construction tips
+
+Effective queries use specific technical terms rather than natural language:
+
+| Instead of | Use |
+|-----------|-----|
+| "how did we handle auth" | "JWT authentication middleware" |
+| "that error we fixed" | "CORS preflight 403" |
+| "the refactoring we did" | "refactor session-parser" |
+| "what was decided about DB" | "SQLite WAL migration" |
+
+Best practices:
+- Use **specific technical terms**: library names, error messages, API names
+- Use **file paths**: component or module names that were modified
+- Use **error text**: paste the exact error message or key portion
+- **Combine terms**: "FTS5 tokenizer unicode61" is better than "search"
+- When the first query returns no results, try **synonyms or related terms**
+
 ## Notes
 
 - If no approved units exist, search will effectively return sessions/interactions only.
+- Stopwords (common English/Japanese words) are automatically removed from queries.
 
 ## Failure conditions
 

package/skills/using-mneme/SKILL.md

@@ -31,6 +31,17 @@ mneme is a long-term memory plugin for Claude Code.
 3. **`/mneme:save`**: writes structured metadata (decisions, patterns, rules).
 4. **SessionEnd**: finalizes session status.
 
+## When to proactively search mneme
+
+Search mneme (`/mneme:search`) when you encounter these situations during implementation:
+
+- **Recurring error**: search with the error message to find past solutions
+- **Design decision**: search with the technical topic to find prior decisions and reasoning
+- **Unfamiliar area**: search with module/file names to find sessions that worked on the same code
+- **Before refactoring**: search to understand historical context and past approaches
+
+The `<mneme-context>` block injected on each prompt provides automatic matches, but deeper search with specific technical terms often reveals more relevant context.
+
 ## Recommended workflow
 
 ```