continuous-improvement 1.0.0

package/docs/superpowers/specs/2026-04-05-mulahazah-instinct-learning-design.md

@@ -0,0 +1,636 @@
+# Mulahazah: Instinct-Based Behavioral Learning for continuous-improve
+
+**Date:** 2026-04-05
+**Status:** Design approved, pending implementation
+**Author:** Naim Katiman
+
+---
+
+## Summary
+
+Upgrade continuous-improve from a static 6-law discipline framework to a 7-law learning system. The new system (codename **Mulahazah** — Arabic for "observation") adds instinct-based behavioral learning: hooks observe every session, a background agent detects patterns, and learned instincts get stronger or weaker over time based on evidence.
+
+This is a Claude Code-only upgrade. Self-contained, no external dependencies.
+
+## Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Goal | Make continuous-improve learn | Laws should get smarter over time |
+| Relationship to ECC v2 | Fork and embed — no ECC dependency | Self-contained package, own the implementation |
+| Reflection + observation | Both layers — passive hooks + active reflection | Passive catches what you miss; active captures reasoning |
+| Confidence behavior | Graduated — silent / suggest / auto-apply | Balance between learning speed and user control |
+| Scope | Learning + project scoping | Project isolation is hard to retrofit; evolution/export later |
+| Background observer | Included from day one | Continuous pattern detection, not just on-demand |
+| Contribution target | Fork Kiyoraka/Project-AI-MemoryCore | Mulahazah as a new Feature module, complementary to Forge |
+
+---
+
+## Architecture
+
+```
++--------------------------------------------------+
+|              Claude Code Session                  |
+|                                                   |
+|  7 Laws govern behavior                           |
+|  Instincts inform decisions (graduated)           |
++------------------+-------------------------------+
+                   |
+                   v
++--------------------------------------------------+
+|       observe.sh (PreToolUse/PostToolUse)         |
+|                                                   |
+|  - Detect project (git remote -> 12-char hash)    |
+|  - Append 1 JSONL line per event (<50ms)          |
+|  - Write to projects/<hash>/observations.jsonl    |
+|  - Global fallback if no git repo                 |
++----------+----------------------+----------------+
+           |                      |
+     +-----v------+        +-----v-----------------+
+     | Background  |        | On-Demand Analysis    |
+     | Observer    |        |                       |
+     | (Haiku)     |        | - Law 5 Reflection    |
+     |             |        |   (auto, high conf.)  |
+     | Every 5min  |        | - /continuous-improve |
+     | when 20+    |        |   (user-triggered)    |
+     | obs accum.  |        |                       |
+     +-----+------+        +-----+-----------------+
+           |                      |
+           v                      v
++--------------------------------------------------+
+|              Instinct Store                       |
+|                                                   |
+|  ~/.claude/mulahazah/                             |
+|  +-- projects.json          (registry)            |
+|  +-- config.json            (observer settings)   |
+|  +-- observer.pid           (background PID)      |
+|  +-- instincts/personal/    (global instincts)    |
+|  +-- projects/<hash>/                             |
+|      +-- project.json       (metadata)            |
+|      +-- observations.jsonl (raw events)          |
+|      +-- observations.archive/ (rotated)          |
+|      +-- instincts/personal/ (project instincts)  |
+|                                                   |
+|  Confidence -> Behavior:                          |
+|  0.3-0.5  silent (stored only)                    |
+|  0.5-0.7  suggested inline                        |
+|  0.7+     auto-applied                            |
++--------------------------------------------------+
+```
+
+Three analysis channels feed one instinct store:
+1. **Background observer** (Haiku, periodic) — catches patterns continuously
+2. **Law 5 reflection** (automatic) — higher-confidence deliberate insights
+3. **`/continuous-improve`** (user-initiated) — on-demand review and analysis
+
+---
+
+## The 7 Laws
+
+Laws 1-6 remain unchanged. Law 7 is new:
+
+### Law 7: Learn From Every Session
+
+```
+Your sessions create knowledge. Capture it.
+
+- Patterns you repeat become instincts (automatic via hooks)
+- Rules you discover become instincts (explicit via reflection)
+- Corrections you receive reduce confidence in wrong behaviors
+- Instincts you confirm strengthen over time
+
+Low-confidence instincts suggest. High-confidence instincts apply.
+If the user corrects you, the instinct weakens. If they don't, it strengthens.
+
+Nothing learned is permanent. Everything decays without reinforcement.
+```
+
+**The updated loop:**
+
+```
+Research -> Plan -> Execute (one thing) -> Verify -> Reflect -> Learn -> Iterate
+```
+
+**Separation of concerns:**
+- Law 5 (Reflect) = produce the reflection block (what worked, failed, what to do differently)
+- Law 7 (Learn) = persist knowledge as instincts (observe, score, apply, decay)
+
+---
+
+## The Instinct Model
+
+Each instinct is a single YAML file:
+
+```yaml
+---
+id: prefer-grep-before-edit
+trigger: "when modifying code"
+confidence: 0.65
+domain: "workflow"
+source: "session-observation"
+scope: project
+project_id: "a1b2c3d4e5f6"
+project_name: "my-app"
+created: "2026-04-05"
+last_observed: "2026-04-05"
+---
+
+# Prefer Grep Before Edit
+
+## Action
+Always search with Grep to confirm location before using Edit.
+
+## Evidence
+- Observed 6 times in sessions on 2026-04-05
+- User corrected blind edit on 2026-04-03
+```
+
+### Properties
+
+| Field | Purpose |
+|-------|---------|
+| `id` | Unique identifier (kebab-case), used for dedup and promotion |
+| `trigger` | When the instinct is relevant — matched against current context |
+| `confidence` | Drives graduated behavior: silent (0.3-0.5), suggest (0.5-0.7), auto-apply (0.7+) |
+| `domain` | One of: `code-style`, `testing`, `git`, `debugging`, `workflow`, `security`, `architecture` |
+| `source` | How created: `session-observation` (passive), `reflection` (Law 5), `imported` |
+| `scope` | `project` (default) or `global` |
+| `project_id` | 12-char hash from git remote URL (project-scoped only) |
+| `project_name` | Human-readable project name (project-scoped only) |
+| `evidence` | What observations back this up — no raw code, only patterns |
+
+### Scope Decision
+
+| Pattern Type | Scope | Examples |
+|-------------|-------|---------|
+| Language/framework conventions | **project** | "Use React hooks", "Follow Django REST patterns" |
+| File structure preferences | **project** | "Tests in `__tests__`/", "Components in src/components/" |
+| Code style | **project** | "Use functional style", "Prefer dataclasses" |
+| Error handling strategies | **project** | "Use Result type for errors" |
+| Security practices | **global** | "Validate user input", "Sanitize SQL" |
+| General best practices | **global** | "Write tests first", "Always handle errors" |
+| Tool workflow preferences | **global** | "Grep before Edit", "Read before Write" |
+| Git practices | **global** | "Conventional commits", "Small focused commits" |
+
+**Default to `project` scope.** Promote later when pattern appears in 2+ projects.
+
+### Confidence Scoring
+
+**Initial confidence by source:**
+
+| Source | Initial Confidence |
+|--------|-------------------|
+| Observer: 1-2 observations | 0.3 |
+| Observer: 3-5 observations | 0.5 |
+| Observer: 6-10 observations | 0.7 |
+| Observer: 11+ observations | 0.85 |
+| Law 5 reflection "Rule to add" | 0.6 (boosted start) |
+
+**Confidence adjustments:**
+
+| Event | Change |
+|-------|--------|
+| Confirming observation | +0.05 |
+| User explicitly accepts suggestion | +0.15 |
+| User corrects/rejects | -0.1 |
+| Law 5 reflection matches existing instinct | +0.2 (two sources agree) |
+| No observation for 1 week | -0.02 (decay) |
+
+---
+
+## Hook System
+
+Two hooks in `~/.claude/settings.json`: `PreToolUse` and `PostToolUse`, both calling `observe.sh`.
+
+### observe.sh Contract
+
+Must complete in <50ms. Never blocks the session.
+
+```
+1. Read hook input from stdin (JSON: tool name, input/output, session ID)
+2. Detect project:
+   - $CLAUDE_PROJECT_DIR env var (highest priority)
+   - git remote get-url origin -> SHA-256 -> first 12 chars
+   - git rev-parse --show-toplevel -> SHA-256 -> first 12 chars
+   - fallback: global
+3. Append one JSONL line:
+   {
+     "ts": "2026-04-05T10:30:00Z",
+     "event": "tool_start" | "tool_complete",
+     "session": "abc123",
+     "tool": "Edit",
+     "input_summary": "<truncated to 500 chars>",
+     "output_summary": "<truncated to 200 chars>",
+     "project_id": "a1b2c3d4e5f6",
+     "project_name": "my-app"
+   }
+4. Exit 0
+```
+
+**Rules:**
+- No analysis in the hook — append only
+- Truncate input/output to keep JSONL manageable
+- Never log file contents or secrets — only tool names, patterns, summaries
+- Auto-create project directory on first observation
+- Update `projects.json` registry if new project detected
+- Rotate observations.jsonl to `observations.archive/YYYY-MM-DD.jsonl` when exceeding 10,000 lines
+
+---
+
+## Background Observer Agent
+
+A Haiku agent that runs periodically, reads observations, and creates/updates instincts.
+
+### Lifecycle
+
+```
+start-observer.sh
+  +-- observer-loop.sh (runs every 5 min)
+        +-- Check: 20+ new observations? If not, skip.
+        +-- Launch Haiku agent with observer.md prompt
+        |     +-- Read observations.jsonl
+        |     +-- Read existing instincts (project + global)
+        |     +-- Detect patterns
+        |     +-- Create/update instinct YAML files
+        |     +-- Exit
+        +-- Sleep 5 min, repeat
+```
+
+**Process management:**
+- `start-observer.sh` writes PID to `~/.claude/mulahazah/observer.pid`
+- Session guardian can auto-start if configured (`config.json: observer.enabled: true`)
+- Graceful shutdown on SIGTERM; SIGUSR1 forces immediate analysis
+
+### Pattern Detection
+
+| Pattern | Signal | Instinct Created |
+|---------|--------|-----------------|
+| User corrections | "No, use X instead" / immediate undo+redo | "When doing X, prefer Y" |
+| Error -> fix sequences | Tool error -> next tools fix it | "When error X occurs, try Y" |
+| Repeated workflows | Same tool sequence 3+ times | "When doing X, follow steps A->B->C" |
+| Tool preferences | Consistently choosing one tool over another | "For task X, use tool Y" |
+| Rejected suggestions | User declines or reverts agent output | "Don't do X in this context" |
+
+### Observer Rules
+
+- Conservative — only create instincts for 3+ observations
+- Merge similar — update existing instinct rather than duplicate
+- Default to project scope
+- Never include raw code in instincts, only patterns
+- Read existing instincts before creating — avoid contradictions
+
+### Configuration
+
+```json
+{
+  "version": "2.0",
+  "observer": {
+    "enabled": true,
+    "run_interval_minutes": 5,
+    "min_observations_to_analyze": 20,
+    "model": "haiku"
+  }
+}
+```
+
+---
+
+## Law 5 Integration
+
+Law 5 still produces the reflection block. Now it also feeds the instinct system.
+
+**Enhanced output:**
+
+```
+## Reflection
+- What worked: In-memory cache was simpler than Redis
+- What failed: nothing
+- What I'd do differently: nothing
+- Rule to add: For single-server, start with in-memory cache
+
+## Instinct created
+- id: prefer-in-memory-cache-single-server
+- confidence: 0.6 (reflection source -> boosted start)
+- scope: global (general best practice)
+```
+
+**Behavior:**
+1. Law 5 reflection fires as before (after non-trivial tasks)
+2. The "Rule to add" field is parsed into an instinct
+3. Instinct gets 0.6 starting confidence (higher than observer's 0.3)
+4. If a matching instinct already exists from passive observation, confidence gets +0.2 boost
+5. Instinct is written to the appropriate scope
+
+---
+
+## The /continuous-improve Command
+
+One master command with subcommands:
+
+```
+/continuous-improve              # Full dashboard (default)
+/continuous-improve status       # Instinct overview
+/continuous-improve projects     # List all projects
+/continuous-improve analyze      # Force analysis now
+/continuous-improve reflect      # Trigger Law 5 + Law 7 manually
+```
+
+### Default behavior (no args)
+
+Runs the full loop — ideal after shipping long code:
+
+1. **REFLECT** — Auto-generate Law 5 reflection for this session
+2. **ANALYZE** — Process pending observations, create/update instincts
+3. **STATUS** — Show current instincts dashboard
+4. **SUGGEST** — Surface actionable insights
+
+### Example output
+
+```
+=== continuous-improve ===
+
+## Reflection (Law 5)
+- What worked: TDD approach caught the auth bug early
+- What failed: First attempt at caching hit rate limit
+- What I'd do differently: Check API rate limits before choosing polling interval
+- Rule to add: Always check rate limits before setting intervals
+
+## Session Learning (Law 7)
+  NEW  prefer-tdd-for-auth       testing    0.6  (from reflection)
+  NEW  check-rate-limits-first   workflow   0.6  (from reflection)
+   ^   grep-before-edit          workflow   0.65 -> 0.70  (3 more observations)
+   ^   use-react-hooks           code-style 0.60 -> 0.65  (2 more observations)
+
+## Dashboard
+PROJECT: my-app (a1b2c3d4e5f6) -- 6 instincts
+  * [0.85] prefer-functional-style     code-style   auto-apply
+  * [0.70] grep-before-edit            workflow     auto-apply
+  * [0.65] use-react-hooks             code-style   suggest
+  * [0.60] prefer-tdd-for-auth         testing      suggest
+  * [0.60] check-rate-limits-first     workflow     suggest
+  o [0.35] prefer-barrel-exports       architecture silent
+
+GLOBAL -- 3 instincts
+  * [0.90] validate-user-input         security     auto-apply
+  o [0.45] conventional-commits        git          silent
+  o [0.40] small-focused-commits       git          silent
+
+## Suggestions
+  -> grep-before-edit crossed 0.7 -- now auto-applying
+  -> 47 unprocessed observations pending
+```
+
+---
+
+## File Structure
+
+### What ships in the continuous-improve package
+
+```
+continuous-improve/
++-- skills/
+|   +-- continuous-improve/
+|       +-- SKILL.md                 # The 7 Laws + instinct behavior
++-- hooks/
+|   +-- observe.sh                   # PreToolUse/PostToolUse hook
++-- agents/
+|   +-- observer.md                  # Background Haiku observer prompt
+|   +-- observer-loop.sh             # Periodic runner
+|   +-- start-observer.sh            # Launcher
++-- scripts/
+|   +-- install.js                   # npx continuous-improve install
++-- config.json                      # Default observer config
++-- package.json
++-- README.md
+```
+
+### Runtime directory
+
+```
+~/.claude/mulahazah/
++-- projects.json                    # Registry: hash -> name/path/remote
++-- config.json                      # Observer settings
++-- observer.pid                     # Background observer PID
++-- observations.jsonl               # Global fallback observations
++-- instincts/
+|   +-- personal/                    # Global auto-learned instincts
++-- projects/
+    +-- a1b2c3d4e5f6/
+    |   +-- project.json             # Project metadata
+    |   +-- observations.jsonl       # Project observations
+    |   +-- observations.archive/    # Rotated logs
+    |   +-- instincts/
+    |       +-- personal/            # Project-scoped instincts
+    +-- f6e5d4c3b2a1/
+        +-- ...
+```
+
+### Install flow (npx continuous-improve install --claude)
+
+1. Copy SKILL.md content -> append to CLAUDE.md
+2. Copy observe.sh -> skill-relative path
+3. Patch ~/.claude/settings.json with PreToolUse/PostToolUse hooks
+4. Create ~/.claude/mulahazah/ directory structure
+5. Copy observer agent files
+6. Write default config.json (observer.enabled: true)
+7. Print instructions for starting the background observer
+8. Print: "Installed. Run /continuous-improve after your next session."
+
+**Note:** The background observer is enabled in config but does not auto-start as a daemon. Users start it manually with `start-observer.sh` or it can be added to shell profile for auto-start. Hooks capture observations regardless of whether the observer is running — analysis just happens on-demand via `/continuous-improve` until the observer is started.
+
+---
+
+## MemoryCore Contribution Strategy
+
+After updating continuous-improve, fork Kiyoraka/Project-AI-MemoryCore and add Mulahazah as a new Feature module.
+
+### Why Mulahazah is a new feature, not a Forge duplicate
+
+| Forge | Mulahazah |
+|-------|-----------|
+| Deliberate — detects when AI/user notices a pattern | Automatic — hooks observe every session |
+| Requires 3+ occurrences + human approval | Creates tentative instincts from first sighting |
+| Creates full skills | Creates atomic instincts (smaller than skills) |
+| No confidence scoring | 0.3-0.9 confidence with decay |
+| No project isolation | Project-scoped by default |
+| No background processing | Background Haiku observer |
+
+**Forge = conscious skill creation.** "I noticed I keep doing X, let me make a skill."
+**Mulahazah = unconscious behavioral adaptation.** The system quietly learns preferences.
+
+### Synergy with existing MemoryCore features
+
+| Feature | Integration |
+|---------|------------|
+| Forge | High-confidence instinct clusters become Forge proposals |
+| Observation System | Mulahazah feeds instincts into Refine quality checks |
+| Decision Log | Instinct promotions logged as decisions |
+| Save Diary | Session learning summary in diary entries |
+| Memory Consolidation | Instincts as a new memory type |
+
+### MemoryCore file structure
+
+```
+Feature/Mulahazah-System/
++-- README.md
++-- SKILL.md
++-- install-mulahazah.md
++-- hooks/
+|   +-- observe.sh
++-- agents/
+|   +-- observer.md
+|   +-- observer-loop.sh
+|   +-- start-observer.sh
++-- config.json
+```
+
+---
+
+## Competitive Landscape: Observation & Learning Systems
+
+### Comparison Matrix
+
+| System | Observation Method | Learning Unit | Confidence | Project Scope | Background | Daily Workflow Fit |
+|--------|-------------------|---------------|------------|---------------|------------|-------------------|
+| **Mulahazah** | PreToolUse/PostToolUse hooks (100%) | Atomic instinct (YAML) | 0.3-0.9, decays | Yes (hash-based) | Haiku observer | One command: `/continuous-improve` |
+| **MemoryCore Forge** | Skill-triggered (~50-80%) | Full skill (SKILL.md) | None | No | No | Manual: "create skill", "forge this" |
+| **MemoryCore Observation** | On-demand (user triggers) | Report (no persistence) | None | No | No | Manual: "survey", "investigate" |
+| **Homunculus v2** | PreToolUse/PostToolUse hooks (100%) | Instinct (YAML) | 0.3-0.9 weighted | Yes (v2.1) | Haiku observer | CLI commands |
+| **ECC continuous-learning v1** | Stop hook (session end) | Skill file | None | No | No | `/learn` at milestones |
+| **ECC continuous-learning v2** | Hooks (100%) | Instinct (YAML) | 0.3-0.9 | Yes (v2.1) | Haiku observer | 6 commands |
+| **Claude Code auto-memory** | Built-in (always on) | Memory file (.md) | None | Yes (project dirs) | No | Automatic, no command |
+| **Cursor .cursorrules** | None (static) | Rule file | None | Yes (per-project) | No | Manual edits |
+| **Windsurf Memories** | Session end | Memory entry | None | No | No | Automatic |
+| **Aider conventions** | None (static) | .aider.conf.yml | None | Yes (per-project) | No | Manual edits |
+
+### What Mulahazah does differently
+
+1. **100% observation + graduated behavior** — no other system combines deterministic hook capture with confidence-based application. Claude's auto-memory captures facts but doesn't score or decay them. Forge requires human recognition of patterns.
+
+2. **Three learning channels** — passive (hooks), active (reflection), manual (command). Other systems have one channel at most.
+
+3. **Confidence decay** — instincts weaken without reinforcement. No other system models forgetting. This prevents stale rules from accumulating indefinitely.
+
+4. **One master command** — `/continuous-improve` replaces the fragmented command surfaces of ECC v2 (6 commands) and MemoryCore (per-feature commands).
+
+### Gaps to close (future roadmap)
+
+| Gap | What's Missing | When |
+|-----|---------------|------|
+| Forge integration | Instinct clusters don't auto-propose Forge skills yet | v2.1 |
+| Team sharing | No export/import of instinct libraries across developers | v2.2 |
+| IDE integration | No VS Code/JetBrains panel showing active instincts | v2.3 |
+| Cross-agent | Only Claude Code — no Codex, Cursor, Aider support | v3.0 |
+| Analytics | No dashboard showing learning velocity, instinct health over time | v2.2 |
+
+---
+
+## Daily Workflow Integration
+
+The system must disappear into the developer's natural rhythm — not add ceremony.
+
+### The Natural Developer Loop
+
+```
+Morning: open project, start coding
+  |
+  |  Hooks silently capture every tool call (zero friction)
+  |  High-confidence instincts auto-apply (invisible)
+  |  Medium instincts suggest inline (gentle nudges)
+  |
+Midday: finish a feature or fix
+  |
+  |  Law 5 reflection fires automatically
+  |  "Rule to add" becomes an instinct (0.6 confidence)
+  |  Background observer processes pending observations
+  |
+End of session: run /continuous-improve
+  |
+  |  See what the system learned today
+  |  Review new instincts, confirm or correct
+  |  Dashboard shows confidence changes
+  |
+Next day: instincts from yesterday inform today's work
+```
+
+### Zero-Friction Integration Points
+
+| Developer Action | Mulahazah Behavior | Friction |
+|-----------------|-------------------|---------|
+| Write code normally | Hooks capture tool usage silently | **Zero** — hooks run in <50ms |
+| Make a mistake, get corrected | Instinct created: "don't do X" | **Zero** — automatic |
+| Repeat a workflow 3+ times | Instinct created: "when X, do Y->Z" | **Zero** — observer detects |
+| Finish a task | Law 5 reflection, instinct from "Rule to add" | **Low** — reflection is already part of the 6 Laws |
+| End a long session | Run `/continuous-improve` | **Low** — one command, full picture |
+| Start a new project | Project auto-detected from git remote | **Zero** — hash-based isolation |
+| Switch between projects | Correct instincts load per-project | **Zero** — automatic scoping |
+
+### Anti-Patterns to Avoid
+
+| Anti-Pattern | Why It Kills Adoption | How Mulahazah Avoids It |
+|-------------|----------------------|------------------------|
+| Requiring manual tagging | Developers won't tag consistently | Hooks auto-capture, observer auto-analyzes |
+| Too many commands to remember | Cognitive overhead | One command: `/continuous-improve` |
+| Noisy suggestions | Alert fatigue | Graduated: silent until 0.5, suggest until 0.7, then auto-apply |
+| Learning that never applies | "What's the point?" | Auto-apply at 0.7+ means instincts visibly change behavior |
+| No way to correct bad learning | Frustration, distrust | User corrections reduce confidence by -0.1; decay removes stale instincts |
+| Cross-project contamination | React rules breaking Python | Project-scoped by default |
+| Slow hooks | Breaks flow | <50ms, append-only, no analysis in hook |
+
+### Adoption Ladder
+
+```
+Level 0: Install
+  - npx continuous-improve install --claude
+  - Hooks start capturing immediately
+  - No behavior change yet — just observation
+
+Level 1: Passive Learning (Week 1)
+  - Observer creates first instincts
+  - All below 0.5 — silent, no suggestions
+  - Developer doesn't notice anything different
+  - /continuous-improve shows what's been learned
+
+Level 2: Suggestions (Week 2-3)
+  - Instincts cross 0.5 from repeated observations
+  - Inline suggestions appear: "Consider using Grep before Edit"
+  - Developer confirms or corrects — confidence adjusts
+
+Level 3: Auto-Apply (Month 1+)
+  - Strongest instincts cross 0.7
+  - Agent behavior subtly adapts without prompting
+  - "It just knows how I work now"
+  - /continuous-improve shows a mature instinct library
+
+Level 4: Cross-Project (Month 2+)
+  - Same patterns seen in multiple projects
+  - Global instincts emerge naturally
+  - New projects start with a baseline of learned behavior
+```
+
+### Measuring Success
+
+How a developer knows Mulahazah is working:
+
+| Signal | Metric |
+|--------|--------|
+| Fewer corrections needed | User correction events decrease over time |
+| Faster sessions | Time-to-completion for similar tasks decreases |
+| Instinct library grows | `/continuous-improve` shows 10+ instincts after 2 weeks |
+| Auto-apply instincts exist | At least 3 instincts at 0.7+ confidence after 1 month |
+| Cross-project learning | Global instincts emerge from 2+ projects |
+
+---
+
+## Out of Scope (v1)
+
+- Instinct evolution into full skills/commands/agents (future v2.1)
+- Export/import instincts (future v2.2)
+- `/promote` command for project->global promotion (future v2.1)
+- `/evolve` command for clustering instincts (future v2.1)
+- Integration with OpenClaw memory-core-plus (different platform)
+- Inherited instinct libraries (future v2.2)
+- Cross-machine instinct sync (future v2.2)
+- IDE panel for instinct visibility (future v2.3)
+- Analytics dashboard (future v2.2)
+- Multi-agent support beyond Claude Code (future v3.0)