metame-cli 1.5.26 → 1.6.1

package/scripts/daemon-wiki.js

@@ -0,0 +1,420 @@
+'use strict';
+
+/**
+ * daemon-wiki.js — /wiki command handler
+ *
+ * Subcommands (Phase 1):
+ *   /wiki                     — list all wiki pages (title, staleness, last_built)
+ *   /wiki research <query>    — search wiki + facts, format answer (trackSearch: true)
+ *   /wiki page <slug>         — show full content of a page
+ *   /wiki sync                — force rebuild stale pages (staleness ≥ 0.4)
+ *   /wiki pin <tag> [title]   — manually register a topic (force=true, pinned=1)
+ *   /wiki open                — open Obsidian vault
+ *
+ * Exports:
+ *   createWikiCommandHandler(deps) → { handleWikiCommand }
+ */
+
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const {
+  listWikiPages,
+  getWikiPageBySlug,
+  searchWikiAndFacts,
+  upsertWikiTopic,
+} = require('./core/wiki-db');
+
+const STALENESS_THRESHOLD = 0.4;
+const DEFAULT_WIKI_DIR = path.join(os.homedir(), 'Documents', 'MetaMe-Wiki');
+
+function createWikiCommandHandler(deps) {
+  const {
+    getDb,                    // () → DatabaseSync
+    providers,                // { callHaiku, buildDistillEnv }
+    wikiOutputDir,            // optional — path to Obsidian vault wiki folder
+    log = () => {},
+  } = deps;
+
+  const outputDir = wikiOutputDir || DEFAULT_WIKI_DIR;
+
+  /**
+   * Main entry point. Returns true if /wiki command was handled.
+   * @param {{ bot: object, chatId: string, text: string }} ctx
+   * @returns {Promise<boolean>}
+   */
+  async function handleWikiCommand(ctx) {
+    const { bot, chatId, text } = ctx;
+    if (typeof text !== 'string') return false;
+
+    const trimmed = text.trim();
+    if (trimmed === '/wiki') {
+      await _handleList(bot, chatId);
+      return true;
+    }
+    if (trimmed === '/wiki research' || trimmed.startsWith('/wiki research ')) {
+      const query = trimmed.slice(15).trim();
+      await _handleResearch(bot, chatId, query);
+      return true;
+    }
+    if (trimmed === '/wiki page' || trimmed.startsWith('/wiki page ')) {
+      const slug = trimmed.slice(11).trim();
+      await _handlePage(bot, chatId, slug);
+      return true;
+    }
+    if (trimmed === '/wiki sync') {
+      await _handleSync(bot, chatId);
+      return true;
+    }
+    if (trimmed === '/wiki pin' || trimmed.startsWith('/wiki pin ')) {
+      const args = trimmed.slice(10).trim();
+      await _handlePin(bot, chatId, args);
+      return true;
+    }
+    if (trimmed === '/wiki open') {
+      await _handleOpen(bot, chatId);
+      return true;
+    }
+    if (trimmed === '/wiki help' || trimmed === '/wiki ?') {
+      await _handleHelp(bot, chatId);
+      return true;
+    }
+    if (trimmed === '/wiki import' || trimmed.startsWith('/wiki import ')) {
+      const args = trimmed.slice(12).trim();
+      await _handleImport(bot, chatId, args);
+      return true;
+    }
+    // Unknown /wiki subcommand — show help
+    if (trimmed.startsWith('/wiki ')) {
+      await _handleHelp(bot, chatId);
+      return true;
+    }
+
+    return false;
+  }
+
+  // ── Subcommand handlers ──────────────────────────────────────────────────────
+
+  async function _handleList(bot, chatId) {
+    const db = getDb();
+    const pages = listWikiPages(db, { limit: 50, orderBy: 'title' });
+
+    if (pages.length === 0) {
+      await bot.sendMessage(chatId,
+        '📚 Wiki 暂无页面。\n\n使用 `/wiki pin <标签> [标题]` 手工注册第一个主题。'
+      );
+      return;
+    }
+
+    const lines = ['📚 **知识 Wiki**', ''];
+    for (const p of pages) {
+      const stalePct = Math.round((p.staleness || 0) * 100);
+      const built = p.last_built_at ? p.last_built_at.slice(0, 10) : '未建';
+      const staleFlag = p.staleness >= STALENESS_THRESHOLD ? ' ⚠️' : '';
+      lines.push(`• **${p.title}** \`${p.slug}\`${staleFlag}`);
+      lines.push(`  来源:${p.raw_source_count || 0} 条 · 陈旧度:${stalePct}% · 更新:${built}`);
+    }
+    lines.push('');
+    lines.push(`共 ${pages.length} 页 · \`/wiki research <关键词>\` 搜索`);
+
+    await bot.sendMessage(chatId, lines.join('\n'));
+  }
+
+  async function _handleResearch(bot, chatId, query) {
+    if (!query) {
+      await bot.sendMessage(chatId, '用法: `/wiki research <关键词>`');
+      return;
+    }
+
+    const db = getDb();
+    let wikiPages, facts;
+    try {
+      const { hybridSearchWiki } = require('./core/hybrid-search');
+      ({ wikiPages, facts } = await hybridSearchWiki(db, query, { trackSearch: true }));
+    } catch (err) {
+      log('WARN', `[wiki-research] hybrid search fallback to FTS: ${err.message}`);
+      ({ wikiPages, facts } = searchWikiAndFacts(db, query, { trackSearch: true }));
+    }
+
+    if (wikiPages.length === 0 && facts.length === 0) {
+      await bot.sendMessage(chatId,
+        `🔍 未找到与「${query}」相关的知识。\n\n可用 \`/wiki pin ${query}\` 手工注册主题，或等待记忆积累后自动建页。`
+      );
+      return;
+    }
+
+    const lines = [`🔍 **「${query}」相关知识**`, ''];
+
+    for (const wp of wikiPages.slice(0, 3)) {
+      const built = wp.last_built_at ? wp.last_built_at.slice(0, 10) : '—';
+      lines.push(`📖 **${wp.title}**`);
+      if (wp.excerpt) lines.push(wp.excerpt.replace(/<\/?b>/g, '**'));
+      lines.push(`来源: \`${wp.slug}\` · 更新于 ${built}`);
+      lines.push('');
+    }
+
+    if (facts.length > 0) {
+      lines.push(`📌 **相关事实** (${facts.length} 条)`);
+      for (const f of facts.slice(0, 5)) {
+        const title = f.title ? `**${f.title}** ` : '';
+        const excerpt = f.excerpt
+          ? f.excerpt.replace(/<\/?b>/g, '**').slice(0, 120)
+          : (f.content || '').slice(0, 120);
+        lines.push(`• ${title}${excerpt}`);
+      }
+    }
+
+    await bot.sendMessage(chatId, lines.join('\n'));
+  }
+
+  async function _handlePage(bot, chatId, slug) {
+    if (!slug) {
+      await bot.sendMessage(chatId, '用法: `/wiki page <slug>`');
+      return;
+    }
+
+    const db = getDb();
+    const page = getWikiPageBySlug(db, slug);
+
+    if (!page) {
+      await bot.sendMessage(chatId, `❌ 未找到页面 \`${slug}\`\n\n用 \`/wiki\` 查看所有页面。`);
+      return;
+    }
+
+    const built = page.last_built_at ? page.last_built_at.slice(0, 10) : '未建';
+    const stalePct = Math.round((page.staleness || 0) * 100);
+
+    const lines = [
+      `📄 **${page.title}**`,
+      `_标签: ${page.primary_topic} · 来源: ${page.raw_source_count || 0} 条 · 陈旧度: ${stalePct}% · 更新: ${built}_`,
+      '',
+      page.content,
+    ];
+
+    await bot.sendMessage(chatId, lines.join('\n'));
+  }
+
+  async function _handleSync(bot, chatId) {
+    const db = getDb();
+    const pages = listWikiPages(db, { limit: 200 });
+    const staleCount = pages.filter(p => (p.staleness || 0) >= STALENESS_THRESHOLD).length;
+
+    if (staleCount === 0) {
+      await bot.sendMessage(chatId, `✅ Wiki 已是最新状态，无需重建。`);
+      return;
+    }
+
+    await bot.sendMessage(chatId, `🔄 开始重建 ${staleCount} 个陈旧页面...`);
+
+    try {
+      const { runWikiReflect } = require('./wiki-reflect');
+      const result = await runWikiReflect(db, {
+        providers,
+        outputDir,
+        threshold: STALENESS_THRESHOLD,
+      });
+
+      const lines = ['✅ Wiki 重建完成'];
+      if (result.built.length > 0) {
+        lines.push(`• 重建: ${result.built.join(', ')}`);
+        try {
+          const { execFile } = require('child_process');
+          const embScript = path.join(os.homedir(), '.metame', 'daemon-embedding.js');
+          execFile('node', [embScript], { timeout: 120000, stdio: 'ignore' }, (err) => {
+            if (err) log('WARN', `[wiki-sync] embedding trigger failed: ${err.message}`);
+          });
+        } catch { }
+      }
+      if (result.failed.length > 0) {
+        lines.push(`• 失败: ${result.failed.map(f => f.slug).join(', ')}`);
+      }
+      if (result.exportFailed.length > 0) {
+        lines.push(`• 文件导出失败 (DB 已更新): ${result.exportFailed.join(', ')}`);
+      }
+      await bot.sendMessage(chatId, lines.join('\n'));
+
+      // Phased doc + cluster rebuild (wiki-import feature extension)
+      const { listStaleDocSources } = require('./core/wiki-db');
+      const { buildDocWikiPage } = require('./wiki-reflect-build');
+      const { extractText } = require('./wiki-extract');
+      const allDocSlugsForSync = db.prepare("SELECT slug FROM doc_sources WHERE status='active'").all().map(r => r.slug);
+      const staleDocSources = listStaleDocSources(db);
+      const builtDocSlugs = [];
+      for (const docSrc of staleDocSources) {
+        try {
+          const { text } = await extractText(docSrc.file_path);
+          const docResult = await buildDocWikiPage(db, docSrc, text, { allowedSlugs: allDocSlugsForSync, providers });
+          if (docResult) {
+            db.prepare("UPDATE doc_sources SET content_stale=0, built_at=? WHERE id=?")
+              .run(new Date().toISOString(), docSrc.id);
+            builtDocSlugs.push(docSrc.slug);
+          }
+        } catch (docErr) {
+          db.prepare("UPDATE doc_sources SET error_message=? WHERE id=?").run(docErr.message, docSrc.id);
+          log('WARN', `[wiki-sync] doc rebuild failed ${docSrc.slug}: ${docErr.message}`);
+        }
+      }
+      // Cascade stale cluster pages
+      if (builtDocSlugs.length > 0) {
+        const ph = builtDocSlugs.map(() => '?').join(',');
+        const affected = db.prepare(`SELECT DISTINCT page_slug FROM wiki_page_doc_sources
+          WHERE role='cluster_member' AND doc_source_id IN
+          (SELECT id FROM doc_sources WHERE slug IN (${ph}))`).all(...builtDocSlugs).map(r => r.page_slug);
+        if (affected.length) {
+          db.prepare(`UPDATE wiki_pages SET staleness=1 WHERE slug IN (${affected.map(() => '?').join(',')})`).run(...affected);
+        }
+      }
+      // Rebuild stale cluster pages after embedding drain
+      const { waitForEmbeddingDrain } = require('./wiki-import');
+      const phase1ChunkIds = builtDocSlugs.flatMap(slug =>
+        db.prepare("SELECT id FROM content_chunks WHERE page_slug=?").all(slug).map(c => c.id)
+      );
+      const drainedOk = await waitForEmbeddingDrain(db, phase1ChunkIds, (msg) => log('INFO', msg));
+      if (drainedOk) {
+        const { buildTopicClusterPage } = require('./wiki-reflect-build');
+        const { getClusterMemberIds } = require('./core/wiki-db');
+        const staleClusterPages = db.prepare("SELECT * FROM wiki_pages WHERE source_type='topic_cluster' AND staleness=1").all();
+        for (const cp of staleClusterPages) {
+          const memberIds = getClusterMemberIds(db, cp.slug);
+          const getDocSrcById = db.prepare("SELECT * FROM doc_sources WHERE id=?");
+          const docRows = memberIds.map(id => getDocSrcById.get(id)).filter(Boolean);
+          try {
+            await buildTopicClusterPage(db, docRows, { allowedSlugs: allDocSlugsForSync, providers, existingClusters: [] });
+          } catch (clErr) {
+            log('WARN', `[wiki-sync] cluster rebuild failed ${cp.slug}: ${clErr.message}`);
+          }
+        }
+      }
+      if (staleDocSources.length > 0) {
+        const docMsg = [];
+        if (builtDocSlugs.length > 0) docMsg.push(`• 文档页面重建: ${builtDocSlugs.join(', ')}`);
+        const docFailed = staleDocSources.length - builtDocSlugs.length;
+        if (docFailed > 0) docMsg.push(`• 文档重建失败: ${docFailed} 个（见日志）`);
+        if (docMsg.length > 0) {
+          await bot.sendMessage(chatId, `📄 文档页面同步\n\n${docMsg.join('\n')}`);
+        }
+      }
+    } catch (err) {
+      log('ERROR', `[wiki-sync] ${err.message}`);
+      if (err.message.includes('another instance')) {
+        await bot.sendMessage(chatId, '⚠️ Wiki 重建正在进行中，请稍后再试。');
+      } else {
+        await bot.sendMessage(chatId, `❌ Wiki 重建失败: ${err.message}`);
+      }
+    }
+  }
+
+  async function _handlePin(bot, chatId, args) {
+    if (!args) {
+      await bot.sendMessage(chatId, '用法: `/wiki pin <标签> [显示名称]`\n例: `/wiki pin session Session管理`');
+      return;
+    }
+
+    // Parse: first token = tag, rest = label
+    const parts = args.split(/\s+/);
+    const tag = parts[0];
+    const label = parts.slice(1).join(' ') || tag;
+
+    const db = getDb();
+    try {
+      const { slug, isNew } = upsertWikiTopic(db, tag, { label, pinned: 1, force: true });
+      if (isNew) {
+        await bot.sendMessage(chatId,
+          `📌 已注册主题 \`${tag}\` (slug: \`${slug}\`)\n\n使用 \`/wiki sync\` 构建页面，或等待每周自动重建。`
+        );
+      } else {
+        await bot.sendMessage(chatId,
+          `📌 主题 \`${tag}\` 已更新标题为「${label}」，pinned=1。`
+        );
+      }
+    } catch (err) {
+      log('ERROR', `[wiki-pin] ${err.message}`);
+      await bot.sendMessage(chatId, `❌ 注册失败: ${err.message}`);
+    }
+  }
+
+  async function _handleOpen(bot, chatId) {
+    try {
+      // Ensure the vault directory exists (may not yet have any pages)
+      const fs = require('fs');
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+      // Try Obsidian URI first (opens vault by path if already configured)
+      const vaultName = path.basename(outputDir);
+      try {
+        execFileSync('open', [`obsidian://open?vault=${encodeURIComponent(vaultName)}`], { timeout: 5000 });
+      } catch {
+        // Fallback: open folder in Finder — user can then drag into Obsidian
+        execFileSync('open', [outputDir], { timeout: 5000 });
+      }
+      await bot.sendMessage(chatId,
+        `📂 已打开 Obsidian vault: \`${outputDir}\`\n\n` +
+        `如果是第一次打开，请在 Obsidian 里选 **Open folder as vault** 并选择该目录。\n` +
+        `之后用 \`/wiki sync\` 生成页面。`
+      );
+    } catch (err) {
+      log('ERROR', `[wiki-open] ${err.message}`);
+      await bot.sendMessage(chatId, `❌ 打开失败: ${err.message}\n\nVault 路径: \`${outputDir}\``);
+    }
+  }
+
+  async function _handleImport(bot, chatId, args) {
+    const noCluster = args.includes('--no-cluster');
+    const inputPath = args.replace('--no-cluster', '').trim();
+
+    if (!inputPath) {
+      await bot.sendMessage(chatId, '用法: `/wiki import <路径或文件>` [--no-cluster]\n\n示例:\n`/wiki import ~/Documents/notes`\n`/wiki import ~/report.pdf`');
+      return;
+    }
+
+    const resolvedPath = inputPath.replace(/^~/, require('node:os').homedir());
+
+    let stat;
+    try { stat = require('node:fs').statSync(resolvedPath); }
+    catch { await bot.sendMessage(chatId, `❌ 路径不存在: ${resolvedPath}`); return; }
+
+    const isDir = stat.isDirectory();
+    await bot.sendMessage(chatId, `⏳ 开始导入 ${isDir ? '目录' : '文件'}: \`${resolvedPath}\`\n${noCluster ? '（跳过聚类）' : '（含自动聚类）'}`);
+
+    const { runWikiImport } = require('./wiki-import');
+    const db = getDb();
+    const logFn = (msg) => { log('INFO', msg); };
+
+    try {
+      const stats = await runWikiImport(db, resolvedPath, {
+        providers, noCluster, log: logFn,
+      });
+      await bot.sendMessage(chatId,
+        `✅ 导入完成\n\n` +
+        `- 新建/更新页面: ${stats.imported}\n` +
+        `- 跳过 (未变更): ${stats.skipped}\n` +
+        `- 失败: ${stats.failed}\n` +
+        `- 聚类页面: ${stats.clusters}\n\n` +
+        `使用 \`/wiki\` 查看全部页面`
+      );
+    } catch (err) {
+      log('ERROR', `[wiki-import] ${err.message}`);
+      await bot.sendMessage(chatId, `❌ 导入失败: ${err.message}`);
+    }
+  }
+
+  async function _handleHelp(bot, chatId) {
+    await bot.sendMessage(chatId, [
+      '📚 **Wiki 命令**',
+      '',
+      '`/wiki` — 列出所有知识页',
+      '`/wiki research <关键词>` — 搜索知识',
+      '`/wiki page <slug>` — 查看页面全文',
+      '`/wiki sync` — 重建陈旧页面',
+      '`/wiki import <路径>` — 导入本地文档 (md/txt/PDF)',
+      '`/wiki pin <标签> [标题]` — 手工注册主题',
+      '`/wiki open` — 在 Obsidian 中打开 vault',
+    ].join('\n'));
+  }
+
+  return { handleWikiCommand };
+}
+
+module.exports = { createWikiCommandHandler };

package/scripts/daemon.js

@@ -1992,6 +1992,10 @@ const { handleAdminCommand } = createAdminCommandHandler({
   getDistillModel,
 });
 
+// Warm process pool for eliminating Claude CLI cold-start latency
+// Must be created before createSessionCommandHandler so releaseWarmPool can be passed in.
+const warmPool = createWarmPool({ log });
+
 const { handleSessionCommand } = createSessionCommandHandler({
   fs,
   path,
@@ -2021,14 +2025,12 @@ const { handleSessionCommand } = createSessionCommandHandler({
   getSessionRecentDialogue,
   sessionLabel,
   getDefaultEngine,
+  releaseWarmPool: (key) => warmPool.releaseWarm(key),
 });
 
 // Message queue for messages received while a task is running
 const messageQueue = new Map(); // chatId -> { messages: string[], notified: false }
 
-// Warm process pool for eliminating Claude CLI cold-start latency
-const warmPool = createWarmPool({ log });
-
 const { spawnClaudeAsync, askClaude } = createClaudeEngine({
   fs,
   path,
@@ -2258,6 +2260,7 @@ const { startTelegramBridge, startFeishuBridge, startWeixinBridge, startImessage
   saveState,
   getSession,
   restoreSessionFromReply,
+  releaseWarmPool: (key) => warmPool.releaseWarm(key),
   handleCommand,
   pipeline,
   pendingActivations,
@@ -2384,7 +2387,7 @@ async function main() {
   }
 
   // Config validation: warn on unknown/suspect fields
-  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'weixin', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge'];
+  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'weixin', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge', 'hooks'];
   const KNOWN_DAEMON = [
     'model',          // legacy (still valid as fallback)
     'models',         // per-engine model map: { claude, codex }
@@ -2399,6 +2402,8 @@ async function main() {
     'mac_control_mode',
     'enable_nl_mac_control',
     'enable_nl_mac_fallback',
+    'wiki_output_dir',       // wiki export path (used by daemon-command-router)
+    'skill_evolution_notify', // whether to notify on skill evolution (used by daemon-task-scheduler)
   ];
   for (const key of Object.keys(config)) {
     if (!KNOWN_SECTIONS.includes(key)) log('WARN', `Config: unknown section "${key}" (typo?)`);
@@ -2507,7 +2512,7 @@ async function main() {
   };
 
   // Start heartbeat scheduler
-  let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn);
+  let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn, adminNotifyFn);
 
   let shuttingDown = false;
   function spawnReplacementDaemon(reason) {

package/scripts/distill.js

@@ -221,7 +221,7 @@ ${promptInput}
 
   fs.mkdirSync(POSTMORTEM_DIR, { recursive: true });
   const day = new Date().toISOString().slice(0, 10);
-  const topicSlug = sanitizeSlug(title || skeleton.intent, `session-${String(skeleton.session_id || '').slice(0, 8)}`);
+  const topicSlug = sanitizeSlug(skeleton.intent || title, `session-${String(skeleton.session_id || '').slice(0, 8)}`);
   const filePath = path.join(POSTMORTEM_DIR, `${day}-${topicSlug}.md`);
   const markdown = [
     `# ${title}`,

package/scripts/docs/file-transfer.md

@@ -30,4 +30,3 @@
 - **永远不要读取再复述文件内容**，直接用 `[[FILE:...]]` 标记发送
 - 路径必须是绝对路径
 - daemon 会自动解析标记并通过 bot 发送给用户
-- **⛔ 禁止发到 open_id**：即使系统上下文中存在用户的飞书 `ou_...` ID，也绝不用它发文件。`[[FILE:...]]` 会自动发到**当前对话群**，这才是正确行为。直接发 open_id 会导致文件出现在 bot 和用户的 1-on-1 私聊，而不在当前群里。

package/scripts/docs/maintenance-manual.md

@@ -362,60 +362,7 @@ Claude 看到 hook 注入:
 - `/dispatch to windows:hunter <任务>`：手动跨设备派发
 - `/dispatch to 猎手 <任务>`：按昵称解析，自动检测 `member.peer` 走远端
 
-## 12. 永续任务系统（Perpetual Task Engine）
-
-### 概念
-
-永续任务系统允许任何项目作为 reactive 永续循环运行。Agent 产出信号 → daemon 解析 → 门控检查 → 调度下一步。平台完全领域无关，科研、代码审计、文档维护等任何长期任务均可接入。
-
-### 核心组件
-
-| 组件 | 文件 | 职责 |
-|------|------|------|
-| Reactive Lifecycle | `daemon-reactive-lifecycle.js` | 信号解析、budget/depth gate、事件溯源、verifier 调用、state 生成 |
-| Event Log | `~/.metame/events/<key>.jsonl` | 唯一 Source of Truth，daemon 独占写入 |
-| Manifest | `<cwd>/perpetual.yaml` | 可选项目清单（completion_signal、脚本路径、约束） |
-| Reconciliation | `reconcilePerpetualProjects()` | heartbeat 中零 token 停滞检测 |
-| Status 命令 | `/status perpetual` | 查看所有永续项目的 phase/depth/mission/status |
-
-### 接入一个新永续项目
-
-1. 在 `daemon.yaml` 中注册项目，添加 `reactive: true`
-2. 在项目目录创建 `CLAUDE.md`（定义 agent 行为）
-3. 可选：创建 `scripts/verifier.js`（阶段门控）
-4. 可选：创建 `perpetual.yaml`（覆盖默认约定）
-5. 可选：创建 `scripts/archiver.js` + `scripts/mission-queue.js`（归档与任务队列）
-
-不创建 perpetual.yaml 时，平台使用默认约定：
-- Verifier: `scripts/verifier.js`
-- Archiver: `scripts/archiver.js`
-- Mission Queue: `scripts/mission-queue.js`
-- 完成信号: `MISSION_COMPLETE`
-
-### 事件溯源协议
-
-所有状态变更记录在 `~/.metame/events/<projectKey>.jsonl`，一行一个 JSON 事件。`now/<key>.md` 和 `workspace/progress.tsv` 都是 event log 的投影（Projection），可随时从 event log 重建。
-
-Event 类型：`MISSION_START` / `DISPATCH` / `MEMBER_COMPLETE` / `PHASE_GATE` / `DEPTH_LIMIT` / `BUDGET_LIMIT` / `MISSION_COMPLETE` / `ARCHIVE` / `STALE` / `INFRA_PAUSE`
-
-### 设计契约
-
-1. **Tolerant Reader**：`replayEventLog` 逐行解析，损坏行 WARN + skip，绝不 crash
-2. **Error Semantic Isolation**：verifier L2b 区分 404（幻觉，打回 agent）和 50x（基建故障，挂起项目通知人类）
-3. **State 由 daemon 生成**：agent 只读 `now/<key>.md`，不负责维护
-
-### 故障排查
-
-| 症状 | 检查 |
-|------|------|
-| 永续项目不启动 | `daemon.yaml` 中是否有 `reactive: true`？ |
-| 完成信号不触发 | 检查 `perpetual.yaml` 中的 `completion_signal` 是否与 CLAUDE.md 一致 |
-| Verifier 不运行 | 检查 `scripts/verifier.js` 路径（或 manifest 中的自定义路径）是否存在 |
-| 项目挂起 (infra_failure) | 外部 API 不可用，检查网络。非 agent 错误。 |
-| Event log 损坏 | 重启后 replay 会跳过损坏行。`progress.tsv` 和 `now/<key>.md` 可从 event log 重建 |
-| `/status perpetual` 无输出 | 确认项目配置了 `reactive: true` |
-
-## 13. 私人配置保护（原 §12）
+## 12. 私人配置保护
 
 - `daemon.yaml` 是用户私人配置，包含 API keys、chat IDs、个人项目配置
 - **绝不上传**到代码仓库，已加入 `.gitignore`
@@ -424,7 +371,7 @@ Event 类型：`MISSION_START` / `DISPATCH` / `MEMBER_COMPLETE` / `PHASE_GATE` /
 - 同样不应上传的文件：`MEMORY.md`、`SOUL.md`、`.env*`
 - Agent 在执行任务时，**绝不能** `cp scripts/daemon.yaml ~/.metame/daemon.yaml`，这会覆盖用户私人配置
 
-## 14. 变更后维护动作
+## 13. 变更后维护动作
 
 1. 测试：
    - `npm test`（全量）

package/scripts/docs/pointer-map.md

@@ -140,39 +140,6 @@
   - `scripts/memory.js`：`saveFactLabels()` 原子写入 API
   - `scripts/memory-nightly-reflect.js`：`synthesized_insight` 回写、知识胶囊聚合与 `knowledge_capsule` 回写
 
-## 永续任务系统（Perpetual Task Engine）
-
-- Reactive 生命周期引擎：
-  - `scripts/daemon-reactive-lifecycle.js`
-  - 关键点：`handleReactiveOutput()` 通用任务链引擎（领域无关）；
-    `parseReactiveSignals()` 信号解析（NEXT_DISPATCH + 可配完成信号）；
-    `reconcilePerpetualProjects()` 停滞检测（零 token，heartbeat 驱动）；
-    `replayEventLog()` 事件溯源状态重放；
-    `generateStateFile()` 从 event log 生成 `now/<key>.md`（投影）；
-    `appendEvent()` 追加事件到 `~/.metame/events/<key>.jsonl`（唯一 SoT）；
-    `loadProjectManifest()` 读取项目 `perpetual.yaml`（convention over config）；
-    `resolveProjectScripts()` 按约定/manifest 发现 verifier/archiver/mission-queue 脚本
-
-- daemon.js 接入点：
-  - `scripts/daemon.js` `outputHandler` 内 `handleReactiveOutput` 调用（try/catch 隔离）
-  - `scripts/daemon.js` `physiologicalHeartbeat` 内 `reconcilePerpetualProjects` 调用
-
-- 可观测命令：
-  - `scripts/daemon-admin-commands.js`
-  - 关键点：`/status perpetual`（或 `/status reactive`）显示所有永续项目状态
-
-- 设计文档：
-  - `docs/perpetual-task-system-design.md`（v4，含 4 份附录）
-  - `docs/perpetual-task-system-plan.md`（实施计划，Phase A-C）
-
-- 项目清单协议：
-  - `<cwd>/perpetual.yaml` — 可选，声明 completion_signal / verifier / archiver / mission_queue 路径
-  - 不存在时使用默认约定：`scripts/verifier.js`、`scripts/archiver.js`、`scripts/mission-queue.js`、信号 `MISSION_COMPLETE`
-
-- 事件日志：
-  - `~/.metame/events/<projectKey>.jsonl` — append-only，daemon 独占写入
-  - Event 类型：MISSION_START / DISPATCH / MEMBER_COMPLETE / PHASE_GATE / DEPTH_LIMIT / BUDGET_LIMIT / MISSION_COMPLETE / ARCHIVE / STALE / INFRA_PAUSE
-
 ## 运行时数据位置
 
 - 画像：`~/.claude_profile.yaml`
@@ -184,7 +151,6 @@
 - 复盘文档：`~/.metame/memory/postmortems/`
 - Dispatch 队列：`~/.metame/dispatch/pending.jsonl`（本地 socket 降级）
 - 远端 Dispatch 队列：`~/.metame/dispatch/remote-pending.jsonl`（跨设备中继）
-- **永续任务事件日志**：`~/.metame/events/<projectKey>.jsonl`（唯一 SoT，append-only）
 - 共享进度白板：`~/.metame/memory/now/shared.md`
 - Agent 最新产出：`~/.metame/memory/agents/{key}_latest.md`
 - Agent 收件箱：`~/.metame/memory/inbox/{key}/`（未读），`read/`（已归档）

package/scripts/feishu-adapter.js

@@ -393,11 +393,14 @@ function createBot(config) {
       let stopped = false;
       let currentWs = null;
       let healthTimer = null;
+      let sleepWakeTimer = null;
       let reconnectTimer = null;
       let reconnectDelay = 5000; // start 5s, doubles up to 60s
       const MAX_RECONNECT_DELAY = 60000;
       const HEALTH_CHECK_INTERVAL = 90000; // check every 90s
       const SILENT_THRESHOLD = 300000; // 5 min no SDK activity → suspect dead
+      const SLEEP_DETECT_INTERVAL = 5000; // tick every 5s to detect clock jump
+      const SLEEP_JUMP_THRESHOLD = 30000; // clock jump >30s = system was sleeping
 
       // Track last SDK activity (any event received = alive)
       let _lastActivityAt = Date.now();
@@ -538,15 +541,37 @@ function createBot(config) {
         }, HEALTH_CHECK_INTERVAL);
       }
 
+      // Sleep/wake detector: if the JS clock jumps >30s, system was sleeping → force reconnect
+      function startSleepWakeDetector() {
+        let _lastTickAt = Date.now();
+        sleepWakeTimer = setInterval(() => {
+          if (stopped) return;
+          const now = Date.now();
+          const elapsed = now - _lastTickAt;
+          _lastTickAt = now;
+          if (elapsed > SLEEP_JUMP_THRESHOLD) {
+            _log('INFO', `System wake detected (${Math.round(elapsed / 1000)}s gap) — forcing reconnect`);
+            reconnectDelay = 5000;
+            clearTimeout(reconnectTimer);
+            try { currentWs?.stop?.(); } catch { /* ignore */ }
+            currentWs = null;
+            touchActivity(); // reset silence counter so health check doesn't double-fire
+            connect();
+          }
+        }, SLEEP_DETECT_INTERVAL);
+      }
+
       // Initial connect
       connect();
       startHealthCheck();
+      startSleepWakeDetector();
 
       return Promise.resolve({
         stop() {
           stopped = true;
           clearTimeout(reconnectTimer);
           clearInterval(healthTimer);
+          clearInterval(sleepWakeTimer);
           currentWs = null;
         },
         reconnect() {

package/scripts/hooks/intent-file-transfer.js

@@ -35,10 +35,9 @@ module.exports = function detectFileTransfer(prompt) {
 
   if (isSend) {
     hints.push(
-      '- **发送文件到手机**：在回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发到**当前对话群**',
+      '- **发送文件到手机**：在回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发送',
       '- 多个文件用多个 `[[FILE:...]]` 标记',
       '- **不要读取文件内容再复述**，直接用标记发送（省 token）',
-      '- **⛔ 严禁发到 open_id**：即使上下文中有 `ou_...` 用户ID，也绝对不用它发文件——那会发到 bot 私聊而非当前群',
     );
   }