metame-cli 1.6.0 → 1.6.2

package/scripts/daemon-task-scheduler.js

@@ -660,7 +660,7 @@ function createTaskScheduler(deps) {
     return found || null;
   }
 
-  function startHeartbeat(config, notifyFn, notifyPersonalFn) {
+  function startHeartbeat(config, notifyFn, notifyPersonalFn, adminNotifyFn) {
     const { all: tasks } = getAllTasks(config);
 
     const enabledTasks = tasks.filter(t => t.enabled !== false);
@@ -787,10 +787,12 @@ function createTaskScheduler(deps) {
               }
               if (task.notify && notifyFn && !result.skipped) {
                 const proj = task._project || null;
+                // Tasks without a project are system-level — send to admin chat only
+                const sendFn = proj ? notifyFn : (adminNotifyFn || notifyFn);
                 if (result.success) {
-                  notifyFn(`✅ *${task.name}* completed\n\n${result.output}`, proj);
+                  sendFn(`✅ *${task.name}* completed\n\n${result.output}`, proj);
                 } else {
-                  notifyFn(`❌ *${task.name}* failed: ${result.error}`, proj);
+                  sendFn(`❌ *${task.name}* failed: ${result.error}`, proj);
                 }
               }
             })

package/scripts/daemon-wiki.js

@@ -17,7 +17,7 @@
 
 const os = require('os');
 const path = require('path');
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 
 const {
   listWikiPages,
@@ -80,6 +80,11 @@ function createWikiCommandHandler(deps) {
       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);
@@ -123,7 +128,14 @@ function createWikiCommandHandler(deps) {
     }
 
     const db = getDb();
-    const { wikiPages, facts } = searchWikiAndFacts(db, query, { trackSearch: true });
+    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,
@@ -206,6 +218,13 @@ function createWikiCommandHandler(deps) {
       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(', ')}`);
@@ -214,6 +233,68 @@ function createWikiCommandHandler(deps) {
         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')) {
@@ -263,10 +344,10 @@ function createWikiCommandHandler(deps) {
       // Try Obsidian URI first (opens vault by path if already configured)
       const vaultName = path.basename(outputDir);
       try {
-        execSync(`open "obsidian://open?vault=${encodeURIComponent(vaultName)}"`, { timeout: 5000 });
+        execFileSync('open', [`obsidian://open?vault=${encodeURIComponent(vaultName)}`], { timeout: 5000 });
       } catch {
         // Fallback: open folder in Finder — user can then drag into Obsidian
-        execSync(`open "${outputDir}"`, { timeout: 5000 });
+        execFileSync('open', [outputDir], { timeout: 5000 });
       }
       await bot.sendMessage(chatId,
         `📂 已打开 Obsidian vault: \`${outputDir}\`\n\n` +
@@ -279,6 +360,46 @@ function createWikiCommandHandler(deps) {
     }
   }
 
+  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 命令**',
@@ -287,6 +408,7 @@ function createWikiCommandHandler(deps) {
       '`/wiki research <关键词>` — 搜索知识',
       '`/wiki page <slug>` — 查看页面全文',
       '`/wiki sync` — 重建陈旧页面',
+      '`/wiki import <路径>` — 导入本地文档 (md/txt/PDF)',
       '`/wiki pin <标签> [标题]` — 手工注册主题',
       '`/wiki open` — 在 Obsidian 中打开 vault',
     ].join('\n'));

package/scripts/daemon.js

@@ -2387,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 }
@@ -2402,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?)`);
@@ -2510,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/feishu-adapter.js

@@ -8,6 +8,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const dns = require('dns');
 
 let Lark;
 function _tryRequireLark() {
@@ -58,6 +59,40 @@ function withTimeout(promise, ms = 10000) {
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
+// Wait for DNS to resolve a target host with exponential backoff.
+// Used after system wake / before reconnect: the OS may report clock/events
+// restored before WiFi+DNS are actually usable. Retries 1/2/4/8s, total cap 30s.
+async function waitForNetworkReady(hostname, opts = {}) {
+  const log = opts.log || (() => {});
+  const totalBudget = Number.isFinite(opts.totalBudgetMs) ? opts.totalBudgetMs : 30000;
+  const lookup = opts.lookup || dns.promises.lookup;
+  const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const startedAt = Date.now();
+  let attempt = 0;
+  let lastError = null;
+  // Backoff schedule: 0s, 1s, 2s, 4s, 8s between attempts (before the next attempt)
+  const backoff = [0, 1000, 2000, 4000, 8000];
+  // Always make at least one attempt; subsequent attempts are budget-gated.
+  do {
+    const wait = backoff[Math.min(attempt, backoff.length - 1)];
+    if (wait > 0) await sleep(wait);
+    attempt += 1;
+    try {
+      await lookup(hostname);
+      return { ok: true, attempts: attempt, elapsed: Date.now() - startedAt };
+    } catch (err) {
+      lastError = err;
+      log('DEBUG', `[net-ready] ${hostname} attempt ${attempt} failed: ${err.code || err.message}`);
+    }
+  } while (Date.now() - startedAt < totalBudget);
+  return {
+    ok: false,
+    attempts: attempt,
+    elapsed: Date.now() - startedAt,
+    error: lastError && (lastError.message || String(lastError)),
+  };
+}
+
 // Max chars per lark_md element (Feishu limit ~4000)
 const MAX_CHUNK = 3800;
 
@@ -101,12 +136,25 @@ function createBot(config) {
       return { ok: true };
     } catch (err) {
       const msg = err && err.message || String(err);
-      const isAuthError = /invalid|unauthorized|forbidden|token|credential|app_id|app_secret|permission|99991663|99991664|99991665/i.test(msg);
+      // Only flag as auth error when we have strong evidence: known Feishu
+      // auth error codes, HTTP 401/403, or explicit 'invalid app_id/secret'.
+      // Previously a loose /token/ regex false-positived on SDK-internal
+      // messages like "Cannot destructure 'tenant_access_token' of undefined"
+      // (which is really a network/empty-response failure) and caused the
+      // bridge to refuse to start across a lid-close/wake cycle.
+      const authPatterns = [
+        /\b(99991663|99991664|99991665)\b/,                                  // Feishu token invalid codes
+        /\b(401|403)\b/,                                                     // HTTP 401/403
+        /invalid\s+(app_?id|app_?secret|tenant_access_token|access_?token)/i,
+        /unauthorized/i,
+        /\bforbidden\b/i,
+      ];
+      const isAuthError = authPatterns.some((p) => p.test(msg));
       return {
         ok: false,
         error: isAuthError
           ? `Feishu credential validation failed (app_id/app_secret may be incorrect): ${msg}`
-          : `Feishu API probe failed (network or config issue): ${msg}`,
+          : `Feishu API probe failed (network or transient issue): ${msg}`,
         isAuthError,
       };
     }
@@ -393,14 +441,24 @@ 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
+      let aliveTimer = null;
+      let reconnectScheduled = false; // dedup flag: true while a reconnect is pending
+      let wsEpoch = 0; // increments each connect(); underlying-ws hooks capture their own epoch
+      const INITIAL_RECONNECT_DELAY = 5000;
       const MAX_RECONNECT_DELAY = 60000;
-      const HEALTH_CHECK_INTERVAL = 90000; // check every 90s
-      const SILENT_THRESHOLD = 300000; // 5 min no SDK activity → suspect dead
+      let reconnectDelay = INITIAL_RECONNECT_DELAY;
+      const HEALTH_CHECK_INTERVAL = 30000; // tighter bottom-line probe (was 90s)
+      const SILENT_THRESHOLD = 90000; // 90s no SDK activity → probe (was 300s)
+      const SLEEP_DETECT_INTERVAL = 5000;
+      const SLEEP_JUMP_THRESHOLD = 30000; // clock jump >30s = was sleeping
+      const ALIVE_CHECK_WINDOW = 15000; // after connect, must see activity within 15s
+      const FEISHU_HOST = 'open.feishu.cn';
 
       // Track last SDK activity (any event received = alive)
       let _lastActivityAt = Date.now();
+      let _connectedAt = 0; // when the current WSClient was (re)started
       function touchActivity() { _lastActivityAt = Date.now(); }
 
       // Dedup: track recent message_ids (Feishu may redeliver on slow ack)
@@ -487,75 +545,196 @@ function createBot(config) {
         });
       }
 
+      // Hook the underlying ws instance for first-class close/error notification.
+      // Lark SDK stores the live WebSocket via wsConfig.setWSInstance; we wrap it
+      // so we learn about 'close' immediately instead of waiting for silence.
+      // Defensive: SDK internals can change between versions — any failure just
+      // downgrades to the silent/health/sleep bottom-lines.
+      function hookUnderlyingWs(wsClient, epoch) {
+        try {
+          const cfg = wsClient && wsClient.wsConfig;
+          if (!cfg || typeof cfg.setWSInstance !== 'function') return;
+          const orig = cfg.setWSInstance.bind(cfg);
+          cfg.setWSInstance = (inst) => {
+            orig(inst);
+            if (!inst || inst._metameHooked) return;
+            inst._metameHooked = true;
+            try {
+              inst.on('close', () => {
+                if (stopped) return;
+                if (epoch !== wsEpoch) return; // stale: a newer connect() has superseded this one
+                _log('INFO', 'Feishu underlying WS closed — scheduling reconnect');
+                scheduleReconnect({ immediate: true, reason: 'ws-close' });
+              });
+              inst.on('error', (e) => {
+                if (epoch !== wsEpoch) return;
+                _log('WARN', `Feishu underlying WS error: ${e && e.message || e}`);
+              });
+            } catch (hookErr) {
+              _log('WARN', `Feishu ws event hook failed: ${hookErr.message}`);
+            }
+          };
+        } catch (err) {
+          _log('WARN', `Feishu SDK hook unavailable (${err.message}) — falling back to silence/sleep detection`);
+        }
+      }
+
       function connect() {
         if (stopped) return;
+        clearTimeout(aliveTimer);
+        wsEpoch += 1;
+        const myEpoch = wsEpoch;
+        let ws;
         try {
-          currentWs = new Lark.WSClient({
+          ws = new Lark.WSClient({
             appId: app_id,
             appSecret: app_secret,
             loggerLevel: Lark.LoggerLevel.info,
+            autoReconnect: false, // we own the reconnect lifecycle
           });
+          currentWs = ws;
+          hookUnderlyingWs(ws, myEpoch);
           const eventDispatcher = buildDispatcher();
-          currentWs.start({ eventDispatcher });
+          const startResult = ws.start({ eventDispatcher });
+          _connectedAt = Date.now();
           touchActivity();
-          reconnectDelay = 5000; // reset backoff on successful start
           _log('INFO', 'Feishu WebSocket connecting...');
+          startAliveCheck();
+          // start() may return a Promise. Surface async failures into the reconnect pipeline
+          // so we don't depend solely on the 15s alive-check to recover.
+          if (startResult && typeof startResult.then === 'function') {
+            startResult.catch((err) => {
+              if (stopped) return;
+              if (myEpoch !== wsEpoch) return; // superseded
+              _log('ERROR', `Feishu WSClient.start rejected: ${err && err.message || err}`);
+              scheduleReconnect({ immediate: true, reason: 'start-rejected', failed: true });
+            });
+          }
         } catch (err) {
           _log('ERROR', `Feishu WSClient.start failed: ${err.message}`);
-          scheduleReconnect();
+          scheduleReconnect({ immediate: true, reason: 'start-failed', failed: true });
         }
       }
 
-      function scheduleReconnect() {
+      // Single entry point for all reconnect signals. Dedup'd via reconnectScheduled
+      // so concurrent ws-close + alive-probe-fail + sleep events collapse into one
+      // reconnect. Backoff only grows when the caller marks this as a failure recovery
+      // (failed:true) — known-cause resets (manual / system-wake) start from 0s.
+      function scheduleReconnect({ immediate = false, reason = '', failed = false } = {}) {
         if (stopped) return;
+        if (reconnectScheduled) {
+          _log('DEBUG', `Feishu reconnect already scheduled — dropping duplicate (reason: ${reason})`);
+          return;
+        }
+        reconnectScheduled = true;
         clearTimeout(reconnectTimer);
-        _log('INFO', `Feishu reconnecting in ${reconnectDelay / 1000}s...`);
-        reconnectTimer = setTimeout(() => {
-          _log('INFO', 'Feishu reconnecting now...');
+        clearTimeout(aliveTimer);
+        try { currentWs?.stop?.(); } catch { /* ignore */ }
+        currentWs = null;
+        if (failed) {
+          // Only failure paths grow the backoff ceiling for the *next* attempt.
+          reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY);
+        }
+        const delay = immediate ? 0 : reconnectDelay;
+        _log('INFO', `Feishu reconnect in ${Math.round(delay / 1000)}s (reason: ${reason || 'unspecified'})`);
+        reconnectTimer = setTimeout(async () => {
+          reconnectScheduled = false;
+          if (stopped) return;
+          const net = await waitForNetworkReady(FEISHU_HOST, { log: _log });
+          if (stopped) return;
+          if (!net.ok) {
+            _log('WARN', `Feishu network still down after ${Math.round(net.elapsed / 1000)}s (${net.error || 'unknown'}) — retrying`);
+            scheduleReconnect({ immediate: false, reason: 'network-wait-timeout', failed: true });
+            return;
+          }
+          if (net.attempts > 1) {
+            _log('INFO', `Feishu network ready after ${net.attempts} attempts (${Math.round(net.elapsed / 1000)}s)`);
+          }
           connect();
-        }, reconnectDelay);
-        reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY);
+        }, delay);
+      }
+
+      // Alive-check: after each connect, require either SDK activity or a
+      // successful API probe within ALIVE_CHECK_WINDOW. Otherwise reconnect.
+      // This catches the "WSClient.start returned but underlying socket is
+      // dead" case that the 120s SDK loop would otherwise sit on.
+      function startAliveCheck() {
+        clearTimeout(aliveTimer);
+        const connectedAt = _connectedAt;
+        aliveTimer = setTimeout(async () => {
+          if (stopped) return;
+          if (_lastActivityAt > connectedAt) {
+            // SDK delivered at least one event strictly after connect → healthy.
+            // Using `>` (not `>=`) because connect() calls touchActivity(), so
+            // _lastActivityAt === _connectedAt at connect time — `>=` would
+            // false-positive immediately without any real post-connect activity.
+            reconnectDelay = INITIAL_RECONNECT_DELAY;
+            return;
+          }
+          try {
+            await withTimeout(client.im.chat.list({ params: { page_size: 1 } }), 8000);
+            touchActivity();
+            reconnectDelay = INITIAL_RECONNECT_DELAY;
+            _log('INFO', 'Feishu alive probe ok');
+          } catch (err) {
+            _log('WARN', `Feishu alive probe failed: ${err.message} — reconnecting`);
+            scheduleReconnect({ immediate: true, reason: 'alive-probe-failed', failed: true });
+          }
+        }, ALIVE_CHECK_WINDOW);
       }
 
-      // Health check: detect silent WebSocket death via API probe
+      // Health check: bottom-line probe for silent dead-sockets the hooks missed.
       function startHealthCheck() {
         clearInterval(healthTimer);
         healthTimer = setInterval(async () => {
           if (stopped) return;
           const silentMs = Date.now() - _lastActivityAt;
-          if (silentMs < SILENT_THRESHOLD) return; // recently active, skip
-          // Probe: try a lightweight API call to verify token + connectivity
+          if (silentMs < SILENT_THRESHOLD) return;
           try {
-            await withTimeout(client.im.chat.list({ params: { page_size: 1 } }), 10000);
-            // API works — connection might still be alive, just quiet. Reset activity.
+            await withTimeout(client.im.chat.list({ params: { page_size: 1 } }), 8000);
             touchActivity();
           } catch (err) {
             _log('WARN', `Feishu health check failed after ${Math.round(silentMs / 1000)}s silence: ${err.message} — reconnecting`);
-            try { currentWs?.stop?.(); } catch { /* ignore */ }
-            currentWs = null;
-            connect();
+            scheduleReconnect({ immediate: true, reason: 'health-probe-failed', failed: true });
           }
         }, HEALTH_CHECK_INTERVAL);
       }
 
+      // Sleep/wake detector: JS clock jump >30s ⇒ system was suspended.
+      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', `Feishu system wake detected (${Math.round(elapsed / 1000)}s gap) — reconnecting`);
+            reconnectDelay = INITIAL_RECONNECT_DELAY; // wake is a known cause, not a failure
+            scheduleReconnect({ immediate: true, reason: 'system-wake' });
+          }
+        }, SLEEP_DETECT_INTERVAL);
+      }
+
       // Initial connect
       connect();
       startHealthCheck();
+      startSleepWakeDetector();
 
       return Promise.resolve({
         stop() {
           stopped = true;
           clearTimeout(reconnectTimer);
+          clearTimeout(aliveTimer);
           clearInterval(healthTimer);
+          clearInterval(sleepWakeTimer);
+          try { currentWs?.stop?.(); } catch { /* ignore */ }
           currentWs = null;
         },
         reconnect() {
           _log('INFO', 'Feishu manual reconnect triggered');
-          reconnectDelay = 5000;
-          clearTimeout(reconnectTimer);
-          try { currentWs?.stop?.(); } catch { /* ignore */ }
-          currentWs = null;
-          connect();
+          reconnectDelay = INITIAL_RECONNECT_DELAY;
+          scheduleReconnect({ immediate: true, reason: 'manual' });
         },
         isAlive() {
           return !stopped && (Date.now() - _lastActivityAt) < SILENT_THRESHOLD;
@@ -567,4 +746,4 @@ function createBot(config) {
   };
 }
 
-module.exports = { createBot };
+module.exports = { createBot, _internal: { waitForNetworkReady } };

package/scripts/memory-backfill-chunks.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * memory-backfill-chunks.js — One-time backfill for existing wiki pages
+ *
+ * For each wiki page that has content but no content_chunks rows:
+ * 1. Splits content into chunks via recursive chunker
+ * 2. Inserts chunk rows
+ * 3. Enqueues each chunk for embedding generation
+ *
+ * Idempotent: pages with existing chunks are skipped.
+ *
+ * Usage: node scripts/memory-backfill-chunks.js
+ */
+
+const path = require('path');
+const os = require('os');
+
+const DB_PATH = path.join(os.homedir(), '.metame', 'memory.db');
+
+function main() {
+  const { DatabaseSync } = require('node:sqlite');
+  const db = new DatabaseSync(DB_PATH);
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA busy_timeout = 3000');
+
+  // Ensure schema is up to date
+  try {
+    const { applyWikiSchema } = require('./memory-wiki-schema');
+    applyWikiSchema(db);
+  } catch (err) {
+    process.stderr.write(`Schema init failed: ${err.message}\n`);
+    db.close();
+    process.exit(1);
+  }
+
+  const { chunkText } = require('./core/chunker');
+
+  // Find pages without chunks
+  const pages = db.prepare(`
+    SELECT wp.slug, wp.content
+    FROM wiki_pages wp
+    WHERE wp.content IS NOT NULL
+      AND wp.content != ''
+      AND NOT EXISTS (
+        SELECT 1 FROM content_chunks cc WHERE cc.page_slug = wp.slug
+      )
+  `).all();
+
+  if (pages.length === 0) {
+    console.log('All wiki pages already have chunks. Nothing to backfill.');
+    db.close();
+    return;
+  }
+
+  console.log(`Backfilling ${pages.length} wiki pages...`);
+
+  const insertChunk = db.prepare(
+    'INSERT INTO content_chunks (id, page_slug, chunk_text, chunk_idx) VALUES (?, ?, ?, ?)',
+  );
+  const enqueue = db.prepare(
+    "INSERT INTO embedding_queue (item_type, item_id) VALUES ('chunk', ?)",
+  );
+
+  let totalChunks = 0;
+
+  db.prepare('BEGIN').run();
+  try {
+    for (const page of pages) {
+      const chunks = chunkText(page.content, { targetWords: 300 });
+      for (let i = 0; i < chunks.length; i++) {
+        const chunkId = `ck_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        insertChunk.run(chunkId, page.slug, chunks[i], i);
+        enqueue.run(chunkId);
+        totalChunks++;
+      }
+    }
+    db.prepare('COMMIT').run();
+  } catch (err) {
+    try { db.prepare('ROLLBACK').run(); } catch { }
+    process.stderr.write(`Backfill failed: ${err.message}\n`);
+    db.close();
+    process.exit(1);
+  }
+
+  console.log(`Done. Created ${totalChunks} chunks for ${pages.length} pages. Run daemon-embedding.js to generate embeddings.`);
+  db.close();
+}
+
+main();