metame-cli 1.3.0 → 1.3.2

package/README.md

@@ -20,9 +20,10 @@ It is not a memory system; it is a  **Cognitive Mirror** .
 
 * **🧠 Global Brain (`~/.claude_profile.yaml`):** A single, portable source of truth — your identity, cognitive traits, and preferences travel with you across every project.
 * **🧬 Cognitive Evolution Engine:** MetaMe learns how you think through three channels: (1) **Passive** — silently captures your messages and distills cognitive traits via Haiku on next launch; (2) **Manual** — `!metame evolve` for explicit teaching; (3) **Confidence gates** — strong directives ("always"/"以后一律") write immediately, normal observations need 3+ consistent sightings before promotion. Schema-enforced (41 fields, 5 tiers, 800 token budget) to prevent bloat.
-* **🤝 Dynamic Handshake:** The "Canary Test." Claude must address you by your **Codename** in the first sentence. If it doesn't, the link is broken.
 * **🛡️ Auto-Lock:** Mark any value with `# [LOCKED]` — treated as a constitution, never auto-modified.
+* **🪞 Metacognition Layer (v1.3):** MetaMe now observes *how* you think, not just *what* you say. Behavioral pattern detection runs inside the existing Haiku distill call (zero extra cost). It tracks decision patterns, cognitive load, comfort zones, and avoidance topics across sessions. When persistent patterns emerge, MetaMe injects a one-line mirror observation — e.g., *"You tend to avoid testing until forced"* — with a 14-day cooldown per pattern. Conditional reflection prompts appear only when triggered (every 7th distill or 3x consecutive comfort zone). All injection logic runs in Node.js; Claude receives only pre-decided directives, never rules to self-evaluate.
 * **📱 Remote Claude Code (v1.3):** Full Claude Code from your phone via Telegram or Feishu (Lark). Stateful sessions with `--resume` — same conversation history, tool use, and file editing as your terminal. Interactive buttons for project/session picking, directory browser, and macOS launchd auto-start.
+* **🔄 Workflow Engine (v1.3):** Define multi-step skill chains as heartbeat tasks. Each workflow runs in a single Claude Code session via `--resume`, so step outputs flow as context to the next step. Example: `deep-research` → `tech-writing` → `wechat-publisher` — fully automated content pipeline.
 
 ## 🛠 Prerequisites
 
@@ -105,8 +106,21 @@ metame set-trait status.focus "Learning Rust"
 metame evolve "I prefer functional programming patterns"
 ```
 
+**Episodic memory (keyframe, not full log):** MetaMe is not a memory system, but it captures two types of experiential "keyframes" that pure personality traits can't replace:
+
+* **Anti-patterns** (`context.anti_patterns`, max 5): Cross-project failure lessons — e.g., *"Promise.all rejects all on single failure, use Promise.allSettled"*. Auto-expires after 60 days. Prevents the AI from repeating the same mistakes across sessions.
+* **Milestones** (`context.milestones`, max 3): Recent completed landmarks — e.g., *"MetaMe v1.3 published"*. Provides continuity so Claude knows where you left off without you having to recap.
+
 **Anti-bias safeguards:** single observations ≠ traits, contradictions are tracked not overwritten, pending traits expire after 30 days, context fields auto-clear on staleness.
 
+**Metacognition controls:**
+
+```bash
+metame quiet            # Silence mirror observations & reflections for 48h
+metame insights         # Show detected behavioral patterns
+metame mirror on|off    # Toggle mirror injection
+```
+
 ### Remote Claude Code — Telegram & Feishu (v1.3)
 
 Full Claude Code from your phone — stateful sessions with conversation history, tool use, and file editing. Supports both Telegram and Feishu (Lark).
@@ -168,6 +182,7 @@ Each chat gets a persistent session via `claude -p --resume <session-id>`. This
 | `/run <name>` | Run a task immediately |
 | `/budget` | Today's token usage |
 | `/quiet` | Silence mirror/reflections for 48h |
+| `/reload` | Manually reload daemon.yaml (also auto-reloads on file change) |
 
 **Heartbeat Tasks:**
 
@@ -188,6 +203,30 @@ heartbeat:
 * `type: "script"`: Run a local script directly instead of `claude -p`.
 * `notify: true`: Push results to Telegram/Feishu.
 
+**Workflow tasks** (multi-step skill chains):
+
+```yaml
+heartbeat:
+  tasks:
+    - name: "daily-wechat"
+      type: "workflow"
+      interval: "24h"
+      model: "sonnet"
+      notify: true
+      steps:
+        - skill: "deep-research"
+          prompt: "Today's top 3 AI news stories"
+        - skill: "tech-writing"
+          prompt: "Write a WeChat article based on the research above"
+        - skill: "wechat-publisher"
+          prompt: "Publish the article"
+          optional: true
+```
+
+Each step runs in the same Claude Code session. Step outputs automatically become context for the next step. Set `optional: true` on steps that may fail without aborting the workflow.
+
+**Auto-reload:** The daemon watches `daemon.yaml` for changes. When Claude (or you) edits the config file, the daemon automatically reloads — no restart or `/reload` needed. A notification is pushed to confirm.
+
 **Token efficiency:**
 
 * Polling, slash commands, directory browsing: **zero tokens**
@@ -356,8 +395,6 @@ You might worry: *"Does this eat up my context window?"*
 **Q: Does this replace `CLAUDE.md`?**
 A: No. It *prepends* its meta-cognitive protocol to your existing `CLAUDE.md`. Your project-specific notes remain intact.
 
-**Q: What if Claude stops calling me by my nickname?**
-A: This is the "Canary Test." It means the context window has been compressed or the file link is broken. Run `/compact` in Claude or restart `metame` to fix it.
 
 **Q: Is my data sent to a third party?**
 A: No. Your profile stays local at `~/.claude_profile.yaml`. MetaMe simply passes text to the official Claude Code tool.

package/index.js

@@ -208,20 +208,13 @@ const CORE_PROTOCOL = `
 ---
 ## 🧠 SYSTEM KERNEL: SHADOW_MODE (Active)
 
-**1. THE HANDSHAKE (Dynamic Verification):**
-   * **SOURCE:** Check \`$HOME/.claude_profile.yaml\`.
-   * **RULE:** Look for \`identity.nickname\`.
-     * **IF FOUND:** You MUST address the user by that nickname in the very first sentence.
-     * **IF NULL/MISSING:** Address user as "User" and immediately trigger Genesis to fix it.
-   * **SIGNAL:** This nickname is the "Canary Test". If you omit it, the user assumes the system is broken.
-
-**2. THE BRAIN (Source of Truth):**
+**1. THE BRAIN (Source of Truth):**
    * **FILE:** \`$HOME/.claude_profile.yaml\`
    * **RULE:** This file is your Ground Truth. If context is compressed (/compact), **RE-READ** this file immediately.
    * **AUTO-LOCK:** Never edit lines marked \`# [LOCKED]\` (Core Values).
    * **EVOLUTION:** Silently overwrite outdated status/focus.
 
-**3. EVOLUTION MECHANISM (Manual Sync):**
+**2. EVOLUTION MECHANISM (Manual Sync):**
    *   **PHILOSOPHY:** You respect the User's flow. You do NOT interrupt.
    *   **TOOLS:**
        1. **Log Insight:** \`!metame evolve "Insight"\` (For additive knowledge).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.0",
+    "version": "1.3.2",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/daemon.js

@@ -211,6 +211,11 @@ function executeTask(task, config) {
     return { success: true, output: '(skipped — no activity)', skipped: true };
   }
 
+  // Workflow tasks: multi-step skill chain via --resume session
+  if (task.type === 'workflow') {
+    return executeWorkflow(task, config);
+  }
+
   // Script tasks: run a local script directly (e.g. distill.js), no claude -p
   if (task.type === 'script') {
     log('INFO', `Executing script task: ${task.name} → ${task.command}`);
@@ -251,11 +256,12 @@ function executeTask(task, config) {
   }
   const fullPrompt = preamble + taskPrompt;
 
+  const allowedArgs = (task.allowedTools || []).map(t => `--allowedTools ${t}`).join(' ');
   log('INFO', `Executing task: ${task.name} (model: ${model})`);
 
   try {
     const output = execSync(
-      `claude -p --model ${model}`,
+      `claude -p --model ${model}${allowedArgs ? ' ' + allowedArgs : ''}`,
       {
         input: fullPrompt,
         encoding: 'utf8',
@@ -307,6 +313,70 @@ function parseInterval(str) {
   }
 }
 
+// ---------------------------------------------------------
+// WORKFLOW EXECUTION (multi-step skill chain via --resume)
+// ---------------------------------------------------------
+function executeWorkflow(task, config) {
+  const state = loadState();
+  if (!checkBudget(config, state)) {
+    log('WARN', `Budget exceeded, skipping workflow: ${task.name}`);
+    return { success: false, error: 'budget_exceeded', output: '' };
+  }
+  const precheck = checkPrecondition(task);
+  if (!precheck.pass) {
+    state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'skipped', output_preview: 'Precondition not met' };
+    saveState(state);
+    return { success: true, output: '(skipped)', skipped: true };
+  }
+  const steps = task.steps || [];
+  if (steps.length === 0) return { success: false, error: 'No steps defined', output: '' };
+
+  const model = task.model || 'sonnet';
+  const cwd = task.cwd ? task.cwd.replace(/^~/, HOME) : HOME;
+  const sessionId = crypto.randomUUID();
+  const outputs = [];
+  let totalTokens = 0;
+  const allowed = task.allowedTools || [];
+
+  log('INFO', `Workflow ${task.name}: ${steps.length} steps, session ${sessionId.slice(0, 8)}`);
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    let prompt = (step.skill ? `/${step.skill} ` : '') + (step.prompt || '');
+    if (i === 0 && precheck.context) prompt += `\n\n相关数据:\n\`\`\`\n${precheck.context}\n\`\`\``;
+    const args = ['-p', '--model', model];
+    for (const tool of allowed) args.push('--allowedTools', tool);
+    args.push(i === 0 ? '--session-id' : '--resume', sessionId);
+
+    log('INFO', `Workflow ${task.name} step ${i + 1}/${steps.length}: ${step.skill || 'prompt'}`);
+    try {
+      const output = execSync(`claude ${args.join(' ')}`, {
+        input: prompt, encoding: 'utf8', timeout: step.timeout || 300000, maxBuffer: 5 * 1024 * 1024, cwd,
+      }).trim();
+      const tk = Math.ceil((prompt.length + output.length) / 4);
+      totalTokens += tk;
+      outputs.push({ step: i + 1, skill: step.skill || null, output: output.slice(0, 500), tokens: tk });
+      log('INFO', `Workflow ${task.name} step ${i + 1} done (${tk} tokens)`);
+      if (!checkBudget(config, loadState())) { log('WARN', 'Budget exceeded mid-workflow'); break; }
+    } catch (e) {
+      log('ERROR', `Workflow ${task.name} step ${i + 1} failed: ${e.message.slice(0, 200)}`);
+      outputs.push({ step: i + 1, skill: step.skill || null, error: e.message.slice(0, 200) });
+      if (!step.optional) {
+        recordTokens(loadState(), totalTokens);
+        state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'error', error: `Step ${i + 1} failed`, steps_completed: i, steps_total: steps.length };
+        saveState(state);
+        return { success: false, error: `Step ${i + 1} failed`, output: outputs.map(o => `Step ${o.step}: ${o.error ? 'FAILED' : 'OK'}`).join('\n'), tokens: totalTokens };
+      }
+    }
+  }
+  recordTokens(loadState(), totalTokens);
+  const lastOk = [...outputs].reverse().find(o => !o.error);
+  state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'success', output_preview: (lastOk ? lastOk.output : '').slice(0, 200), steps_completed: outputs.filter(o => !o.error).length, steps_total: steps.length };
+  saveState(state);
+  log('INFO', `Workflow ${task.name} done: ${outputs.filter(o => !o.error).length}/${steps.length} steps (${totalTokens} tokens)`);
+  return { success: true, output: outputs.map(o => `Step ${o.step} (${o.skill || 'prompt'}): ${o.error ? 'FAILED' : 'OK'}`).join('\n') + '\n\n' + (lastOk ? lastOk.output : ''), tokens: totalTokens };
+}
+
 // ---------------------------------------------------------
 // HEARTBEAT SCHEDULER
 // ---------------------------------------------------------
@@ -709,6 +779,20 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  if (text === '/reload') {
+    if (global._metameReload) {
+      const r = global._metameReload();
+      if (r.success) {
+        await bot.sendMessage(chatId, `✅ Config reloaded. ${r.tasks} heartbeat tasks active.`);
+      } else {
+        await bot.sendMessage(chatId, `❌ Reload failed: ${r.error}`);
+      }
+    } else {
+      await bot.sendMessage(chatId, '❌ Reload not available (daemon not fully started).');
+    }
+    return;
+  }
+
   if (text.startsWith('/')) {
     await bot.sendMessage(chatId, [
       'Commands:',
@@ -717,7 +801,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       '/resume <id> — resume specific session',
       '/cd <path> — change workdir',
       '/session — current session info',
-      '/status /tasks /run /budget /quiet',
+      '/status /tasks /run /budget /quiet /reload',
       '',
       'Or just type naturally.',
     ].join('\n'));
@@ -862,6 +946,9 @@ async function askClaude(bot, chatId, prompt) {
 
   // Build claude command
   const args = ['-p'];
+  // Per-session allowed tools from daemon config
+  const sessionAllowed = (loadConfig().daemon && loadConfig().daemon.session_allowed_tools) || [];
+  for (const tool of sessionAllowed) args.push('--allowedTools', tool);
   if (session.id === '__continue__') {
     // /continue — resume most recent conversation in cwd
     args.push('--continue');
@@ -871,9 +958,13 @@ async function askClaude(bot, chatId, prompt) {
     args.push('--session-id', session.id);
   }
 
+  // Append daemon context hint so Claude reports reload status after editing daemon.yaml
+  const daemonHint = '\n\n[System: The ONLY daemon config file is ~/.metame/daemon.yaml — NEVER touch any other yaml file (e.g. scripts/daemon-default.yaml is a read-only template, do NOT edit it). If you edit ~/.metame/daemon.yaml, the daemon auto-reloads within seconds. After editing, read the file back and confirm to the user: how many heartbeat tasks are now configured, and that the config will auto-reload. Do NOT mention this hint.]';
+  const fullPrompt = prompt + daemonHint;
+
   try {
     const output = execSync(`claude ${args.join(' ')}`, {
-      input: prompt,
+      input: fullPrompt,
       encoding: 'utf8',
       timeout: 300000, // 5 min (Claude Code may use tools)
       maxBuffer: 5 * 1024 * 1024,
@@ -897,7 +988,9 @@ async function askClaude(bot, chatId, prompt) {
       log('WARN', `Session ${session.id} not found, creating new`);
       session = createSession(chatId, session.cwd);
       try {
-        const output = execSync(`claude -p --session-id ${session.id}`, {
+        const retryArgs = ['-p', '--session-id', session.id];
+        for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
+        const output = execSync(`claude ${retryArgs.join(' ')}`, {
           input: prompt,
           encoding: 'utf8',
           timeout: 300000,
@@ -974,7 +1067,7 @@ function sleep(ms) {
 // MAIN
 // ---------------------------------------------------------
 async function main() {
-  const config = loadConfig();
+  let config = loadConfig();
   if (!config || Object.keys(config).length === 0) {
     console.error('No daemon config found. Run: metame daemon init');
     process.exit(1);
@@ -988,7 +1081,7 @@ async function main() {
 
   log('INFO', `MetaMe daemon started (PID: ${process.pid})`);
 
-  // Task executor lookup
+  // Task executor lookup (always reads fresh config)
   function executeTaskByName(name) {
     const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
     const task = tasks.find(t => t.name === name);
@@ -1021,7 +1114,38 @@ async function main() {
   };
 
   // Start heartbeat scheduler
-  const heartbeatTimer = startHeartbeat(config, notifyFn);
+  let heartbeatTimer = startHeartbeat(config, notifyFn);
+
+  // Hot reload: re-read config and restart heartbeat scheduler
+  function reloadConfig() {
+    const newConfig = loadConfig();
+    if (!newConfig) return { success: false, error: 'Failed to read config' };
+    config = newConfig;
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = startHeartbeat(config, notifyFn);
+    log('INFO', `Config reloaded: ${(config.heartbeat && config.heartbeat.tasks || []).length} tasks`);
+    return { success: true, tasks: (config.heartbeat && config.heartbeat.tasks || []).length };
+  }
+  // Expose reloadConfig to handleCommand via closure
+  global._metameReload = reloadConfig;
+
+  // Auto-reload: watch daemon.yaml for changes (e.g. Claude edits it via askClaude)
+  let _reloadDebounce = null;
+  fs.watchFile(CONFIG_FILE, { interval: 2000 }, (curr, prev) => {
+    if (curr.mtimeMs === prev.mtimeMs) return;
+    // Debounce: wait 1s for file write to finish
+    if (_reloadDebounce) clearTimeout(_reloadDebounce);
+    _reloadDebounce = setTimeout(() => {
+      log('INFO', 'daemon.yaml changed on disk — auto-reloading config');
+      const r = reloadConfig();
+      if (r.success) {
+        log('INFO', `Auto-reload OK: ${r.tasks} tasks`);
+        notifyFn(`🔄 Config auto-reloaded. ${r.tasks} heartbeat tasks active.`).catch(() => {});
+      } else {
+        log('ERROR', `Auto-reload failed: ${r.error}`);
+      }
+    }, 1000);
+  });
 
   // Start bridges (both can run simultaneously)
   telegramBridge = await startTelegramBridge(config, executeTaskByName);
@@ -1030,6 +1154,7 @@ async function main() {
   // Graceful shutdown
   const shutdown = () => {
     log('INFO', 'Daemon shutting down...');
+    fs.unwatchFile(CONFIG_FILE);
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     if (telegramBridge) telegramBridge.stop();
     if (feishuBridge) feishuBridge.stop();

package/scripts/distill.js

@@ -110,6 +110,12 @@ INSTRUCTIONS:
 5. Fields marked [LOCKED] must NEVER be changed (T1 and T2 tiers).
 6. For enum fields, you MUST use one of the listed values.
 
+EPISODIC MEMORY — TWO EXCEPTIONS to the "no facts" rule:
+7. context.anti_patterns (max 5): If the user encountered a REPEATED technical failure or expressed strong frustration about a specific technical approach, record it as an anti-pattern. Format: "topic — what failed and why". Only cross-project generalizable lessons, NOT project-specific bugs.
+   Example: ["async/await deadlock — Promise.all rejects all on single failure, use Promise.allSettled", "CSS Grid in email templates — no support, use tables"]
+8. context.milestones (max 3): If the user completed a significant milestone or made a key decision, record it. Only the 3 most recent. Format: short description string.
+   Example: ["MetaMe v1.3 published", "Switched from REST to GraphQL"]
+
 COGNITIVE BIAS PREVENTION:
 - A single observation is a STATE, not a TRAIT. Do NOT infer T3 cognition fields from one message.
 - Never infer cognitive style from identity/demographics.
@@ -233,6 +239,9 @@ Do NOT repeat existing unchanged values. Only output NEW or CHANGED fields.`;
 
       const profile = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
 
+      // Auto-expire anti_patterns older than 60 days
+      expireAntiPatterns(profile);
+
       // Read raw content to find locked lines and comments
       const rawProfile = fs.readFileSync(BRAIN_FILE, 'utf8');
       const lockedKeys = extractLockedKeys(rawProfile);
@@ -415,7 +424,18 @@ function strategicMerge(profile, updates, lockedKeys, pendingTraits, confidenceM
       }
 
       case 'T4':
-        setNested(result, key, value);
+        // Stamp added date on anti_pattern entries for auto-expiry
+        if (key === 'context.anti_patterns' && Array.isArray(value)) {
+          const today = new Date().toISOString().slice(0, 10);
+          const existing = getNested(result, key) || [];
+          const existingTexts = new Set(existing.map(e => typeof e === 'string' ? e : e.text));
+          const stamped = value
+            .filter(v => !existingTexts.has(typeof v === 'string' ? v : v.text))
+            .map(v => typeof v === 'string' ? { text: v, added: today } : v);
+          setNested(result, key, [...existing, ...stamped].slice(-5));
+        } else {
+          setNested(result, key, value);
+        }
         // Auto-set focus_since when focus changes
         if (key === 'context.focus') {
           setNested(result, 'context.focus_since', new Date().toISOString().slice(0, 10));
@@ -455,6 +475,19 @@ function flattenObject(obj, parentKey = '', result = {}) {
   return result;
 }
 
+/**
+ * Get a nested property by dot-path key.
+ */
+function getNested(obj, dotPath) {
+  const keys = dotPath.split('.');
+  let current = obj;
+  for (const k of keys) {
+    if (!current || typeof current !== 'object') return undefined;
+    current = current[k];
+  }
+  return current;
+}
+
 /**
  * Set a nested property by dot-path key.
  */
@@ -508,6 +541,24 @@ function truncateArrays(obj) {
   }
 }
 
+/**
+ * Auto-expire anti_patterns older than 60 days.
+ * Each entry is stored as { text: "...", added: "2026-01-15" } internally.
+ * If legacy string entries exist, they are kept (no added date = never expire).
+ */
+function expireAntiPatterns(profile) {
+  if (!profile.context || !Array.isArray(profile.context.anti_patterns)) return;
+  const now = Date.now();
+  const SIXTY_DAYS = 60 * 24 * 60 * 60 * 1000;
+  profile.context.anti_patterns = profile.context.anti_patterns.filter(entry => {
+    if (typeof entry === 'string') return true; // legacy, keep
+    if (entry.added) {
+      return (now - new Date(entry.added).getTime()) < SIXTY_DAYS;
+    }
+    return true;
+  });
+}
+
 /**
  * Clean up: remove buffer and lock
  */

package/scripts/schema.js

@@ -60,6 +60,8 @@ const SCHEMA = {
   'context.active_projects':   { tier: 'T4', type: 'array', maxItems: 5 },
   'context.blockers':          { tier: 'T4', type: 'array', maxItems: 3 },
   'context.energy':            { tier: 'T4', type: 'enum', values: ['high', 'medium', 'low', null] },
+  'context.milestones':        { tier: 'T4', type: 'array', maxItems: 3 },
+  'context.anti_patterns':     { tier: 'T4', type: 'array', maxItems: 5 },
   'status.focus':              { tier: 'T4', type: 'string', maxChars: 80 },
   'status.language':           { tier: 'T4', type: 'string' },