metame-cli 1.5.17 → 1.5.18

package/README.md

@@ -79,21 +79,16 @@ Start on your laptop, continue on the train. `/stop` to interrupt, `/undo` to ro
 
 ### 3. Layered Memory That Works While You Sleep
 
-MetaMe's memory system runs automatically in the background — no prompts, no manual saves. Five layers, fully autonomous.
+MetaMe's memory system runs automatically in the background — no prompts, no manual saves. Three layers, fully autonomous.
 
 **Layer 1 — Long-term Facts**
 When you go idle, MetaMe runs memory consolidation: extracts key decisions, patterns, and knowledge from your sessions into a persistent facts store. Facts can also carry concept labels (`fact_labels`) for faster cross-domain retrieval.
 
-**Layer 2 — Session Continuity**
-Resuming a conversation after 2+ hours? MetaMe injects a brief summary of what you were working on last time — so you pick up where you left off without re-explaining context.
+**Layer 2 — History Retrieval**
+When you refer to "that thing we worked on last week", MetaMe uses session routing, topic tags, and memory recall to find the right thread, files, and facts. Same-session continuation stays native — no synthetic resume summary is injected.
 
-**Layer 3 — Session Index**
-Every session gets tagged with topics and intent. This powers future session routing: when you reference "that thing we worked on last week", MetaMe knows where to look.
-
-**Layer 4 — Nightly Reflection**
+**Layer 3 — Higher-order Memory**
 Every night at 01:00, MetaMe reviews your most-accessed facts from the past week and distills them into high-level decision logs and operational lessons. Distilled outputs are also written back to `memory.db` as `synthesized_insight`, enabling retrieval in future sessions.
-
-**Layer 5 — Memory Index**
 At 01:30, an auto-generated global index (`INDEX.md`) maps every memory document across all categories (including capsules and postmortems). This serves as a fast lookup table so MetaMe always knows where to find relevant context.
 
 ```
@@ -101,14 +96,13 @@ At 01:30, an auto-generated global index (`INDEX.md`) maps every memory document
 idle 30min → memory consolidation triggered
   → session_tags.json updated (topics indexed)
   → facts extracted → ~/.metame/memory.db
-  → session summary cached → daemon_state.json
 01:00 → nightly reflection: hot facts → decisions + lessons
 01:30 → memory index regenerated
 
 [Next morning, when you resume]
 "continue from yesterday" →
-  [上次对话摘要] Auth refactor, decided on JWT with
-  refresh token rotation. Token expiry set to 15min.
+  session lookup + memory recall point to the right thread/files
+  without auto-injecting a synthetic conversation summary.
 ```
 
 ### 4. Heartbeat — A Programmable Nervous System
@@ -121,7 +115,7 @@ The heartbeat system is three-layered:
 Built into the daemon. Runs every 60 seconds regardless of what's in your config:
 - Drains the dispatch queue (IPC messages from other agents)
 - Tracks daemon aliveness and rotates logs
-- Detects when you go idle → generates session continuity summaries
+- Detects when you go idle and enters sleep mode for gated background work
 
 **Layer 1 — System Evolution (built-in defaults)**
 Five tasks shipped out of the box. They are precondition-gated and run only when useful:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.17",
+    "version": "1.5.18",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/daemon-claude-engine.js

@@ -1752,25 +1752,6 @@ ${mentorRadarHint}
 6. Before executing high-risk or non-obvious Bash commands (rm, kill, git reset, overwrite configs), prepend a single-line [Why] explanation. Skip for routine commands (ls, cat, grep).]`;
       }
 
-      // P2-B: inject session summary when resuming after a 2h+ gap
-      let summaryHint = '';
-      if (session.started) {
-        try {
-          const _stSum = loadState();
-          const _sess = _stSum.sessions && _stSum.sessions[chatId];
-          if (_sess && _sess.last_summary && _sess.last_summary_at) {
-            const _idleMs = Date.now() - (_sess.last_active || 0);
-            const _summaryAgeH = (Date.now() - _sess.last_summary_at) / 3600000;
-            if (_idleMs > 2 * 60 * 60 * 1000 && _summaryAgeH < 168) {
-              summaryHint = `
-
-[上次对话摘要（历史已完成，仅供上下文，请勿重复执行）]: ${_sess.last_summary}`;
-              log('INFO', `[DAEMON] Injected session summary for ${chatId} (idle ${Math.round(_idleMs / 3600000)}h)`);
-            }
-          }
-        } catch { /* non-critical */ }
-      }
-
       // Mentor context hook: inject after memoryHint, before langGuard.
       let mentorHint = '';
       if (mentorEnabled && !mentorExcluded && !mentorSuppressed) {
@@ -1842,7 +1823,7 @@ ${mentorRadarHint}
       // (varies per prompt), so include it even on warm reuse.
       const fullPrompt = _warmEntry
         ? routedPrompt + intentHint
-        : routedPrompt + daemonHint + intentHint + agentHint + macAutomationHint + summaryHint + memoryHint + mentorHint + langGuard;
+        : routedPrompt + daemonHint + intentHint + agentHint + macAutomationHint + memoryHint + mentorHint + langGuard;
       if (runtime.name === 'codex' && session.started && session.id && requestedCodexPermissionProfile) {
         const actualPermissionProfile = getActualCodexPermissionProfile(session);
         if (codexNeedsFallbackForRequestedPermissions(actualPermissionProfile, requestedCodexPermissionProfile)) {

package/scripts/daemon-task-scheduler.js

@@ -194,7 +194,6 @@ function createTaskScheduler(deps) {
     isUserIdle,
     isInSleepMode,
     setSleepMode,
-    spawnSessionSummaries,
     getWakeRecoveryHook,
     skillEvolution,
   } = deps;
@@ -744,8 +743,6 @@ function createTaskScheduler(deps) {
       if (idle && !isInSleepMode()) {
         setSleepMode(true);
         log('INFO', '[DAEMON] Entering Sleep Mode');
-        // Generate summaries for sessions idle 2-24h
-        spawnSessionSummaries();
       } else if (!idle && isInSleepMode()) {
         setSleepMode(false);
         log('INFO', '[DAEMON] Exiting Sleep Mode — local activity detected');

package/scripts/daemon.js

@@ -1180,67 +1180,6 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
   };
 }
 
-/**
- * Spawn memory-extract.js as a detached background process.
- * Called on sleep mode entry to consolidate session facts.
- */
-/**
- * Spawn session-summarize.js for sessions that have been idle 2-24 hours.
- * Called on sleep mode entry. Skips sessions that already have a fresh summary.
- */
-const MAX_CONCURRENT_SUMMARIES = 3;
-
-function spawnSessionSummaries() {
-  const scriptPath = path.join(__dirname, 'session-summarize.js');
-  if (!fs.existsSync(scriptPath)) return;
-  const state = loadState();
-  const now = Date.now();
-  const TWO_HOURS = 2 * 60 * 60 * 1000;
-  const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1000;
-  // Collect eligible sessions, sort by most recently active first
-  const eligible = [];
-  for (const [cid, sess] of Object.entries(state.sessions || {})) {
-    // Support both old flat format and new per-engine format
-    let sessionId, started;
-    if (sess.engines) {
-      const active = Object.values(sess.engines).find(s => s.id && s.started);
-      if (!active) continue;
-      sessionId = active.id;
-      started = true;
-    } else {
-      sessionId = sess.id;
-      started = sess.started;
-    }
-    if (!sessionId || !started) continue;
-    const lastActive = sess.last_active || 0;
-    const idleMs = now - lastActive;
-    if (idleMs < TWO_HOURS || idleMs > SEVEN_DAYS) continue;
-    if ((sess.last_summary_at || 0) > lastActive) continue;
-    eligible.push({ cid, sess: { ...sess, id: sessionId, started }, lastActive });
-  }
-  eligible.sort((a, b) => b.lastActive - a.lastActive);
-
-  let spawned = 0;
-  for (const { cid, sess } of eligible) {
-    if (spawned >= MAX_CONCURRENT_SUMMARIES) {
-      log('INFO', `[DAEMON] Session summary concurrency limit (${MAX_CONCURRENT_SUMMARIES}) reached, deferring remaining`);
-      break;
-    }
-    const idleMs = now - (sess.last_active || 0);
-    try {
-      const child = spawn(process.execPath, [scriptPath, cid, sess.id], {
-        detached: true, stdio: 'ignore',
-        ...(process.platform === 'win32' ? { windowsHide: true } : {}),
-      });
-      child.unref();
-      spawned++;
-      log('INFO', `[DAEMON] Session summary spawned for ${cid} (idle ${Math.round(idleMs / 3600000)}h)`);
-    } catch (e) {
-      log('WARN', `[DAEMON] Failed to spawn session summary: ${e.message}`);
-    }
-  }
-}
-
 /**
  * Physiological heartbeat: zero-token awareness check.
  * Runs every tick unconditionally.
@@ -2137,7 +2076,6 @@ const {
   isUserIdle,
   isInSleepMode: () => _inSleepMode,
   setSleepMode: (next) => { _inSleepMode = !!next; },
-  spawnSessionSummaries,
   getWakeRecoveryHook: () => wakeRecoveryHook,
   skillEvolution,
 });

package/scripts/docs/maintenance-manual.md

@@ -46,6 +46,8 @@ feishu:
 - 引擎 runtime 工厂：`scripts/daemon-engine-runtime.js`
 - 会话执行入口：`scripts/daemon-claude-engine.js`（Claude/Codex 共用）
 - Session 回写：`patchSessionSerialized()` 串行化，避免 thread.started 竞态覆盖
+- 同一个底层 session 不做自动“恢复摘要”注入；续聊直接依赖引擎原生上下文
+- 额外上下文只在显式链路进入时注入，例如 `/compact` 产物、`NOW.md`、memory facts / capsules、intent hints
 
 ### Codex 会话策略
 
@@ -95,6 +97,10 @@ feishu:
 - Dispatch 签名密钥：`~/.metame/.dispatch_secret`（自动创建）
 - 自动更新策略：发布版 npm 安装默认开启；源码 checkout / `npm link` 默认关闭，可用 `METAME_AUTO_UPDATE=on|off` 覆盖
 
+说明：
+- `daemon_state.json` 仍保存 session 元数据（如 `last_active`），用于路由、恢复和状态判断。
+- 不再缓存或注入“闲置后恢复摘要”；如果需要压缩上下文，只走显式 `/compact`。
+
 ## 7. 热重载安全机制（三层防护）
 
 1. **部署前预检**（`index.js`）：`node -c` 语法检查所有 `.js`，不通过则拒绝以 copy 模式部署到 `~/.metame/`

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

@@ -11,7 +11,7 @@
 
 | 文件 | 引用方 | 说明 |
 |------|--------|------|
-| `session-analytics.js` | daemon-claude-engine, distill, memory-extract, session-summarize | 会话分析核心库 |
+| `session-analytics.js` | daemon-claude-engine, distill, memory-extract | 会话分析核心库 |
 | `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 | 会话路由解析 |
@@ -19,7 +19,6 @@
 | `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 心跳任务调用（无需处理）
 

package/scripts/docs/pointer-map.md

@@ -28,6 +28,7 @@
 - 会话与引擎选择：
   - `scripts/daemon-claude-engine.js`
   - 关键点：`askClaude()` 按 `project.engine`/session 选择 runtime；`patchSessionSerialized()` 串行回写 session
+  - 说明：同一底层 session 续聊不再注入会话恢复摘要；额外上下文仅来自显式 compact / memory / intent 链路
   - Codex 规则：`exec`/`resume`、10 分钟窗口内一次自动重试、`thread_id` 迁移回写
 
 - Agent Soul 身份层（新）：

package/scripts/session-summarize.js

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-/**
- * session-summarize.js <chatId> <sessionId>
- * Generates a 3-5 sentence summary for an idle session via Haiku,
- * stores it in daemon_state.json for injection on next resume.
- *
- * Uses session-analytics.extractSkeleton() for robust JSONL parsing
- * (handles tool_use, artifacts, empty chunks without crashing).
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const [,, chatId, sessionId] = process.argv;
-if (!chatId || !sessionId) {
-  console.error('Usage: session-summarize.js <chatId> <sessionId>');
-  process.exit(1);
-}
-
-const HOME = os.homedir();
-const METAME_DIR = path.join(HOME, '.metame');
-const STATE_FILE = path.join(METAME_DIR, 'daemon_state.json');
-const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
-
-function findSessionFile(sid) {
-  try {
-    for (const dir of fs.readdirSync(CLAUDE_PROJECTS)) {
-      const p = path.join(CLAUDE_PROJECTS, dir, `${sid}.jsonl`);
-      if (fs.existsSync(p)) return p;
-    }
-  } catch { /* ignore */ }
-  return null;
-}
-
-function loadState() {
-  try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { return {}; }
-}
-
-function saveState(state) {
-  try { fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), 'utf8'); } catch { /* ignore */ }
-}
-
-async function main() {
-  const sessionFile = findSessionFile(sessionId);
-  if (!sessionFile) {
-    console.log(`[session-summarize] Session file not found for ${sessionId.slice(0, 8)}`);
-    return;
-  }
-
-  // Use extractSkeleton for robust parsing — already battle-tested on 100+ sessions.
-  // Handles tool_use blocks, artifacts, empty chunks, malformed lines gracefully.
-  let skeleton;
-  try {
-    const analytics = require('./session-analytics');
-    skeleton = analytics.extractSkeleton(sessionFile);
-  } catch (e) {
-    console.log(`[session-summarize] extractSkeleton failed: ${e.message}`);
-    return;
-  }
-
-  const snippets = skeleton.user_snippets || [];
-  if (snippets.length < 2) {
-    console.log(`[session-summarize] Too few user messages (${snippets.length}), skipping`);
-    return;
-  }
-
-  let callHaiku;
-  try {
-    callHaiku = require('./providers').callHaiku;
-  } catch (e) {
-    console.log(`[session-summarize] providers not available: ${e.message}`);
-    return;
-  }
-
-  // Build compact context from skeleton (safe strings, already sliced to 100 chars each)
-  const snippetText = snippets.join('\n- ');
-  const meta = [
-    skeleton.project ? `项目: ${skeleton.project}` : '',
-    skeleton.intent ? `首要意图: ${skeleton.intent}` : '',
-    skeleton.duration_min ? `时长: ${skeleton.duration_min}分钟` : '',
-    skeleton.total_tool_calls ? `工具调用: ${skeleton.total_tool_calls}次` : '',
-  ].filter(Boolean).join('，');
-
-  const prompt = `请用2-4句话简洁总结以下会话的核心内容和关键结论。只说结果和决策，不列举过程。中文输出。
-
-${meta}
-
-用户主要说了什么：
-- ${snippetText}`;
-
-  let summary;
-  try {
-    summary = await Promise.race([
-      callHaiku(prompt, {}, 30000),
-      new Promise((_, r) => setTimeout(() => r(new Error('timeout')), 35000)),
-    ]);
-    summary = (summary || '').trim().slice(0, 500);
-  } catch (e) {
-    console.log(`[session-summarize] Haiku call failed: ${e.message}`);
-    return;
-  }
-
-  if (!summary) return;
-
-  const state = loadState();
-  if (!state.sessions) state.sessions = {};
-  if (!state.sessions[chatId]) state.sessions[chatId] = {};
-  state.sessions[chatId].last_summary = summary;
-  state.sessions[chatId].last_summary_at = Date.now();
-  state.sessions[chatId].last_summary_session_id = sessionId;
-  saveState(state);
-
-  console.log(`[session-summarize] Saved for ${chatId} (${sessionId.slice(0, 8)}): ${summary.slice(0, 80)}...`);
-}
-
-main().catch(e => console.error(`[session-summarize] Fatal: ${e.message}`));