metame-cli 1.6.0 → 1.6.2

package/scripts/core/wiki-db.js

@@ -83,6 +83,9 @@ function upsertWikiPage(db, {
   raw_source_count = 0,
   topic_tags = '[]',
   word_count = 0,
+  source_type = 'memory',
+  membership_hash = null,
+  cluster_size = null,
 }) {
   const rawSourceIdsStr = typeof raw_source_ids === 'string'
     ? raw_source_ids : JSON.stringify(raw_source_ids);
@@ -105,18 +108,22 @@ function upsertWikiPage(db, {
           raw_source_count = ?,
           topic_tags = ?,
           word_count = ?,
+          source_type = ?,
+          membership_hash = ?,
+          cluster_size = ?,
           updated_at = datetime('now')
       WHERE slug = ?
-    `).run(primary_topic, title, content, rawSourceIdsStr, capsuleRefsStr, raw_source_count, topicTagsStr, word_count, slug);
+    `).run(primary_topic, title, content, rawSourceIdsStr, capsuleRefsStr, raw_source_count, topicTagsStr, word_count, source_type, membership_hash, cluster_size, slug);
   } else {
     const id = `wp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
     db.prepare(`
       INSERT INTO wiki_pages
         (id, slug, primary_topic, title, content, raw_source_ids, capsule_refs,
          raw_source_count, topic_tags, word_count, staleness, new_facts_since_build,
+         source_type, membership_hash, cluster_size,
          created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0.0, 0, datetime('now'), datetime('now'))
-    `).run(id, slug, primary_topic, title, content, rawSourceIdsStr, capsuleRefsStr, raw_source_count, topicTagsStr, word_count);
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0.0, 0, ?, ?, ?, datetime('now'), datetime('now'))
+    `).run(id, slug, primary_topic, title, content, rawSourceIdsStr, capsuleRefsStr, raw_source_count, topicTagsStr, word_count, source_type, membership_hash, cluster_size);
   }
 }
 
@@ -284,6 +291,24 @@ function listRecentSessionSummaries(db, { limit = 200 } = {}) {
   `).all(limit);
 }
 
+// ── Timeline ──────────────────────────────────────────────────────────────────
+
+/**
+ * Append a timestamped entry to a wiki page's timeline (evidence trail).
+ * Does NOT touch content (compiled truth) — timeline is append-only.
+ *
+ * @param {object} db
+ * @param {string} slug
+ * @param {string} entry — free-text description of what happened
+ */
+function appendWikiTimeline(db, slug, entry) {
+  const ts = new Date().toISOString().slice(0, 10);
+  const line = `[${ts}] ${entry}`;
+  db.prepare(
+    `UPDATE wiki_pages SET timeline = COALESCE(timeline, '') || ? || char(10), updated_at = datetime('now') WHERE slug = ?`,
+  ).run(line, slug);
+}
+
 // ── Search ────────────────────────────────────────────────────────────────────
 
 /**
@@ -311,6 +336,11 @@ function searchWikiAndFacts(db, query, { trackSearch = true } = {}) {
     LIMIT 5
   `).all(safeQuery);
 
+  // Add stale flag to wiki results (staleness >= 0.3 means compiled truth may be outdated)
+  for (const wp of wikiPages) {
+    wp.stale = typeof wp.staleness === 'number' && wp.staleness >= 0.3;
+  }
+
   // 2. FTS5 search memory_items_fts — graceful fallback if table doesn't exist
   let facts = [];
   try {
@@ -385,6 +415,105 @@ function updateStalenessForTags(db, dirtyTagCounts) {
   }
 }
 
+// ── doc_sources CRUD ──────────────────────────────────────────────────────────
+
+function upsertDocSource(db, { filePath, fileHash, mtimeMs, sizeBytes, fileType,
+    extractor, extractStatus, extractedTextHash, title, slug }) {
+  const now = new Date().toISOString();
+  const existing = db.prepare('SELECT file_hash, extracted_text_hash FROM doc_sources WHERE file_path=?').get(filePath);
+  const hashChanged = !existing
+    || existing.file_hash !== fileHash
+    || existing.extracted_text_hash !== (extractedTextHash || null);
+
+  db.prepare(`
+    INSERT INTO doc_sources
+      (file_path, file_hash, mtime_ms, size_bytes, extracted_text_hash, file_type, extractor,
+       extract_status, title, slug, status, indexed_at, last_seen_at, content_stale)
+    VALUES (?,?,?,?,?,?,?,?,?,?,'active',?,?,?)
+    ON CONFLICT(file_path) DO UPDATE SET
+      file_hash=excluded.file_hash,
+      mtime_ms=excluded.mtime_ms,
+      size_bytes=excluded.size_bytes,
+      extracted_text_hash=excluded.extracted_text_hash,
+      extractor=excluded.extractor,
+      extract_status=excluded.extract_status,
+      title=excluded.title,
+      status='active',
+      last_seen_at=excluded.last_seen_at,
+      content_stale=CASE
+        WHEN excluded.file_hash != doc_sources.file_hash
+          OR COALESCE(excluded.extracted_text_hash,'') != COALESCE(doc_sources.extracted_text_hash,'')
+        THEN 1
+        ELSE doc_sources.content_stale
+      END
+  `).run(
+    filePath, fileHash, mtimeMs || null, sizeBytes || null,
+    extractedTextHash || null, fileType, extractor || null,
+    extractStatus || 'pending', title || null, slug,
+    now, now, hashChanged ? 1 : 0
+  );
+}
+
+function getDocSourceByPath(db, filePath) {
+  return db.prepare('SELECT * FROM doc_sources WHERE file_path=?').get(filePath) || null;
+}
+
+function getDocSourceBySlug(db, slug) {
+  return db.prepare('SELECT * FROM doc_sources WHERE slug=?').get(slug) || null;
+}
+
+function listStaleDocSources(db) {
+  return db.prepare("SELECT * FROM doc_sources WHERE content_stale=1 AND status='active'").all();
+}
+
+function markDocSourcesMissing(db, seenPaths) {
+  if (seenPaths.length === 0) return;
+  const set = new Set(seenPaths);
+  // Infer the scan directory from the seen paths so we only mark files
+  // within that directory scope as missing (not docs imported from other paths).
+  const path = require('node:path');
+  const dirs = new Set(seenPaths.map(p => path.dirname(p)));
+  const all = db.prepare("SELECT id, file_path FROM doc_sources WHERE status='active'").all();
+  const missingIds = all
+    .filter(r => dirs.has(path.dirname(r.file_path)) && !set.has(r.file_path))
+    .map(r => r.id);
+  if (missingIds.length === 0) return;
+  const ph = missingIds.map(() => '?').join(',');
+  db.prepare(`UPDATE doc_sources SET status='missing' WHERE id IN (${ph})`).run(...missingIds);
+}
+
+function upsertDocPageLink(db, pageSlug, docSourceId, role) {
+  db.prepare(`
+    INSERT OR IGNORE INTO wiki_page_doc_sources (page_slug, doc_source_id, role)
+    VALUES (?, ?, ?)
+  `).run(pageSlug, docSourceId, role);
+}
+
+function getClusterMemberIds(db, pageSlug) {
+  return db.prepare(
+    "SELECT doc_source_id FROM wiki_page_doc_sources WHERE page_slug=? AND role='cluster_member'"
+  ).all(pageSlug).map(r => r.doc_source_id);
+}
+
+function replaceClusterMembers(db, pageSlug, docSourceIds) {
+  db.exec('BEGIN');
+  try {
+    db.prepare("DELETE FROM wiki_page_doc_sources WHERE page_slug=? AND role='cluster_member'").run(pageSlug);
+    const ins = db.prepare("INSERT INTO wiki_page_doc_sources (page_slug, doc_source_id, role) VALUES (?,?,'cluster_member')");
+    for (const id of docSourceIds) ins.run(pageSlug, id);
+    db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+}
+
+function listClusterPages(db) {
+  return db.prepare(
+    "SELECT slug, membership_hash, cluster_size FROM wiki_pages WHERE source_type='topic_cluster'"
+  ).all();
+}
+
 module.exports = {
   // wiki_pages
   getWikiPageBySlug,
@@ -392,6 +521,7 @@ module.exports = {
   getStalePages,
   upsertWikiPage,
   resetPageStaleness,
+  appendWikiTimeline,
   // wiki_topics
   upsertWikiTopic,
   checkTopicThreshold,
@@ -401,4 +531,15 @@ module.exports = {
   searchWikiAndFacts,
   // staleness
   updateStalenessForTags,
+  // doc_sources CRUD
+  upsertDocSource,
+  getDocSourceByPath,
+  getDocSourceBySlug,
+  listStaleDocSources,
+  markDocSourcesMissing,
+  // wiki_page_doc_sources CRUD
+  upsertDocPageLink,
+  getClusterMemberIds,
+  replaceClusterMembers,
+  listClusterPages,
 };

package/scripts/daemon-bridges.js

@@ -736,21 +736,24 @@ function createBridgeStarter(deps) {
     const { createBot } = require('./feishu-adapter.js');
     const bot = createBot(config.feishu);
 
-    // Validate credentials before starting WebSocket — fail loud, not silent
+    // Credential pre-check is informational only. We always start the WS
+    // pipeline — it has its own network-ready-probe + backoff reconnect, so
+    // even if startup lands in a "just woke / network flaky" window, recovery
+    // is automatic instead of requiring a manual daemon restart.
     try {
       const validation = await bot.validateCredentials();
       if (!validation.ok) {
-        log('ERROR', `Feishu credential check FAILED: ${validation.error}`);
         if (validation.isAuthError) {
-          log('ERROR', 'Feishu bridge will NOT start — fix app_id/app_secret in ~/.metame/daemon.yaml and restart daemon');
-          return null;
+          log('ERROR', `Feishu credential check FAILED (likely bad app_id/app_secret): ${validation.error}`);
+          log('WARN', 'Starting bridge anyway — if this persists, fix ~/.metame/daemon.yaml and restart daemon');
+        } else {
+          log('WARN', `Feishu credential pre-check failed (transient): ${validation.error} — WS pipeline will retry`);
         }
-        log('WARN', 'Feishu credential check failed (possibly network issue) — attempting to start anyway');
       } else {
         log('INFO', 'Feishu credentials validated OK');
       }
     } catch (e) {
-      log('WARN', `Feishu credential pre-check error: ${e.message} — attempting to start anyway`);
+      log('WARN', `Feishu credential pre-check error: ${e.message} — WS pipeline will retry`);
     }
 
     try {

package/scripts/daemon-command-router.js

@@ -613,7 +613,31 @@ function createCommandRouter(deps) {
       await bot.sendMessage(chatId, 'Daily token budget exceeded.');
       return;
     }
-    const claudeResult = await askClaude(bot, chatId, text, config, readOnly, senderId);
+
+    // --- "修" shortcut: inject latest health report as context ---
+    let effectiveText = text;
+    if (text.trim() === '修') {
+      const reportFile = require('path').join(require('os').homedir(), '.metame', 'health-report-latest.json');
+      try {
+        const raw = require('fs').readFileSync(reportFile, 'utf8');
+        const report = JSON.parse(raw);
+        const ageMs = Date.now() - new Date(report.generated_at).getTime();
+        if (ageMs < 48 * 60 * 60 * 1000) { // only if report is within 48h
+          const issues = (report.analysis && report.analysis.issues || [])
+            .map(i => `- ${i.name}（×${i.count}）：${i.fix}`)
+            .join('\n');
+          effectiveText = `请根据以下 daemon 健康报告修复问题：\n\n` +
+            `摘要：${report.analysis.summary}\n` +
+            `建议行动：${report.analysis.action}\n\n` +
+            `问题清单：\n${issues}\n\n` +
+            `报告时间：${report.generated_at}\n` +
+            `请先读取 ~/.metame/daemon.log 确认问题，然后修复 /Users/yaron/AGI/MetaMe/scripts/ 中的对应代码。`;
+          log('INFO', `[health-scan] "修" shortcut: injected health report (${report.total_errors} errors)`);
+        }
+      } catch { /* no report or stale — fall through with original text */ }
+    }
+
+    const claudeResult = await askClaude(bot, chatId, effectiveText, config, readOnly, senderId);
     const claudeFailed = !!(claudeResult && claudeResult.ok === false);
     const claudeAborted = !!(claudeResult && claudeResult.error === 'Stopped by user');
     if (claudeFailed && !claudeAborted && !macLocalFirst && macFallbackEnabled && allowLocalMacControl) {

package/scripts/daemon-default.yaml

@@ -107,6 +107,27 @@ heartbeat:
       notify: false
       enabled: true
 
+    # wiki-sync: 每天 02:30 把所有 wiki 页面（记忆主题、doc/cluster 页、decisions/lessons）同步到 Obsidian vault
+    # 前置条件: daemon.wiki_output_dir 已配置，如: ~/Documents/ObsidianVault/MetaMe/wiki
+    - name: wiki-sync
+      type: script
+      command: >-
+        node -e "
+        const path=require('path'),os=require('os');
+        const {DatabaseSync}=require('node:sqlite');
+        const {runWikiReflect}=require(path.join(os.homedir(),'.metame','wiki-reflect'));
+        const providers=require(path.join(os.homedir(),'.metame','providers'));
+        const db=new DatabaseSync(path.join(os.homedir(),'.metame','memory.db'));
+        const outDir=path.join(os.homedir(),'Documents/ObsidianVault/MetaMe/wiki');
+        runWikiReflect(db,{providers,outputDir:outDir}).then(r=>{
+          console.log('wiki-sync done',JSON.stringify(r));db.close();
+        }).catch(e=>{console.error(e.message);db.close();process.exit(1);});
+        "
+      at: "02:30"
+      require_idle: true
+      notify: false
+      enabled: false  # set to true after verifying wiki_output_dir is correct
+
     # 记忆索引：每天 01:30 更新 ~/.metame/memory/INDEX.md
     - name: memory-index
       type: script
@@ -116,6 +137,16 @@ heartbeat:
       notify: false
       enabled: true
 
+    # Embedding 索引：消费 embedding_queue，生成向量嵌入，30 分钟冷却
+    - name: embedding-index
+      type: script
+      command: node ~/.metame/daemon-embedding.js
+      interval: 30m
+      timeout: 600
+      require_idle: false
+      notify: false
+      enabled: true
+
     # Legacy flat tasks (no project isolation). New tasks should go under projects: above.
     # Examples — uncomment or add your own:
     #

package/scripts/daemon-embedding.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * daemon-embedding.js — Embedding queue consumer
+ *
+ * Processes pending items in embedding_queue:
+ * 1. Reads batch from queue (attempts < 3)
+ * 2. Fetches text from content_chunks
+ * 3. Calls OpenAI embedding API
+ * 4. Writes BLOB + metadata back to content_chunks
+ * 5. Deletes completed queue rows; increments attempts on failure
+ *
+ * Designed to run as heartbeat task (interval: 30min) or post-wiki-reflect trigger.
+ * Graceful degradation: no OPENAI_API_KEY → exits immediately, no error.
+ */
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const DB_PATH = path.join(METAME_DIR, 'memory.db');
+const LOCK_FILE = path.join(METAME_DIR, 'daemon-embedding.lock');
+const LOG_FILE = path.join(METAME_DIR, 'embedding_log.jsonl');
+const LOCK_TIMEOUT_MS = 10 * 60 * 1000;
+const MAX_BATCH = 50;
+
+function loadModule(name) {
+  const candidates = [
+    path.join(HOME, '.metame', name),
+    path.join(__dirname, name),
+  ];
+  for (const p of candidates) {
+    try { return require(p); } catch { }
+  }
+  return null;
+}
+
+async function main() {
+  const embedding = loadModule('core/embedding');
+  if (!embedding || !embedding.isEmbeddingAvailable()) {
+    // No API key — skip silently
+    return;
+  }
+
+  // Atomic lock acquisition
+  try {
+    const fd = fs.openSync(LOCK_FILE, 'wx');
+    fs.writeFileSync(fd, String(process.pid));
+    fs.closeSync(fd);
+  } catch {
+    // Lock exists — check if stale
+    try {
+      const lockAge = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
+      if (lockAge < LOCK_TIMEOUT_MS) return; // another instance running
+      fs.unlinkSync(LOCK_FILE);
+      fs.openSync(LOCK_FILE, 'wx');
+      fs.writeFileSync(LOCK_FILE, String(process.pid));
+    } catch {
+      return; // race lost or fs error
+    }
+  }
+
+  let db;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    db = new DatabaseSync(DB_PATH);
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA busy_timeout = 3000');
+
+    // Ensure schema exists
+    try {
+      const { applyWikiSchema } = loadModule('memory-wiki-schema') || {};
+      if (applyWikiSchema) applyWikiSchema(db);
+    } catch { }
+
+    // Fetch pending queue items
+    const pending = db.prepare(`
+      SELECT eq.id AS queue_id, eq.item_type, eq.item_id, eq.model, eq.attempts,
+             cc.chunk_text
+      FROM embedding_queue eq
+      JOIN content_chunks cc ON eq.item_id = cc.id
+      WHERE eq.item_type = 'chunk'
+        AND eq.attempts < 3
+      ORDER BY eq.created_at ASC
+      LIMIT ?
+    `).all(MAX_BATCH);
+
+    if (pending.length === 0) return;
+
+    // Batch embed
+    const texts = pending.map(p => p.chunk_text);
+    let embeddings;
+    try {
+      embeddings = await embedding.batchEmbed(texts);
+    } catch (err) {
+      // API failure — increment attempts for all
+      const updateAttempts = db.prepare(
+        'UPDATE embedding_queue SET attempts = attempts + 1, last_error = ? WHERE id = ?',
+      );
+      for (const p of pending) {
+        updateAttempts.run(err.message.slice(0, 500), p.queue_id);
+      }
+      appendLog({ ts: new Date().toISOString(), error: err.message, batch_size: pending.length });
+      return;
+    }
+
+    // Write results
+    const updateChunk = db.prepare(`
+      UPDATE content_chunks
+      SET embedding = ?, embedding_model = ?, embedding_dim = ?
+      WHERE id = ?
+    `);
+    const deleteQueue = db.prepare('DELETE FROM embedding_queue WHERE id = ?');
+    const updateAttempts = db.prepare(
+      'UPDATE embedding_queue SET attempts = attempts + 1, last_error = ? WHERE id = ?',
+    );
+
+    let success = 0;
+    let failed = 0;
+    db.prepare('BEGIN').run();
+    try {
+      for (let i = 0; i < pending.length; i++) {
+        const emb = embeddings[i];
+        if (emb) {
+          const buf = embedding.embeddingToBuffer(emb);
+          updateChunk.run(buf, embedding.MODEL, embedding.DIMENSIONS, pending[i].item_id);
+          deleteQueue.run(pending[i].queue_id);
+          success++;
+        } else {
+          updateAttempts.run('null embedding returned', pending[i].queue_id);
+          failed++;
+        }
+      }
+      db.prepare('COMMIT').run();
+    } catch (err) {
+      try { db.prepare('ROLLBACK').run(); } catch { }
+      appendLog({ ts: new Date().toISOString(), error: err.message, batch_size: pending.length });
+      return;
+    }
+
+    appendLog({ ts: new Date().toISOString(), success, failed, batch_size: pending.length });
+
+  } finally {
+    if (db) try { db.close(); } catch { }
+    try { fs.unlinkSync(LOCK_FILE); } catch { }
+  }
+}
+
+function appendLog(entry) {
+  try {
+    fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
+  } catch { }
+}
+
+main().catch(err => {
+  appendLog({ ts: new Date().toISOString(), error: err.message });
+  try { fs.unlinkSync(LOCK_FILE); } catch { }
+});

package/scripts/daemon-engine-runtime.js

@@ -22,7 +22,7 @@ const ENGINE_TIMEOUT_DEFAULTS = Object.freeze({
     ceilingMs: null,
   }),
   claude: Object.freeze({
-    idleMs: 5 * 60 * 1000,
+    idleMs: 20 * 60 * 1000,
     toolMs: 25 * 60 * 1000,
     ceilingMs: null,
   }),

package/scripts/daemon-health-scan.js

@@ -0,0 +1,185 @@
+'use strict';
+
+/**
+ * daemon-health-scan.js — Daily Daemon Health Report
+ *
+ * Reads ~/.metame/daemon.log for last 24h ERROR/WARN entries,
+ * calls LLM (Haiku) to analyze root causes and propose fixes,
+ * saves report to ~/.metame/health-report-latest.json,
+ * then prints a formatted summary to stdout.
+ *
+ * Heartbeat: daily at 08:30 via daemon.yaml
+ * notify: true → daemon sends stdout to Feishu automatically.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { callHaiku, buildDistillEnv } = require('./providers');
+
+const HOME = os.homedir();
+const LOG_FILE = path.join(HOME, '.metame', 'daemon.log');
+const REPORT_FILE = path.join(HOME, '.metame', 'health-report-latest.json');
+const WINDOW_MS = 24 * 60 * 60 * 1000;
+const MAX_UNIQUE_ERRORS = 8;
+const MAX_LINE_LEN = 280;
+
+// Match log lines that contain an ERROR or WARN level tag
+const LEVEL_PATTERN = /\[(ERROR|WARN)\]/;
+// Extract ISO timestamp from log line prefix like [2026-04-10T08:00:00
+const TS_PATTERN = /^\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/;
+
+function readRecentErrors(logFile, windowMs) {
+  let content;
+  try {
+    content = fs.readFileSync(logFile, 'utf8');
+  } catch {
+    return [];
+  }
+
+  const cutoff = Date.now() - windowMs;
+  const lines = content.split('\n').filter(Boolean);
+  const result = [];
+
+  for (const line of lines) {
+    if (!LEVEL_PATTERN.test(line)) continue;
+    const tsMatch = line.match(TS_PATTERN);
+    if (tsMatch) {
+      const ts = new Date(tsMatch[1]).getTime();
+      if (ts < cutoff) continue;
+    }
+    result.push(line.slice(0, MAX_LINE_LEN));
+  }
+
+  return result;
+}
+
+function groupErrors(lines) {
+  const counts = new Map();
+  for (const line of lines) {
+    // Normalize numbers to reduce noise, use first 100 chars as bucket key
+    const key = line.slice(0, 100).replace(/\d+/g, 'N').replace(/[a-f0-9]{8,}/gi, 'HASH');
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  // Sort by frequency descending
+  return Array.from(counts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, MAX_UNIQUE_ERRORS)
+    .map(([key, count]) => ({ key: key.trim(), count }));
+}
+
+async function analyzeWithLLM(grouped, totalCount) {
+  const errorList = grouped
+    .map(({ key, count }) => `[×${count}] ${key}`)
+    .join('\n');
+
+  const prompt = `你是 MetaMe daemon 的健康分析师。以下是过去24小时的错误/警告日志（已去重，按频次排序）：
+
+${errorList}
+
+请分析并以 JSON 格式回复：
+{
+  "summary": "一句话总结（20字以内）",
+  "severity": "low|medium|high",
+  "issues": [
+    {
+      "name": "问题名称（10字以内）",
+      "count": 频次,
+      "cause": "根因（30字以内）",
+      "fix": "修复建议（50字以内）"
+    }
+  ],
+  "action": "最紧迫的下一步行动（30字以内）"
+}
+
+severity 判断：high=影响功能/数据/重复崩溃，medium=有异常但仍可运行，low=轻微警告。
+只输出 JSON，不要解释。`;
+
+  let distillEnv = {};
+  try { distillEnv = buildDistillEnv(); } catch { /* ignore */ }
+
+  try {
+    const raw = await Promise.race([
+      callHaiku(prompt, distillEnv, 60000),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('llm_timeout')), 90000)),
+    ]);
+    const cleaned = raw.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+    const parsed = JSON.parse(cleaned);
+    // Basic validation
+    if (!parsed.summary || !parsed.severity || !Array.isArray(parsed.issues)) {
+      throw new Error('invalid structure');
+    }
+    return parsed;
+  } catch {
+    // Fallback: no LLM
+    return {
+      summary: `发现 ${totalCount} 条错误/警告`,
+      severity: 'medium',
+      issues: grouped.slice(0, 5).map(({ key, count }) => ({
+        name: key.slice(0, 30),
+        count,
+        cause: '待分析',
+        fix: '手动检查 daemon.log',
+      })),
+      action: '手动检查 ~/.metame/daemon.log',
+    };
+  }
+}
+
+function formatReport(analysis, totalCount, uniqueTypes) {
+  const emoji = { low: '🟡', medium: '🟠', high: '🔴' }[analysis.severity] || '🟠';
+  const date = new Date().toLocaleDateString('zh-CN', { month: 'long', day: 'numeric' });
+
+  const issueLines = (analysis.issues || []).slice(0, 5).map(issue =>
+    `• ${issue.name}（×${issue.count}）\n  根因：${issue.cause}\n  建议：${issue.fix}`
+  ).join('\n\n');
+
+  return [
+    `${emoji} Daemon 健康报告 · ${date}`,
+    ``,
+    `📊 过去24h：${totalCount} 条错误/警告，${uniqueTypes} 种类型`,
+    `📝 摘要：${analysis.summary}`,
+    ``,
+    `🔍 问题详情：`,
+    issueLines,
+    ``,
+    `⚡ 建议：${analysis.action}`,
+    ``,
+    `---`,
+    `需要修复？回复「修」，我来处理。`,
+  ].join('\n');
+}
+
+async function run() {
+  const errorLines = readRecentErrors(LOG_FILE, WINDOW_MS);
+
+  if (errorLines.length === 0) {
+    console.log('✅ Daemon 健康正常 · 过去24小时无错误/警告');
+    return;
+  }
+
+  const grouped = groupErrors(errorLines);
+  const analysis = await analyzeWithLLM(grouped, errorLines.length);
+
+  // Save full report for "修" handler to load
+  const report = {
+    generated_at: new Date().toISOString(),
+    total_errors: errorLines.length,
+    unique_types: grouped.length,
+    analysis,
+    raw_grouped: grouped,
+  };
+
+  try {
+    fs.writeFileSync(REPORT_FILE, JSON.stringify(report, null, 2), 'utf8');
+  } catch (e) {
+    process.stderr.write(`[health-scan] failed to write report: ${e.message}\n`);
+  }
+
+  console.log(formatReport(analysis, errorLines.length, grouped.length));
+}
+
+run().catch(e => {
+  process.stderr.write(`[daemon-health-scan] fatal: ${e.message}\n`);
+  process.exit(1);
+});

package/scripts/daemon-runtime-lifecycle.js

@@ -153,7 +153,7 @@ function setupRuntimeWatchers(deps) {
     refreshLogMaxSize(newConfig);
     const timer = getHeartbeatTimer();
     if (timer) clearInterval(timer);
-    setHeartbeatTimer(startHeartbeat(newConfig, notifyFn, notifyPersonalFn));
+    setHeartbeatTimer(startHeartbeat(newConfig, notifyFn, notifyPersonalFn, adminNotifyFn));
     const { general, project } = getAllTasks(newConfig);
     const totalCount = general.length + project.length;
     log('INFO', `Config reloaded: ${totalCount} tasks (${project.length} in projects)`);