metame-cli 1.5.9 → 1.5.11

package/scripts/daemon-utils.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * daemon-utils.js
+ *
+ * Shared normalization helpers used across daemon modules.
+ * Single source of truth — no other module should redefine these.
+ */
+
+function normalizeEngineName(name, defaultEngine = 'claude') {
+  const n = String(name || '').trim().toLowerCase();
+  return n === 'codex' ? 'codex' : (typeof defaultEngine === 'function' ? defaultEngine() : defaultEngine);
+}
+
+function normalizeCodexSandboxMode(value, fallback = null) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return fallback;
+  if (text === 'read-only' || text === 'readonly') return 'read-only';
+  if (text === 'workspace-write' || text === 'workspace') return 'workspace-write';
+  if (
+    text === 'danger-full-access'
+    || text === 'dangerous'
+    || text === 'full-access'
+    || text === 'full'
+    || text === 'bypass'
+    || text === 'writable'
+  ) return 'danger-full-access';
+  return fallback;
+}
+
+function normalizeCodexApprovalPolicy(value, fallback = null) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return fallback;
+  if (text === 'never' || text === 'no' || text === 'none') return 'never';
+  if (text === 'on-failure' || text === 'on_failure' || text === 'failure') return 'on-failure';
+  if (text === 'on-request' || text === 'on_request' || text === 'request') return 'on-request';
+  if (text === 'untrusted') return 'untrusted';
+  return fallback;
+}
+
+function mergeAgentMaps(cfg) {
+  return {
+    ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}),
+    ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}),
+    ...(cfg.imessage ? cfg.imessage.chat_agent_map : {}),
+    ...(cfg.siri_bridge ? cfg.siri_bridge.chat_agent_map : {}),
+  };
+}
+
+module.exports = {
+  normalizeEngineName,
+  normalizeCodexSandboxMode,
+  normalizeCodexApprovalPolicy,
+  mergeAgentMaps,
+};

package/scripts/daemon.js

@@ -48,6 +48,7 @@ const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
 const DISPATCH_LOG = path.join(DISPATCH_DIR, 'dispatch-log.jsonl');
 const { sleepSync, socketPath, needsSocketCleanup } = require('./platform');
+const { handleReactiveOutput } = require('./daemon-reactive-lifecycle');
 const SOCK_PATH = socketPath(METAME_DIR);
 
 // Resolve claude binary path (daemon may not inherit user's full PATH)
@@ -286,12 +287,28 @@ function restoreConfig() {
   if (!fs.existsSync(bak)) return false;
   try {
     const bakCfg = yaml.load(fs.readFileSync(bak, 'utf8')) || {};
-    // Preserve security-critical fields from current config (chat IDs, agent map)
-    // so a /fix never loses manually-added channels
+    // Preserve ALL user-critical fields from current config so /fix never
+    // loses secrets, chat IDs, or agent mappings
     let curCfg = {};
     try { curCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {}; } catch { }
+    // Secret fields that must NEVER be reverted by a restore
+    const SECRET_FIELDS = ['app_id', 'app_secret', 'bot_token', 'operator_ids'];
     for (const adapter of ['feishu', 'telegram']) {
       if (curCfg[adapter] && bakCfg[adapter]) {
+        // Preserve secrets: current config always wins
+        for (const field of SECRET_FIELDS) {
+          if (curCfg[adapter][field] != null) {
+            bakCfg[adapter][field] = curCfg[adapter][field];
+          }
+        }
+        // Preserve remote_dispatch secrets
+        if (curCfg[adapter].remote_dispatch && bakCfg[adapter].remote_dispatch) {
+          if (curCfg[adapter].remote_dispatch.secret) {
+            bakCfg[adapter].remote_dispatch.secret = curCfg[adapter].remote_dispatch.secret;
+          }
+        } else if (curCfg[adapter].remote_dispatch) {
+          bakCfg[adapter].remote_dispatch = curCfg[adapter].remote_dispatch;
+        }
         const curIds = curCfg[adapter].allowed_chat_ids || [];
         const bakIds = bakCfg[adapter].allowed_chat_ids || [];
         // Union of both lists
@@ -301,8 +318,15 @@ function restoreConfig() {
         bakCfg[adapter].chat_agent_map = Object.assign(
           {}, bakCfg[adapter].chat_agent_map || {}, curCfg[adapter].chat_agent_map || {}
         );
+      } else if (curCfg[adapter] && !bakCfg[adapter]) {
+        // Backup doesn't have this adapter at all — keep current entirely
+        bakCfg[adapter] = curCfg[adapter];
       }
     }
+    // Preserve projects (current takes precedence for each project key)
+    if (curCfg.projects) {
+      bakCfg.projects = Object.assign({}, bakCfg.projects || {}, curCfg.projects);
+    }
     writeConfigSafe(bakCfg);
     config = loadConfig(); // eslint-disable-line no-undef -- config is declared in main() closure
     return true;
@@ -1083,6 +1107,37 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
         chain: [], // reset chain for callbacks
       }, config);
     }
+
+    // ── Reactive lifecycle hook ──
+    try {
+      handleReactiveOutput(targetProject, outStr, loadConfig(), {
+        log,
+        loadState,
+        saveState,
+        checkBudget,
+        handleDispatchItem: (item, cfg) => {
+          dispatchTask(item.target, {
+            from: item.from || '_reactive',
+            type: 'reactive',
+            priority: 'normal',
+            new_session: !!item.new_session,
+            payload: { title: 'reactive dispatch', prompt: item.prompt },
+          }, cfg, null, null);
+        },
+        notifyUser: (msg) => {
+          try {
+            const cfg = loadConfig();
+            if (cfg.feishu && cfg.feishu.enabled && cfg.feishu.admin_chat_id) {
+              const { sendFeishuText } = require('./daemon-notify');
+              sendFeishuText(cfg.feishu.admin_chat_id, msg, cfg);
+            }
+          } catch (e) { log('WARN', `Reactive notify failed: ${e.message}`); }
+        },
+        metameDir: path.join(os.homedir(), '.metame'),
+      });
+    } catch (e) {
+      log('ERROR', `Reactive lifecycle error for ${targetProject}: ${e.message}`);
+    }
   };
   // If streamOptions provided, use real bot so output appears in target's Feishu channel.
   // Otherwise fall back to nullBot which captures output for replyFn.
@@ -1697,6 +1752,27 @@ function physiologicalHeartbeat(config) {
   } catch (e) {
     log('WARN', `Dispatch log rotation failed: ${e.message}`);
   }
+
+  // 4. Reconcile perpetual projects — detect stale reactive loops
+  try {
+    const { reconcilePerpetualProjects } = require('./daemon-reactive-lifecycle');
+    reconcilePerpetualProjects(config, {
+      log,
+      loadState,
+      saveState,
+      notifyUser: (msg) => {
+        try {
+          const cfg = loadConfig();
+          if (cfg.feishu && cfg.feishu.enabled && cfg.feishu.admin_chat_id) {
+            const { sendFeishuText } = require('./daemon-notify');
+            sendFeishuText(cfg.feishu.admin_chat_id, msg, cfg);
+          }
+        } catch (e) { log('WARN', `Reconcile notify failed: ${e.message}`); }
+      },
+    });
+  } catch (e) {
+    log('WARN', `Reconcile check failed: ${e.message}`);
+  }
 }
 
 // ── Timing constants ─────────────────────────────────────────────────────────
@@ -2315,6 +2391,7 @@ const { handleOpsCommand } = createOpsCommandHandler({
   path,
   spawn,
   execSync,
+  execFileSync,
   log,
   loadConfig,
   loadState,

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(skeleton.intent || title, `session-${String(skeleton.session_id || '').slice(0, 8)}`);
+  const topicSlug = sanitizeSlug(title || skeleton.intent, `session-${String(skeleton.session_id || '').slice(0, 8)}`);
   const filePath = path.join(POSTMORTEM_DIR, `${day}-${topicSlug}.md`);
   const markdown = [
     `# ${title}`,

package/scripts/docs/maintenance-manual.md

@@ -354,7 +354,60 @@ Claude 看到 hook 注入:
 - `/dispatch to windows:hunter <任务>`：手动跨设备派发
 - `/dispatch to 猎手 <任务>`：按昵称解析，自动检测 `member.peer` 走远端
 
-## 12. 私人配置保护
+## 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）
 
 - `daemon.yaml` 是用户私人配置，包含 API keys、chat IDs、个人项目配置
 - **绝不上传**到代码仓库，已加入 `.gitignore`
@@ -363,7 +416,7 @@ Claude 看到 hook 注入:
 - 同样不应上传的文件：`MEMORY.md`、`SOUL.md`、`.env*`
 - Agent 在执行任务时，**绝不能** `cp scripts/daemon.yaml ~/.metame/daemon.yaml`，这会覆盖用户私人配置
 
-## 13. 变更后维护动作
+## 14. 变更后维护动作
 
 1. `npm test`
 2. `npm run sync:plugin`

package/scripts/docs/orphan-files-review.md

@@ -0,0 +1,72 @@
+# 未被 daemon.js 直接引用的脚本文件审查
+
+> 审查日期: 2026-03-17
+> 目的: 确认哪些文件是活跃的、哪些可以安全删除
+
+---
+
+## 分类结果
+
+### ACTIVE — 被其他活跃模块间接引用（无需处理）
+
+| 文件 | 引用方 | 说明 |
+|------|--------|------|
+| `session-analytics.js` | daemon-claude-engine, distill, memory-extract, session-summarize | 会话分析核心库 |
+| `mentor-engine.js` | daemon-claude-engine, daemon-admin-commands | AI 导师引擎 |
+| `intent-registry.js` | daemon-claude-engine, hooks/intent-engine | 意图识别注册表 |
+| `daemon-command-session-route.js` | daemon-exec-commands, daemon-ops-commands | 会话路由解析 |
+| `daemon-siri-bridge.js` | daemon-bridges.js | Siri HTTP 桥接 |
+| `daemon-siri-imessage.js` | daemon-siri-bridge.js | iMessage 数据库读取 |
+| `telegram-adapter.js` | daemon-bridges.js | Telegram 适配器 |
+| `feishu-adapter.js` | daemon-bridges.js | 飞书适配器 |
+| `session-summarize.js` | daemon.js (spawn) | 会话总结，由 daemon.js 第1158行 spawn 调用 |
+
+### HEARTBEAT — daemon.yaml 心跳任务调用（无需处理）
+
+| 文件 | daemon.yaml 任务名 | 说明 |
+|------|-------------------|------|
+| `distill.js` (1447行) | `cognitive-distill` | 认知蒸馏引擎 |
+| `memory-extract.js` (428行) | `memory-extract` | 记忆提取 |
+| `memory-nightly-reflect.js` (607行) | (nightly task) | 夜间反思 |
+| `self-reflect.js` (378行) | `self-reflect` | 自我反思 |
+
+### DEPENDENCY — 被心跳任务间接依赖（无需处理）
+
+| 文件 | 被谁引用 | 说明 |
+|------|----------|------|
+| `signal-capture.js` | distill.js + Claude Code UserPromptSubmit hook | 信号捕获（hook + 数据源） |
+| `pending-traits.js` (147行) | distill.js | 待处理特征 |
+| `skill-changelog.js` | skill-evolution.js | 技能变更日志 |
+
+---
+
+### ORPHAN — 疑似孤儿文件，需要王总决策
+
+| 文件 | 行数 | 分析 | 建议 |
+|------|------|------|------|
+| `daemon-reactive-lifecycle.js` | ~500 | 未被任何生产模块 require，仅被 test 和 verify 脚本引用。**但仍会被部署到 ~/.metame/**（不在 EXCLUDED_SCRIPTS 中）。是计划中的"反应式生命周期"功能，尚未集成 | **删除或归档**？如果不再计划实现。至少应加入 EXCLUDED_SCRIPTS 避免无用部署 |
+| `verify-reactive-claude-md.js` | ~100 | 仅引用 daemon-reactive-lifecycle，单独的验证脚本 | 随 reactive-lifecycle 一起处理 |
+| `sync-readme.js` | ~50 | 未被任何模块引用，是独立 README 翻译工具。已在 EXCLUDED_SCRIPTS 中，不会被部署到 ~/.metame/ | **保留为 CLI 工具**（无害）还是 **删除**？ |
+
+---
+
+### plugin/scripts/ 孤儿文件（无对应源文件）
+
+这些文件只存在于 `plugin/scripts/`，在 `scripts/` 中没有源文件：
+
+| 文件 | 说明 | 建议 |
+|------|------|------|
+| `auto-start-daemon.js` | SessionStart hook 自启动 daemon | 迁移到 `scripts/` 还是删除？ |
+| `distill-on-start.js` | 启动时 spawn 蒸馏 | 同上 |
+| `inject-profile.js` | 注入 SYSTEM KERNEL 协议头 | 同上 |
+| `setup.js` | 创建 ~/.claude_profile.yaml | 同上 |
+
+> 风险：下次 `npm run sync:plugin` 会用 `scripts/` 覆盖 `plugin/scripts/`，这 4 个文件可能丢失。
+
+---
+
+## 需要王总确认的决策
+
+1. **daemon-reactive-lifecycle.js** — 这个反应式生命周期功能还计划集成吗？如果不做了就可以删掉。
+2. **sync-readme.js** — 是否还在用？
+3. **plugin/scripts/ 的 4 个孤儿** — 应该迁移到 `scripts/` 作为源文件，还是已经不需要了？

package/scripts/docs/pointer-map.md

@@ -130,6 +130,39 @@
   - `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`
@@ -141,6 +174,7 @@
 - 复盘文档：`~/.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

@@ -91,6 +91,27 @@ function createBot(config) {
     appSecret: app_secret,
   });
 
+  /**
+   * Validate credentials by attempting a lightweight API call.
+   * Returns { ok: true } or { ok: false, error: string }.
+   */
+  async function validateCredentials() {
+    try {
+      await withTimeout(client.im.chat.list({ params: { page_size: 1 } }), 15000);
+      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);
+      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}`,
+        isAuthError,
+      };
+    }
+  }
+
   // Private: send an interactive card JSON; returns { message_id } or null.
   // All card functions funnel through here to avoid repeating the SDK call.
   async function _sendInteractive(chatId, card) {
@@ -106,6 +127,7 @@ function createBot(config) {
   let _editBrokenAt = 0;        // timestamp when broken; auto-resets after 10min
 
   return {
+    validateCredentials,
     /**
      * Send a plain text message
      */
@@ -526,6 +548,9 @@ function createBot(config) {
         reconnect() {
           _log('INFO', 'Feishu manual reconnect triggered');
           reconnectDelay = 5000;
+          clearTimeout(reconnectTimer);
+          try { currentWs?.stop?.(); } catch { /* ignore */ }
+          currentWs = null;
           connect();
         },
         isAlive() {

package/scripts/hooks/intent-auto-rules.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * Auto-Rules Intent Module
+ *
+ * Injects auto-promoted defensive rules distilled by memory-nightly-reflect.
+ * Rules live in ~/.metame/auto-rules.md — one-liners promoted from recurring
+ * hot-fact patterns (3+ occurrences in memory.db).
+ *
+ * Always fires when rules exist — no pattern detection needed.
+ * Overhead: ~10–15 one-liners ≈ 200 tokens per turn.
+ *
+ * File is cached for CACHE_TTL_MS to avoid per-prompt disk I/O.
+ * Cache refreshes automatically after nightly-reflect writes new rules.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const RULES_FILE = path.join(os.homedir(), '.metame', 'auto-rules.md');
+const CACHE_TTL_MS = 60 * 1000; // 1 minute — nightly-reflect runs once/day
+
+let _cached = null;
+let _cacheTs = 0;
+
+function loadRules() {
+  const now = Date.now();
+  if (_cached !== null && now - _cacheTs < CACHE_TTL_MS) return _cached;
+
+  try {
+    const content = fs.readFileSync(RULES_FILE, 'utf8');
+    const rules = content
+      .split('\n')
+      .map(l => l.trim())
+      .filter(l => l && !l.startsWith('<!--'));
+    _cached = rules.length > 0 ? rules : [];
+  } catch {
+    _cached = [];
+  }
+
+  _cacheTs = now;
+  return _cached;
+}
+
+module.exports = function detectAutoRules() {
+  const rules = loadRules();
+  if (rules.length === 0) return null;
+  return ['[自动晋升规则 — 夜间蒸馏高频模式]', ...rules.map(r => `- ${r}`)].join('\n');
+};

package/scripts/memory-extract.js

@@ -74,6 +74,7 @@ const SESSION_TAGS_FILE = path.join(os.homedir(), '.metame', 'session_tags.json'
 
 /**
  * Persist session name and derived tags to ~/.metame/session_tags.json.
+ * Consumed by /sessions and /resume commands for friendly display titles.
  * Merges into existing file — never overwrites existing entries.
  */
 function saveSessionTag(sessionId, sessionName, facts) {
@@ -337,6 +338,19 @@ async function run() {
 
         sessionAnalytics.markFactsExtracted(skeleton.session_id);
 
+        // Persist session summary to memory.db sessions table (makes sessions searchable)
+        try {
+          const keywords = facts.flatMap(f => Array.isArray(f.tags) ? f.tags : [])
+            .filter((v, i, a) => a.indexOf(v) === i).slice(0, 10).join(',');
+          memory.saveSession({
+            sessionId: skeleton.session_id,
+            project: skeleton.project || 'unknown',
+            scope: skeleton.project_id || null,
+            summary: `[${session_name}] ${facts.map(f => f.value).join(' | ').slice(0, 2000)}`,
+            keywords,
+          });
+        } catch { /* non-fatal — facts already saved, session is bonus */ }
+
         // P2-A: persist session name + tags to session_tags.json
         saveSessionTag(skeleton.session_id, session_name, facts);
 
@@ -391,12 +405,26 @@ async function run() {
             const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
             const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
             console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): ${saved} facts saved${superMsg}${labelMsg}`);
+
+            // Persist Codex session summary to memory.db sessions table
+            try {
+              const keywords = facts.flatMap(f => Array.isArray(f.tags) ? f.tags : [])
+                .filter((v, i, a) => a.indexOf(v) === i).slice(0, 10).join(',');
+              memory.saveSession({
+                sessionId: cs.session_id,
+                project: skeleton.project || 'unknown',
+                scope: skeleton.project_id || null,
+                summary: `[${session_name}] ${facts.map(f => f.value).join(' | ').slice(0, 2000)}`,
+                keywords,
+              });
+            } catch { /* non-fatal */ }
+
+            saveSessionTag(cs.session_id, session_name, facts);
           } else {
             console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
           }
 
           sessionAnalytics.markCodexFactsExtracted(cs.session_id);
-          saveSessionTag(cs.session_id, session_name, facts);
           processed++;
         } catch (e) {
           console.log(`[memory-extract] Codex session error: ${e.message}`);

package/scripts/memory-nightly-reflect.js

@@ -503,6 +503,109 @@ entity_prefix: ${group.prefix}
       try { if (memory && typeof memory.close === 'function') memory.close(); } catch { /* non-fatal */ }
     }
 
+    // ── Conflict Resolution ──────────────────────────────────────────────
+    // Query CONFLICT facts grouped by entity+relation, ask Haiku to pick winner.
+    // Loser is marked superseded_by winner; winner restored to OK.
+    let conflictsResolved = 0;
+    try {
+      const conflictGroups = db.prepare(`
+        SELECT entity, relation, COUNT(*) as cnt
+        FROM facts
+        WHERE conflict_status = 'CONFLICT' AND superseded_by IS NULL
+        GROUP BY entity, relation
+        HAVING cnt >= 2
+        ORDER BY cnt DESC
+        LIMIT 10
+      `).all();
+
+      if (conflictGroups.length > 0) {
+        console.log(`[NIGHTLY-REFLECT] Found ${conflictGroups.length} conflict group(s) to resolve.`);
+
+        // Collect all conflicting facts for these groups (batch to reduce queries)
+        const allConflicts = [];
+        for (const g of conflictGroups) {
+          const rows = db.prepare(`
+            SELECT id, entity, relation, value, confidence, created_at
+            FROM facts
+            WHERE entity = ? AND relation = ? AND conflict_status = 'CONFLICT' AND superseded_by IS NULL
+            ORDER BY created_at DESC
+          `).all(g.entity, g.relation);
+          if (rows.length >= 2) allConflicts.push({ entity: g.entity, relation: g.relation, facts: rows });
+        }
+
+        if (allConflicts.length > 0) {
+          // Limit to 5 groups to avoid truncating serialized JSON
+          const conflictInput = allConflicts.slice(0, 5).map(g => ({
+            entity: g.entity,
+            relation: g.relation,
+            candidates: g.facts.slice(0, 5).map(f => ({ id: f.id, value: f.value.slice(0, 150), confidence: f.confidence, created_at: f.created_at })),
+          }));
+
+          const resolvePrompt = `你是知识库冲突调解员。以下是同一 entity+relation 下的冲突事实，请选出每组最准确的一条保留。
+
+冲突组(JSON):
+${JSON.stringify(conflictInput, null, 2)}
+
+输出 JSON 数组，每个元素对应一组冲突的裁决：
+[
+  {
+    "entity": "...",
+    "relation": "...",
+    "winner_id": "保留的fact id",
+    "reason": "一句话理由"
+  }
+]
+
+规则：
+- 优先选最新（created_at）且 confidence=high 的
+- 如果旧条目更准确具体，选旧的
+- 只输出 JSON 数组`;
+
+          try {
+            const resolveRaw = await Promise.race([
+              callHaiku(resolvePrompt, distillEnv, 60000),
+              new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+            ]);
+            const verdicts = parseJsonFromLlm(resolveRaw);
+            if (Array.isArray(verdicts)) {
+              for (const v of verdicts) {
+                if (!v || !v.winner_id || !v.entity || !v.relation) continue;
+                // Validate winner exists in our conflict set
+                const group = allConflicts.find(g => g.entity === v.entity && g.relation === v.relation);
+                if (!group) continue;
+                const winnerExists = group.facts.some(f => f.id === v.winner_id);
+                if (!winnerExists) continue;
+
+                const loserIds = group.facts.filter(f => f.id !== v.winner_id).map(f => f.id);
+                if (loserIds.length === 0) continue;
+
+                // Mark losers as superseded
+                const placeholders = loserIds.map(() => '?').join(',');
+                db.prepare(
+                  `UPDATE facts SET superseded_by = ?, conflict_status = 'OK', updated_at = datetime('now')
+                   WHERE id IN (${placeholders})`
+                ).run(v.winner_id, ...loserIds);
+
+                // Restore winner
+                db.prepare(
+                  `UPDATE facts SET conflict_status = 'OK', updated_at = datetime('now') WHERE id = ?`
+                ).run(v.winner_id);
+
+                conflictsResolved += loserIds.length;
+              }
+              if (conflictsResolved > 0) {
+                console.log(`[NIGHTLY-REFLECT] Resolved ${conflictsResolved} conflicting fact(s).`);
+              }
+            }
+          } catch (e) {
+            console.log(`[NIGHTLY-REFLECT] Conflict resolution failed (non-fatal): ${e.message}`);
+          }
+        }
+      }
+    } catch (e) {
+      console.log(`[NIGHTLY-REFLECT] Conflict query failed (non-fatal): ${e.message}`);
+    }
+
     // Write audit log
     writeReflectLog({
       status: 'success',
@@ -510,6 +613,7 @@ entity_prefix: ${group.prefix}
       decisions_written: decisions.length,
       lessons_written: lessons.length,
       synthesized_insights_saved: synthesizedSaved,
+      conflicts_resolved: conflictsResolved,
       capsules_written: capsulesWritten,
       capsule_facts_saved: capsuleFactsSaved,
       decision_file: decisions.length > 0 ? decisionFile : null,