metame-cli 1.4.34 → 1.5.0

package/README.md

@@ -38,10 +38,17 @@ metame
 
 ---
 
-> ### 🚀 v1.4.33 — 6-Dimension Soul Schema + Nightly Reflection + Auto-Provisioning
+> ### 🚀 v1.4.34 — Mentor Mode Step 4 + Distiller/Memory Closed Loop
 >
+> - **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.
-> - **Nightly reflection**: every night, hot-zone facts are distilled into searchable decision logs and lessons learned.
+> - **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.
@@ -69,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
@@ -87,7 +95,7 @@ Start on your laptop, continue on the train. `/stop` to interrupt, `/undo` to ro
 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.
@@ -96,10 +104,10 @@ Resuming a conversation after 2+ hours? MetaMe injects a brief summary of what y
 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 — searchable documents that grow your personal knowledge base over time.
+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. This serves as a fast lookup table so MetaMe always knows where to find relevant context.
+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]
@@ -133,9 +141,9 @@ Five tasks shipped out of the box. They are precondition-gated and run only when
 
 ```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 → decision logs + lessons learned
+- nightly-reflect     # 01:00 daily · hot facts → decisions/lessons + synthesized facts + capsules
 - memory-index        # 01:30 daily · regenerate global memory index
 ```
 
@@ -195,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
 ```
 
 ---
@@ -229,8 +238,8 @@ metame
 
 | 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 |
+| 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 |
@@ -243,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.
 
@@ -298,9 +369,9 @@ systemctl --user start metame
 | Capability | What It Does |
 |-----------|-------------|
 | **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 (semantic recall), session summaries (continuity bridge), session index (topic tags), nightly reflection (decision/lesson distillation), memory index (global lookup). 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. |
+| **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. |
@@ -309,6 +380,7 @@ systemctl --user start metame
 | **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. |
@@ -417,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 |
@@ -434,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
 
 ```
@@ -442,8 +545,8 @@ 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          │
@@ -463,12 +566,19 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 
 - **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.
-- **Distillation**: Heartbeat task (4h, signal-gated) that updates your cognitive profile.
-- **Memory Extract**: Heartbeat task (4h, idle-gated) that extracts long-term facts and session topic tags.
-- **Nightly Reflection**: Daily at 01:00. Distills hot-zone facts into decision logs and operational lessons.
+- **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.
@@ -488,10 +598,10 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | 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
 
@@ -503,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
 

package/index.js

@@ -88,7 +88,7 @@ function syncDirFiles(srcDir, destDir, { fileList, chmod } = {}) {
 // Auto-deploy bundled scripts to ~/.metame/
 // IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 const scriptsDir = path.join(__dirname, 'scripts');
-const BUNDLED_BASE_SCRIPTS = ['platform.js', 'signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'migrate-v2.js', 'daemon.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml', 'providers.js', 'session-analytics.js', 'resolve-yaml.js', 'utils.js', 'skill-evolution.js', 'memory.js', 'memory-extract.js', 'memory-search.js', 'memory-gc.js', 'qmd-client.js', 'session-summarize.js', 'check-macos-control-capabilities.sh', 'usage-classifier.js', 'task-board.js', 'memory-nightly-reflect.js', 'memory-index.js'];
+const BUNDLED_BASE_SCRIPTS = ['platform.js', 'signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'daemon.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml', 'providers.js', 'session-analytics.js', 'resolve-yaml.js', 'utils.js', 'skill-evolution.js', 'memory.js', 'memory-extract.js', 'memory-search.js', 'memory-write.js', 'memory-gc.js', 'qmd-client.js', 'session-summarize.js', 'mentor-engine.js', 'check-macos-control-capabilities.sh', 'usage-classifier.js', 'task-board.js', 'memory-nightly-reflect.js', 'memory-index.js', 'skill-changelog.js'];
 const DAEMON_MODULE_SCRIPTS = (() => {
   try {
     return fs.readdirSync(scriptsDir).filter((f) => /^daemon-[\w-]+\.js$/.test(f));
@@ -124,6 +124,8 @@ if (scriptsUpdated) {
 syncDirFiles(path.join(__dirname, 'scripts', 'docs'), path.join(METAME_DIR, 'docs'));
 // Bin: CLI tools (dispatch_to etc.)
 syncDirFiles(path.join(__dirname, 'scripts', 'bin'), path.join(METAME_DIR, 'bin'), { chmod: 0o755 });
+// Hooks: Claude Code event hooks (Stop, PostToolUse, etc.)
+syncDirFiles(path.join(__dirname, 'scripts', 'hooks'), path.join(METAME_DIR, 'hooks'));
 
 // ---------------------------------------------------------
 // Deploy bundled skills to ~/.claude/skills/
@@ -163,6 +165,29 @@ if (fs.existsSync(bundledSkillsDir)) {
   }
 }
 
+// Ensure ~/.codex/skills and ~/.agents/skills are symlinks to ~/.claude/skills
+// This keeps skill evolution unified across all engines.
+for (const altDir of [
+  path.join(HOME_DIR, '.codex', 'skills'),
+  path.join(HOME_DIR, '.agents', 'skills'),
+]) {
+  try {
+    const parentDir = path.dirname(altDir);
+    if (!fs.existsSync(parentDir)) continue; // engine not installed, skip
+    const stat = fs.lstatSync(altDir);
+    if (stat.isSymbolicLink()) continue; // already a symlink, good
+    // Physical directory exists — replace with symlink
+    fs.rmSync(altDir, { recursive: true, force: true });
+    fs.symlinkSync(CLAUDE_SKILLS_DIR, altDir);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      // Directory doesn't exist — create symlink
+      try { fs.symlinkSync(CLAUDE_SKILLS_DIR, altDir); } catch { /* non-fatal */ }
+    }
+    // Other errors: non-fatal, skip
+  }
+}
+
 // Load daemon config for local launch flags
 let daemonCfg = {};
 try {
@@ -231,6 +256,8 @@ function ensureHookInstalled() {
       entry.hooks?.some(h => h.command && h.command.includes('signal-capture.js'))
     );
 
+    let modified = false;
+
     if (!stillInstalled) {
       if (!settings.hooks) settings.hooks = {};
       if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
@@ -241,9 +268,33 @@ function ensureHookInstalled() {
           command: hookCommand
         }]
       });
+      modified = true;
+      console.log(`${icon("hook")} MetaMe: Signal capture hook installed.`);
+    }
+
+    // Ensure Stop hook (session-logger + tool-failure capture) is installed
+    const stopHookScript = path.join(METAME_DIR, 'hooks', 'stop-session-capture.js').replace(/\\/g, '/');
+    const stopHookCommand = `node "${stopHookScript}"`;
+    const stopHookInstalled = (settings.hooks?.Stop || []).some(entry =>
+      entry.hooks?.some(h => h.command && h.command.includes('stop-session-capture.js'))
+    );
+
+    if (!stopHookInstalled) {
+      if (!settings.hooks) settings.hooks = {};
+      if (!settings.hooks.Stop) settings.hooks.Stop = [];
+
+      settings.hooks.Stop.push({
+        hooks: [{
+          type: 'command',
+          command: stopHookCommand
+        }]
+      });
+      modified = true;
+      console.log(`${icon("hook")} MetaMe: Stop session capture hook installed.`);
+    }
 
+    if (modified) {
       fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2), 'utf8');
-      console.log(`${icon("hook")} MetaMe: Signal capture hook installed.`);
     }
   } catch (e) {
     // Non-fatal: hook install failure shouldn't block launch
@@ -743,7 +794,8 @@ const GLOBAL_MARKER_END = '<!-- METAME-GLOBAL:END -->';
 // Build dynamic Agent dispatch table from daemon.yaml projects.
 // Only include agents whose cwd actually exists on disk — test/stale agents
 // with deleted paths are automatically excluded, no manual cleanup needed.
-let dispatchTable = '';
+// The table is written to ~/.metame/docs/dispatch-table.md (NOT inlined into CLAUDE.md).
+const DISPATCH_TABLE_PATH = path.join(METAME_DIR, 'docs', 'dispatch-table.md');
 try {
   const daemonYamlPath = path.join(os.homedir(), '.metame', 'daemon.yaml');
   if (fs.existsSync(daemonYamlPath)) {
@@ -752,13 +804,29 @@ try {
     const rows = Object.entries(projects)
       .filter(([, p]) => {
         if (!p || !p.name || !p.cwd) return false;
-        // Expand ~ to home directory
         const expandedCwd = String(p.cwd).replace(/^~/, os.homedir());
         return fs.existsSync(expandedCwd);
       })
       .map(([key, p]) => `| \`${key}\` | ${p.name} |`);
     if (rows.length > 0) {
-      dispatchTable = '\n\n| project_key | 昵称 |\n|-------------|------|\n' + rows.join('\n') + '\n\n`--new` 强制新建会话（用户说"新开会话"时加此参数）。';
+      const tableContent = [
+        '# Agent Dispatch 路由表',
+        '',
+        '> 自动生成，来源：daemon.yaml。勿手动编辑。',
+        '',
+        '| project_key | 昵称 |',
+        '|-------------|------|',
+        ...rows,
+        '',
+        '## 使用方法',
+        '```bash',
+        '~/.metame/bin/dispatch_to [--new] <project_key> "内容"',
+        '```',
+        '`--new` 强制新建会话（用户说"新开会话"时加此参数）。',
+        '新增 Agent：`/agent bind <名称> <工作目录>`',
+      ].join('\n') + '\n';
+      fs.mkdirSync(path.dirname(DISPATCH_TABLE_PATH), { recursive: true });
+      fs.writeFileSync(DISPATCH_TABLE_PATH, tableContent);
     }
   }
 } catch { /* daemon.yaml missing or invalid — skip dispatch table */ }
@@ -771,11 +839,11 @@ const KERNEL_BODY = PROTOCOL_NORMAL
 
 const CAPABILITY_SECTIONS = [
   '## Agent Dispatch',
-  `"告诉X/让X" → \`~/.metame/bin/dispatch_to <project_key> "内容"\`，手机端 \`/dispatch to <key> <消息>\`。` + dispatchTable,
-  '新增 Agent：`/agent bind <名称> <工作目录>`',
+  '识别到"告诉X/让X/通知X"等转发意图时 → 先 `cat ~/.metame/docs/dispatch-table.md` 获取路由表（昵称→project_key），再执行转发。不要凭记忆猜测昵称对应关系。',
   '',
   '## Agent 创建与管理',
   '用户问创建/管理/绑定 Agent 时 → 先 `cat ~/.metame/docs/agent-guide.md` 再回答。',
+  '用户问代码结构/升级进度/脚本入口时 → 先 `cat ~/.metame/docs/pointer-map.md` 再回答。',
   '',
   '## 手机端文件交互',
   '用户要文件（"发给我"/"发过来"/"导出"）→ 先 `cat ~/.metame/docs/file-transfer.md` 再执行。',
@@ -882,7 +950,37 @@ try {
   }
 } catch { /* non-fatal */ }
 
+// Skill evolution status
+try {
+  const skillChangelog = require('./scripts/skill-changelog');
+  const skillCount = skillChangelog.countInstalledSkills();
+  const lastSession = skillChangelog.getLastSessionStart();
+  const recentChanges = skillChangelog.getRecentChanges(lastSession);
+
+  if (recentChanges.length === 0) {
+    console.log(`${icon("tool")} Skills: ${skillCount} installed · 无新变更`);
+  } else {
+    const evolved = recentChanges.filter(c => c.action === 'evolved');
+    const others = recentChanges.filter(c => c.action !== 'evolved');
+    const parts = [`${skillCount} installed`];
+    if (evolved.length > 0) parts.push(`${evolved.length} evolved since last session`);
+    if (others.length > 0) parts.push(`${others.length} other event${others.length > 1 ? 's' : ''}`);
+    console.log(`${icon("tool")} Skills: ${parts.join(' · ')}`);
+
+    // Show up to 3 details
+    const shown = recentChanges.slice(0, 3);
+    for (const c of shown) {
+      const actionIcon = skillChangelog.getActionIcon(c.action);
+      console.log(`   ${actionIcon} ${c.skill || 'system'}: ${c.summary}`);
+    }
+    if (recentChanges.length > 3) {
+      console.log(`   +${recentChanges.length - 3} more`);
+    }
+  }
 
+  // Write session start marker for next time
+  skillChangelog.writeSessionStart();
+} catch { /* non-fatal */ }
 
 // ---------------------------------------------------------
 // 4.9 AUTO-UPDATE CHECK (non-blocking)
@@ -1806,7 +1904,12 @@ WantedBy=default.target
   }
 
   // Unknown subcommand
-  console.log(`${icon("book")} MetaMe Daemon Commands:`);
+  console.log(`${icon("book")} MetaMe Commands:`);
+  console.log("   metame                        — launch Claude with MetaMe init");
+  console.log("   metame codex [args]           — launch Codex with MetaMe init");
+  console.log("   metame continue               — resume latest session");
+  console.log("");
+  console.log(`${icon("book")} Daemon Commands:`);
   console.log("   metame start                  — start background daemon");
   console.log("   metame stop                   — stop daemon");
   console.log("   metame status                 — show status & budget");
@@ -1824,7 +1927,43 @@ WantedBy=default.target
 }
 
 // ---------------------------------------------------------
-// 5.8 CONTINUE/SYNC — resume latest session from terminal
+// 5.8 CODEX — launch Codex with MetaMe initialization
+// ---------------------------------------------------------
+const isCodex = process.argv[2] === 'codex';
+if (isCodex) {
+  // spawn() resolves PATH automatically; error event handles missing binary
+  const codexBin = 'codex';
+
+  // Build codex args: remaining user args after 'codex'
+  const codexUserArgs = process.argv.slice(3);
+  let codexArgs;
+  if (codexUserArgs.length === 0) {
+    // Interactive mode: `codex --full-auto`
+    codexArgs = ['--full-auto'];
+  } else {
+    // Non-interactive: `codex exec --full-auto <user args>`
+    codexArgs = ['exec', '--full-auto', ...codexUserArgs];
+  }
+
+  const codexChild = spawn(codexBin, codexArgs, {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: { ...process.env, METAME_ACTIVE_SESSION: 'true' },
+  });
+
+  codexChild.on('error', () => {
+    console.error(`\n${icon("fail")} Error: Could not launch 'codex'.`);
+    console.error("   Please install: npm install -g @openai/codex");
+  });
+  codexChild.on('close', (code) => process.exit(code || 0));
+
+  // Background distillation
+  spawnDistillBackground();
+  return;
+}
+
+// ---------------------------------------------------------
+// 5.9 CONTINUE/SYNC — resume latest session from terminal
 // ---------------------------------------------------------
 // Usage: exit Claude first, then run `metame continue` from terminal.
 // Finds the most recent session and launches Claude with --resume.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.4.34",
+    "version": "1.5.0",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -8,12 +8,15 @@
     },
     "files": [
         "index.js",
-        "scripts/"
+        "scripts/",
+        "!scripts/*.test.js",
+        "!scripts/test_daemon.js",
+        "!scripts/hooks/test-*.js"
     ],
     "scripts": {
         "test": "node --test scripts/*.test.js",
         "start": "node index.js",
-        "sync:plugin": "cp scripts/platform.js scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/daemon-agent-commands.js scripts/daemon-session-commands.js scripts/daemon-admin-commands.js scripts/daemon-exec-commands.js scripts/daemon-ops-commands.js scripts/daemon-session-store.js scripts/daemon-checkpoints.js scripts/daemon-bridges.js scripts/daemon-file-browser.js scripts/daemon-runtime-lifecycle.js scripts/daemon-notify.js scripts/daemon-claude-engine.js scripts/daemon-command-router.js scripts/daemon-user-acl.js scripts/daemon-agent-tools.js scripts/daemon-task-scheduler.js scripts/daemon-task-envelope.js scripts/task-board.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/usage-classifier.js scripts/resolve-yaml.js scripts/memory.js scripts/memory-extract.js scripts/qmd-client.js scripts/session-summarize.js scripts/session-analytics.js scripts/skill-evolution.js scripts/check-macos-control-capabilities.sh plugin/scripts/ && echo '✅ Plugin scripts synced'",
+        "sync:plugin": "cp scripts/platform.js scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/daemon-agent-commands.js scripts/daemon-session-commands.js scripts/daemon-admin-commands.js scripts/daemon-exec-commands.js scripts/daemon-ops-commands.js scripts/daemon-session-store.js scripts/daemon-checkpoints.js scripts/daemon-bridges.js scripts/daemon-file-browser.js scripts/daemon-runtime-lifecycle.js scripts/daemon-notify.js scripts/daemon-claude-engine.js scripts/daemon-engine-runtime.js scripts/daemon-command-router.js scripts/daemon-user-acl.js scripts/daemon-agent-tools.js scripts/daemon-task-scheduler.js scripts/daemon-task-envelope.js scripts/task-board.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/usage-classifier.js scripts/resolve-yaml.js scripts/memory.js scripts/memory-write.js scripts/memory-extract.js scripts/memory-search.js scripts/memory-gc.js scripts/memory-nightly-reflect.js scripts/memory-index.js scripts/qmd-client.js scripts/session-summarize.js scripts/session-analytics.js scripts/mentor-engine.js scripts/skill-evolution.js scripts/skill-changelog.js scripts/check-macos-control-capabilities.sh plugin/scripts/ && echo '✅ Plugin scripts synced'",
         "sync:readme": "node scripts/sync-readme.js",
         "restart:daemon": "node index.js stop 2>/dev/null; sleep 1; node index.js start 2>/dev/null || echo '⚠️  Daemon not running or restart failed'",
         "precommit": "npm run sync:plugin && npm run restart:daemon"