metame-cli 1.3.0 → 1.3.1

package/README.md

@@ -22,7 +22,9 @@ It is not a memory system; it is a  **Cognitive Mirror** .
 * **🧬 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
 
@@ -107,6 +109,14 @@ metame evolve "I prefer functional programming patterns"
 
 **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 +178,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 +199,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**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "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}`);
@@ -307,6 +312,68 @@ 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;
+
+  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];
+    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 +776,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 +798,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'));
@@ -974,7 +1055,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 +1069,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 +1102,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 +1142,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();