metame-cli 1.4.33 → 1.5.0

package/README.md

@@ -24,7 +24,7 @@ No cloud. Your machine, your data.
 curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bash
 ```
 
-**Already have Node.js ≥ 18:**
+**Already have Node.js ≥ 22.5:**
 ```bash
 npm install -g metame-cli
 metame
@@ -38,13 +38,22 @@ metame
 
 ---
 
-> ### 🚀 v1.4.19 — Multi-User ACL + Session Context Preview
+> ### 🚀 v1.4.34 — Mentor Mode Step 4 + Distiller/Memory Closed Loop
 >
-> - **Multi-user permission system**: role-based ACL (admin / member / stranger) — share your bots with teammates without giving them full access. Manage users with `/user` commands.
-> - **Session context preview**: `/resume` and `/sessions` now show the last message snippet so you know exactly what to pick up.
-> - **Team Task protocol**: multi-agent task board for cross-agent collaboration. Agents can dispatch and track tasks across workspaces.
-> - **Layered Memory Architecture**: three-layer memory (long-term facts, session summaries, session index) — all automatic.
-> - **Unix Socket IPC**: dispatch latency <100ms.
+> - **Multi-engine runtime adapter (MVP)**: daemon now supports engine routing by project (`project.engine`) with shared execution flow for Claude/Codex.
+> - **Codex session continuity**: supports `exec`/`resume`, thread id backfill, one-shot resume fallback (max once per 10 minutes per chat), and auth/rate-limit error mapping.
+> - **Agent engine inference**: natural-language agent creation can infer `codex`; default `claude` keeps zero-regression (no `engine` field persisted).
+> - **6-dimension soul schema**: cognitive profile upgraded from key-value pairs to a structured 67-field model covering Values, Drive, Cognition Style, Stress & Shadow, Relational, and Identity Narrative — with tier-based lock protection.
+> - **Mentor mode hooks**: pre-flight emotion breaker, context-time mentor prompt, and post-flight reflection debt registration are wired into daemon flow.
+> - **Distiller Step 4**: competence signals now merge into `user_competence_map` (upgrade-by-default, downgrade only with explicit evidence).
+> - **Memory extraction labels**: `memory-extract` writes concept labels into `fact_labels` (linked by fact id from `saveFacts().savedFacts`).
+> - **Nightly closed loop**: nightly reflection writes back `synthesized_insight` facts and generates `knowledge_capsule` documents + facts.
+> - **Postmortem artifacts**: significant sessions now produce `postmortem` markdown and `bug_lesson` facts.
+> - **Memory index**: auto-generated global index of all memory documents for instant retrieval.
+> - **Auto-provisioning**: first run automatically deploys default CLAUDE.md, docs, and `dispatch_to` — zero manual setup.
+> - **Token budget tracking**: daily token usage monitoring with per-category breakdown and 80% warning threshold.
+> - **Multi-user ACL**: role-based permissions (admin / member / stranger) with binding protection.
+> - **Windows native support**: cross-platform path handling, Named Pipes IPC, GBK-safe encoding.
 >
 > Zero configuration. It just works.
 
@@ -56,7 +65,9 @@ metame
 
 Claude Code forgets you every time you switch folders. MetaMe doesn't.
 
-A cognitive profile (`~/.claude_profile.yaml`) follows you everywhere — not just facts like "user prefers TypeScript", but *how you think*: your decision style, cognitive load preferences, communication patterns. It learns silently from your conversations via background distillation, no effort required.
+A cognitive profile (`~/.claude_profile.yaml`) follows you everywhere — not just facts like "user prefers TypeScript", but *how you think*. The profile is built on a **6-dimension soul schema**: Values, Drive, Cognition Style, Stress & Shadow, Relational, and Identity Narrative — 67 fields organized into 4 tiers (T1 locked identity → T5 system-managed evolution). First-time users go through a **Genesis Interview**: a structured deep conversation that builds your cognitive fingerprint from scratch.
+
+Once established, the profile updates silently from your conversations via background distillation — no effort required.
 
 ```
 $ metame
@@ -65,9 +76,10 @@ $ metame
 Link Established. What are we building?
 ```
 
-### 2. Full Claude Code From Your Phone
+### 2. Full Claude/Codex Sessions From Your Phone
 
-Your Mac runs a daemon. Your phone sends messages via Telegram or Feishu. Same Claude Code engine — same tools, same files, same session.
+Your Mac runs a daemon. Your phone sends messages via Telegram or Feishu.
+Engine is selected per project (`project.engine: claude|codex`) — same tools, same files, same session continuity.
 
 ```
 You (phone):  Fix the auth bug in api/login.ts
@@ -80,10 +92,10 @@ Start on your laptop, continue on the train. `/stop` to interrupt, `/undo` to ro
 
 ### 3. Layered Memory That Works While You Sleep
 
-MetaMe's memory system runs automatically in the background — no prompts, no manual saves.
+MetaMe's memory system runs automatically in the background — no prompts, no manual saves. Five layers, fully autonomous.
 
 **Layer 1 — Long-term Facts**
-When you go idle, MetaMe runs memory consolidation: extracts key decisions, patterns, and knowledge from your sessions into a persistent facts store. These are semantically recalled on every session start.
+When you go idle, MetaMe runs memory consolidation: extracts key decisions, patterns, and knowledge from your sessions into a persistent facts store. Facts can also carry concept labels (`fact_labels`) for faster cross-domain retrieval.
 
 **Layer 2 — Session Continuity**
 Resuming a conversation after 2+ hours? MetaMe injects a brief summary of what you were working on last time — so you pick up where you left off without re-explaining context.
@@ -91,12 +103,20 @@ Resuming a conversation after 2+ hours? MetaMe injects a brief summary of what y
 **Layer 3 — Session Index**
 Every session gets tagged with topics and intent. This powers future session routing: when you reference "that thing we worked on last week", MetaMe knows where to look.
 
+**Layer 4 — Nightly Reflection**
+Every night at 01:00, MetaMe reviews your most-accessed facts from the past week and distills them into high-level decision logs and operational lessons. Distilled outputs are also written back to `memory.db` as `synthesized_insight`, enabling retrieval in future sessions.
+
+**Layer 5 — Memory Index**
+At 01:30, an auto-generated global index (`INDEX.md`) maps every memory document across all categories (including capsules and postmortems). This serves as a fast lookup table so MetaMe always knows where to find relevant context.
+
 ```
 [Background, while you sleep]
 idle 30min → memory consolidation triggered
   → session_tags.json updated (topics indexed)
   → facts extracted → ~/.metame/memory.db
   → session summary cached → daemon_state.json
+01:00 → nightly reflection: hot facts → decisions + lessons
+01:30 → memory index regenerated
 
 [Next morning, when you resume]
 "continue from yesterday" →
@@ -117,12 +137,14 @@ Built into the daemon. Runs every 60 seconds regardless of what's in your config
 - Detects when you go idle → generates session continuity summaries
 
 **Layer 1 — System Evolution (built-in defaults)**
-Three tasks shipped out of the box. They are precondition-gated and run only when useful:
+Five tasks shipped out of the box. They are precondition-gated and run only when useful:
 
 ```yaml
 - cognitive-distill   # 4h · has signals? → distill preferences into profile
-- memory-extract      # 4h · scan sessions → extract long-term facts + topic tags
+- memory-extract      # 4h · scan sessions → extract long-term facts + concept labels
 - skill-evolve        # 6h · has signals? → evolve skills from task outcomes
+- nightly-reflect     # 01:00 daily · hot facts → decisions/lessons + synthesized facts + capsules
+- memory-index        # 01:30 daily · regenerate global memory index
 ```
 
 `precondition` guards mean zero tokens burned when there's nothing to process.
@@ -181,18 +203,19 @@ Chain skills into multi-step workflows — research → write → publish — fu
 
 ### 5. Skills That Evolve Themselves
 
-MetaMe has a living skill ecosystem. Skills aren't static configs — they grow.
+MetaMe's current skill loop is queue-driven and reviewable (not magic black-box automation).
 
-- **Auto-discovery**: When a task fails or a capability is missing, MetaMe's skill-scout automatically searches for, installs, and verifies new skills.
-- **Learning by watching**: Can't automate a complex browser workflow? Say "我来演示" and MetaMe records your actions, then converts them into a reusable skill.
-- **Post-task evolution**: After every significant task, the skill-evolution-manager reviews what worked and what didn't, then surgically updates the relevant skills with new knowledge.
-- **Composable**: Skills chain together in workflows. A `deep-research` skill feeds into `tech-writing`, which feeds into `wechat-publisher` — each one improving from real usage.
+- **Signal capture**: task outcomes and failures are captured into evolution signals.
+- **Hot/cold evolution**: `skill-evolution` runs on task hot path and heartbeat cold path.
+- **Workflow proposals**: repeated multi-tool patterns are merged into workflow sketches and queued as proposals.
+- **Human approval gate**: review and operate with `/skill-evo list`, `/skill-evo approve <id>`, `/skill-evo done <id>`, `/skill-evo dismiss <id>`.
+- **Skill manager fallback**: when capability is missing, runtime routes to `skill-manager` skill guidance instead of blind guessing.
 
 ```
-Task fails → skill-scout finds a skill → installs → retries → succeeds
-                                                      ↓
-                                      skill-evolution-manager
-                                      updates skill with lessons learned
+task outcome/failure → skill signal buffer
+                     → hot/cold evolution
+                     → proposal queue
+                     → /skill-evo approve|done|dismiss
 ```
 
 ---
@@ -203,19 +226,21 @@ Task fails → skill-scout finds a skill → installs → retries → succeeds
 curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bash
 ```
 
-**Already have Node.js ≥ 18:**
+**Already have Node.js ≥ 22.5:**
 ```bash
 npm install -g metame-cli
 metame
 ```
 
+> **First run auto-provisioning:** MetaMe automatically deploys a default `CLAUDE.md`, documentation files, and the `dispatch_to` tool to `~/.metame/`. No manual setup needed.
+
 **Setup guide (3 minutes):**
 
 | Step | What to do | What happens |
 |------|-----------|-------------|
-| 1. Log in to Claude | Run `claude` and complete the login (Anthropic account or API key) | Claude Code is ready to use |
-| 2. Launch MetaMe | Run `metame` | Opens a Claude session with MetaMe loaded |
-| 3. Cognitive interview | Just chat — MetaMe will automatically start a deep interview on first run | Builds `~/.claude_profile.yaml` (your digital twin's brain) |
+| 1. Log in to your engine | Run `claude` (Claude user) or `codex login` (Codex user) | Your local CLI engine is ready |
+| 2. Launch MetaMe | Run `metame` (Claude) or `metame codex` (Codex) | Opens a MetaMe-initialized session |
+| 3. Genesis Interview | Just chat — MetaMe will automatically start a deep soul interview on first run | Builds `~/.claude_profile.yaml` (6-dimension cognitive profile) |
 | 4. Connect phone | Say "help me set up mobile access" or "connect my phone" | Interactive wizard for Telegram/Feishu bot setup → `~/.metame/daemon.yaml` |
 | 5. Start daemon | `metame start` | Background daemon launches, bot goes online |
 | 6. Register with system | macOS: `metame daemon install-launchd` · Windows: `metame daemon install-task-scheduler` · Linux: see below | Always-on, crash recovery |
@@ -227,6 +252,68 @@ metame
 npm install -g metame-cli
 ```
 
+### Install Path By User Type
+
+**Claude Code only (plugin path, one-liner):**
+```bash
+claude plugin install github:Yaron9/MetaMe/plugin
+```
+
+**Claude Code only (npm CLI path, one-liner):**
+```bash
+npm install -g @anthropic-ai/claude-code metame-cli && claude && metame
+```
+
+**Codex only (CLI path, one-liner):**
+```bash
+npm install -g @openai/codex metame-cli && codex login && metame codex
+```
+
+**Claude + Codex (one-liner):**
+```bash
+npm install -g @anthropic-ai/claude-code @openai/codex metame-cli
+```
+
+Then run `claude` once (Claude login), `codex login` once (Codex login), and use:
+- `metame` for Claude
+- `metame codex` for Codex
+
+> `metame-cli` is engine-agnostic. It does not bundle Claude or Codex.  
+> You install the engine(s) separately, and MetaMe routes/launches them.
+
+### Install FAQ
+
+- **Does Claude plugin mode support daemon + phone access?** Yes. Plugin mode can start the daemon (via `SessionStart` after `daemon.yaml` exists), and phone access works while the daemon is running.
+- **Does `npm install -g metame-cli` install Claude or Codex?** No. It only installs MetaMe. Install `@anthropic-ai/claude-code` and/or `@openai/codex` separately.
+- **If I only install one engine, does MetaMe still work?** Yes. MetaMe will run on the installed engine. `/doctor` marks the non-default missing engine as warning, not hard failure.
+
+### Uninstall (CLI Path)
+
+```bash
+metame stop
+npm uninstall -g metame-cli
+```
+
+Codex-only cleanup:
+```bash
+npm uninstall -g metame-cli @openai/codex
+```
+
+Claude-only cleanup:
+```bash
+npm uninstall -g metame-cli @anthropic-ai/claude-code
+```
+
+Optional data cleanup:
+```bash
+rm -rf ~/.metame ~/.claude_profile.yaml
+```
+
+Optional service cleanup:
+- macOS: `launchctl bootout gui/$(id -u) ~/Library/LaunchAgents/com.metame.daemon.plist && rm -f ~/Library/LaunchAgents/com.metame.daemon.plist`
+- Windows: `schtasks /delete /tn "MetaMe-Daemon" /f`
+- Linux/WSL(systemd): `systemctl --user disable --now metame && rm -f ~/.config/systemd/user/metame.service`
+
 > **What does system registration mean?**
 > Once registered, MetaMe runs in the background automatically — screen locked, lid closed, woken from sleep — as long as the machine is on. Scheduled tasks fire on time. No terminal window needed.
 
@@ -281,16 +368,19 @@ systemctl --user start metame
 
 | Capability | What It Does |
 |-----------|-------------|
-| **Cognitive Profile** | Learns how you think across sessions. Schema-enforced, 800-token budget, auto-distilled via Haiku. Lock any value with `# [LOCKED]`. |
-| **Layered Memory** | Three-tier memory: long-term facts (semantic recall), session summaries (continuity bridge), session index (topic tags). All automatic. |
-| **Mobile Bridge** | Full Claude Code via Telegram/Feishu. Stateful sessions, file transfer both ways, real-time streaming status. |
-| **Skill Evolution** | Self-healing skill system. Auto-discovers missing skills, learns from browser recordings, evolves after every task. Skills get smarter over time. |
-| **Heartbeat System** | Three-layer programmable nervous system. Layer 0 kernel always-on (zero config). Layer 1 system evolution built-in (distill + memory + skills). Layer 2 your custom scheduled tasks with `require_idle`, `precondition`, `notify`, workflows. |
+| **Cognitive Profile** | 6-dimension soul schema (Values, Drive, Cognition Style, Stress & Shadow, Relational, Identity Narrative). 67 fields, tier-locked, 800-token budget. First-time Genesis Interview builds your profile from scratch. |
+| **Layered Memory** | Five-tier memory: long-term facts (+ concept labels), session summaries (continuity bridge), session index (topic tags), nightly reflection (distill + write-back), memory index (global lookup). All automatic. |
+| **Mobile Bridge** | Full Claude/Codex via Telegram/Feishu. Stateful sessions, file transfer both ways, real-time streaming status. |
+| **Skill Evolution** | Queue-driven skill evolution: captures task signals, generates workflow proposals, and supports explicit approval/resolve via `/skill-evo` commands. |
+| **Token Budget** | Daily token usage tracking with per-category breakdown. Configurable daily limit, automatic 80% warning threshold, usage history with rollover. |
+| **Auto-Provisioning** | First run deploys default CLAUDE.md, documentation, and `dispatch_to` to `~/.metame/`. Subsequent runs sync scripts without overwriting user config. |
+| **Heartbeat System** | Three-layer programmable nervous system. Layer 0 kernel always-on (zero config). Layer 1 system evolution built-in (5 tasks: distill + memory + skills + nightly reflection + memory index). Layer 2 your custom scheduled tasks with `require_idle`, `precondition`, `notify`, workflows. |
 | **Multi-Agent** | Multiple projects with dedicated chat groups. `/agent bind` for one-tap setup. True parallel execution. |
 | **Browser Automation** | Built-in Playwright MCP. Browser control out of the box for every user. |
 | **Cross-Platform** | Native support for macOS and Windows. Platform abstraction layer handles spawn, IPC, process management, and terminal encoding automatically. |
 | **Provider Relay** | Route through any Anthropic-compatible API. Use GPT-4, DeepSeek, Gemini — zero config file mutation. |
 | **Metacognition** | Detects behavioral patterns (decision style, comfort zones, goal drift) and injects mirror observations. Zero extra API cost. |
+| **Mentor Mode** | `/mentor on|off|level|status` controls friction mode. Emotion breaker, zone-adaptive mentor prompts, and reflection debt run as optional hooks. |
 | **Multi-User ACL** | Role-based permission system (admin / member / stranger). Share bots with teammates safely. Dynamic user management via `/user` commands with hot-reload config. |
 | **Team Task** | Multi-agent task board for cross-agent collaboration. Agents can create, assign, and track tasks across workspaces. N-agent session scoping for parallel team workflows. |
 | **Emergency Tools** | `/doctor` diagnostics, `/mac` macOS control helpers, `/sh` raw shell, `/fix` config restore, `/undo` git-based rollback. |
@@ -399,6 +489,9 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | `/undo <hash>` | Roll back to a specific git checkpoint |
 | `/list` | Browse & download project files |
 | `/model` | Switch model (sonnet/opus/haiku) |
+| `/engine` | Show/switch default engine (`claude`/`codex`) |
+| `/distill-model` | Show/update background distill model (default: `haiku`) |
+| `/mentor` | Mentor mode control: on/off/level/status |
 | `/activate` | Activate and bind the most recently created pending agent in a new group |
 | `/agent bind <name> [dir]` | Manually register group as dedicated agent |
 | `/mac` | macOS control helper: permissions check/open + AppleScript/JXA execution |
@@ -416,6 +509,34 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | `/teamtask <task_id>` | View task detail |
 | `/teamtask resume <task_id>` | Resume a task |
 
+## Mentor Mode (Why + How)
+
+Mentor Mode is designed for users who want MetaMe to actively improve decision quality, not just execute commands.
+
+- `/mentor on` — enable mentor hooks
+- `/mentor off` — disable mentor hooks
+- `/mentor level <0-10>` — set friction level
+- `/mentor status` — show current mode/level
+
+Runtime behavior:
+- Pre-flight emotion breaker (cooldown-aware)
+- Context-time mentor prompts (zone-aware: comfort/stretch/panic)
+- Reflection debt registration on heavy code outputs (intense mode)
+
+Level mapping:
+- `0-3` → `gentle`
+- `4-7` → `active`
+- `8-10` → `intense`
+
+## Hook Optimizations (Default On)
+
+MetaMe installs and maintains two core Claude hooks automatically on launch:
+
+- `UserPromptSubmit` hook (`scripts/signal-capture.js`): captures high-signal preference/task traces with layered filtering.
+- `Stop` hook (`scripts/hooks/stop-session-capture.js`): records session-end/tool-failure signals with watermark protection.
+
+If hook installation fails, MetaMe logs and continues the session (non-blocking fallback).
+
 ## How It Works
 
 ```
@@ -424,32 +545,46 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 └─────────────┘                           │   (your machine, 24/7)       │
                                           │                              │
                                           │   ┌──────────────┐           │
-                                          │   │ Claude Code   │           │
-                                          │   │ (same engine) │           │
+                                          │   │ Claude/Codex  │           │
+                                          │   │ (same runtime)│           │
                                           │   └──────────────┘           │
                                           │                              │
                                           │   ~/.claude_profile          │
-                                          │   (cognitive layer)          │
+                                          │   (6-dim soul schema)        │
                                           │                              │
                                           │   ~/.metame/memory.db        │
                                           │   session_tags.json          │
-                                          │   (memory layer)  ← NEW      │
+                                          │   (5-layer memory)           │
+                                          │                              │
+                                          │   dispatch_to (auto-deployed)│
                                           └──────────────────────────────┘
                                                        ↑
-                                          idle mode → summaries + background memory tasks
-                                                      (automatic, precondition-gated)
+                                          idle → summaries + memory tasks
+                                          01:00 → nightly reflection
+                                          01:30 → memory index rebuild
 ```
 
-- **Profile** (`~/.claude_profile.yaml`): Your cognitive fingerprint. Injected into every Claude session via `CLAUDE.md`.
-- **Daemon** (`scripts/daemon.js`): Background process handling Telegram/Feishu messages, heartbeat tasks, Unix socket dispatch, and idle/sleep transitions.
-- **Distillation** (`scripts/distill.js`): Heartbeat task (default 4h, signal-gated) that updates your profile.
-- **Memory Extract** (`scripts/memory-extract.js`): Heartbeat task (default 4h, idle-gated) that extracts long-term facts and session topic tags.
-- **Session Summarize** (`scripts/session-summarize.js`): Generates a 2-4 sentence summary for idle sessions. Injected as context when resuming after a 2h+ gap.
+- **Profile** (`~/.claude_profile.yaml`): 6-dimension soul schema. Injected into every Claude session via `CLAUDE.md`.
+- **Daemon**: Background process handling Telegram/Feishu messages, heartbeat tasks, Unix socket dispatch, and idle/sleep transitions.
+- **Runtime Adapter** (`scripts/daemon-engine-runtime.js`): normalizes engine args/env/event parsing across Claude/Codex.
+- **Distillation**: Heartbeat task (4h, signal-gated) that updates your cognitive profile, merges competence signals, and emits postmortems for significant sessions.
+- **Memory Extract**: Heartbeat task (4h, idle-gated) that extracts long-term facts, then writes concept labels (`fact_labels`) linked by fact id.
+- **Nightly Reflection**: Daily at 01:00. Distills hot-zone facts into decision logs/lessons, writes back `synthesized_insight`, and generates knowledge capsules.
+- **Memory Index**: Daily at 01:30. Regenerates the global memory index for fast retrieval.
+- **Session Summarize**: Generates a brief summary for idle sessions. Injected as context when resuming after a 2h+ gap.
+
+## Scripts Docs Pointer Map
+
+Use `scripts/docs/pointer-map.md` as the source-of-truth map for script entry points and Step 1-4 landing zones (`session-analytics` / `mentor-engine` / `daemon-claude-engine` / `distill` / `memory-extract` / `memory-nightly-reflect`).
+
+For day-2 operations and troubleshooting (engine routing, codex login/rate-limit, compact boundary), use `scripts/docs/maintenance-manual.md`.
 
 ## Security
 
 - All data stays on your machine. No cloud, no telemetry.
 - `allowed_chat_ids` whitelist — new groups get a smart prompt: if a pending agent activation exists, they're guided to send `/activate`; otherwise they receive setup instructions.
+- **Multi-user ACL**: role-based permissions (admin / member / stranger). Admins manage access via `/user` commands with hot-reload config.
+- **Binding protection**: each group can only be bound to one agent. Existing bindings cannot be overwritten without explicit `force:true`.
 - `operator_ids` for shared groups — non-operators get read-only mode.
 - `~/.metame/` directory is mode 700.
 - Bot tokens stored locally, never transmitted.
@@ -460,13 +595,13 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 |--------|-------|
 | Daemon memory (idle) | ~100 MB RSS — standard Node.js process baseline |
 | Daemon CPU (idle, between heartbeats) | ~0% — event-loop sleeping |
-| Cognitive profile injection | ~600 tokens/session (0.3% of 200k context) |
+| Cognitive profile injection | ~800 tokens/session (0.4% of 200k context) |
 | Dispatch latency (Unix socket) | <100ms |
 | Memory consolidation (per session) | ~1,500–2,000 tokens input + ~50–300 tokens output (Haiku) |
-| Session summary (per session) | ~400–900 tokens input + ≤250 tokens output (Haiku) |
+| Session summary (per session) | ~400–900 tokens input + ≤250 tokens output (distill model configurable) |
 | Mobile commands (`/stop`, `/list`, `/undo`) | 0 tokens |
 
-> Both memory consolidation and session summarization run in the background via Haiku (`--model haiku`). Input is capped by code: skeleton text ≤ 3,000 chars, summary output ≤ 500 chars. Neither runs per-message — memory consolidation follows heartbeat schedule with idle/precondition guards, and summaries trigger once per idle session on sleep-mode transitions.
+> Memory consolidation and session summarization run in the background via the configured distill model (`/distill-model`, default `haiku`). Input is capped by code: skeleton text ≤ 3,000 chars, summary output ≤ 500 chars. Neither runs per-message — memory consolidation follows heartbeat schedule with idle/precondition guards, and summaries trigger once per idle session on sleep-mode transitions.
 
 ## Plugin
 
@@ -478,9 +613,13 @@ claude plugin install github:Yaron9/MetaMe/plugin
 
 Includes: cognitive profile injection, daemon (Telegram/Feishu), heartbeat tasks, layered memory, all mobile commands, slash commands (`/metame:evolve`, `/metame:daemon`, `/metame:refresh`, etc.).
 
-**One key difference from the npm CLI:** the plugin daemon starts when you open Claude Code and stops when you close it. It does not run 24/7 in the background. For always-on mobile access (receiving messages while Claude Code is closed), use the npm CLI with `metame daemon install-launchd`.
+**Current behavior (code-aligned):**
+- Plugin auto-starts daemon on Claude `SessionStart` (if `~/.metame/daemon.yaml` exists).
+- Daemon runs detached; phone access works while daemon is running.
+- Plugin path does **not** auto-register OS service (launchd/task-scheduler/systemd). After reboot, open Claude once or run daemon start manually.
 
-Use the plugin if you prefer not to install a global npm package and only need mobile access while Claude Code is open. Use the npm CLI (`metame-cli`) for 24/7 daemon, the `metame` command, and first-run interview.
+Use the plugin if you want zero npm-global setup and Claude-integrated bootstrap.  
+Use npm CLI (`metame-cli`) if you want explicit system-service management and CLI-first operations.
 
 ## Contributing