metame-cli 1.5.11 → 1.5.12

package/scripts/daemon-reactive-lifecycle.js

@@ -183,11 +183,12 @@ function runProjectVerifier(projectKey, config, deps) {
   const scripts = resolveProjectScripts(projectCwd, manifest);
   if (!fs.existsSync(scripts.verifier)) return null;
 
-  const statePath = path.join(
-    deps.metameDir || path.join(os.homedir(), '.metame'),
-    'memory', 'now', `${projectKey}.md`
-  );
-  const phase = readPhaseFromState(statePath);
+  const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
+  const statePath = path.join(metameDir, 'memory', 'now', `${projectKey}.md`);
+
+  // Read phase from event log (SoT), fall back to state file for backward compat
+  const { phase: eventPhase } = replayEventLog(projectKey, deps);
+  const phase = eventPhase || readPhaseFromState(statePath);
   const relVerifier = path.relative(projectCwd, scripts.verifier);
 
   try {
@@ -468,6 +469,379 @@ function reconcilePerpetualProjects(config, deps) {
   }
 }
 
+// ── Memory System (L1/L2) ───────────────────────────────────────
+
+/**
+ * Parse event log file into an array of event objects.
+ * Single read — callers share the result to avoid redundant I/O.
+ *
+ * @param {string} projectKey
+ * @param {object} deps
+ * @returns {Array<object>} Parsed events (malformed lines silently skipped)
+ */
+function parseEventLog(projectKey, deps) {
+  const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
+  const evDir = path.join(metameDir, 'events');
+  const logPath = path.join(evDir, `${projectKey}.jsonl`);
+  if (!fs.existsSync(logPath)) return [];
+
+  const raw = fs.readFileSync(logPath, 'utf8').trim().split('\n').filter(Boolean);
+  const events = [];
+  for (const line of raw) {
+    try { events.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  }
+  return events;
+}
+
+/**
+ * Build L1 running memory from parsed events.
+ * Extracts key decisions, lessons, phase trail, and round count
+ * from the current mission (since last MISSION_START).
+ *
+ * @param {string} projectKey
+ * @param {object} config
+ * @param {object} deps
+ * @param {Array<object>} [parsedEvents] - Pre-parsed events (avoids re-read)
+ * @returns {string} Markdown string (~600-800 tokens)
+ */
+function buildRunningMemory(projectKey, config, deps, parsedEvents) {
+  const events = parsedEvents || parseEventLog(projectKey, deps);
+  if (events.length === 0) return '';
+
+  // Find last MISSION_START to scope to current mission
+  let missionStartIdx = 0;
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].type === 'MISSION_START') {
+      missionStartIdx = i;
+      break;
+    }
+  }
+
+  const decisions = [];
+  const lessons = [];
+  const phaseTrail = [];
+  let roundCount = 0;
+
+  const decisionVerbs = /(?:chose|decided|switched|because|instead|using|adopted|rejected)/i;
+
+  for (let i = missionStartIdx; i < events.length; i++) {
+    const evt = events[i];
+
+    if (evt.type === 'MEMBER_COMPLETE') roundCount++;
+
+    if (evt.type === 'DISPATCH' && evt.prompt && evt.prompt.length > 80 && decisionVerbs.test(evt.prompt)) {
+      decisions.push({ round: roundCount, text: evt.prompt.slice(0, 150) });
+    }
+
+    if (evt.type === 'PHASE_GATE' && !evt.passed && evt.details) {
+      lessons.push({ round: roundCount, text: evt.details.slice(0, 120) });
+    }
+
+    if (evt.type === 'PHASE_GATE' && evt.passed) {
+      phaseTrail.push({ phase: evt.phase, round: roundCount });
+    }
+  }
+
+  const recentDecisions = decisions.slice(-5);
+  const recentLessons = lessons.slice(-5);
+
+  const parts = [];
+
+  if (recentDecisions.length > 0) {
+    if (parts.length > 0) parts.push('');
+    parts.push('## Recent Decisions');
+    for (const d of recentDecisions) {
+      parts.push(`- [R${d.round}] ${d.text}`);
+    }
+  }
+
+  if (recentLessons.length > 0) {
+    if (parts.length > 0) parts.push('');
+    parts.push('## Lessons Learned');
+    for (const l of recentLessons) {
+      parts.push(`- [R${l.round}] ${l.text}`);
+    }
+  }
+
+  if (phaseTrail.length > 0) {
+    if (parts.length > 0) parts.push('');
+    parts.push('## Phase Trail');
+    parts.push(phaseTrail.map(p => `${p.phase}(R${p.round})`).join(' → '));
+  }
+
+  if (parts.length === 0) return '';
+  return parts.join('\n');
+}
+
+/**
+ * Scan workspace for relevant artifacts (files sorted by mtime).
+ *
+ * @param {string} projectKey
+ * @param {object} config
+ * @param {object} deps
+ * @returns {Array<{ path: string, desc: string }>} Top 5 artifacts
+ */
+function scanRelevantArtifacts(projectKey, config, deps) {
+  const projectCwd = resolveProjectCwd(projectKey, config);
+  if (!projectCwd) return [];
+
+  const wsDir = path.join(projectCwd, 'workspace');
+  if (!fs.existsSync(wsDir)) return [];
+
+  const validExts = new Set(['.md', '.json', '.tsv', '.py', '.csv']);
+  const files = [];
+
+  // Walk max depth 2
+  try {
+    const d1Entries = fs.readdirSync(wsDir, { withFileTypes: true });
+    for (const e1 of d1Entries) {
+      const p1 = path.join(wsDir, e1.name);
+      if (e1.isFile() && validExts.has(path.extname(e1.name))) {
+        try { files.push({ abs: p1, rel: `workspace/${e1.name}`, mtime: fs.statSync(p1).mtimeMs }); } catch { /* skip */ }
+      } else if (e1.isDirectory()) {
+        try {
+          const d2Entries = fs.readdirSync(p1, { withFileTypes: true });
+          for (const e2 of d2Entries) {
+            if (e2.isFile() && validExts.has(path.extname(e2.name))) {
+              const p2 = path.join(p1, e2.name);
+              try { files.push({ abs: p2, rel: `workspace/${e1.name}/${e2.name}`, mtime: fs.statSync(p2).mtimeMs }); } catch { /* skip */ }
+            }
+          }
+        } catch { /* skip unreadable dirs */ }
+      }
+    }
+  } catch { return []; }
+
+  // Sort by mtime descending, take top 5
+  files.sort((a, b) => b.mtime - a.mtime);
+  const top = files.slice(0, 5);
+
+  // Heuristic descriptions based on path/name
+  const descMap = {
+    'progress.tsv': 'phase progress tracker',
+    'results': 'experiment results',
+    'proposal': 'research proposal',
+    'draft': 'paper draft',
+    'notes': 'research notes',
+    'config': 'configuration',
+    'data': 'dataset',
+  };
+
+  return top.map(f => {
+    let desc = path.extname(f.rel).slice(1) + ' file';
+    for (const [key, label] of Object.entries(descMap)) {
+      if (f.rel.toLowerCase().includes(key)) { desc = label; break; }
+    }
+    return { path: f.rel, desc };
+  });
+}
+
+/**
+ * Build L2 working memory from event log replay + memory.db FTS5.
+ *
+ * @param {string} projectKey
+ * @param {object} config
+ * @param {object} deps
+ * @returns {string} Markdown string (~300-500 tokens)
+ */
+function buildWorkingMemory(projectKey, config, deps) {
+  const parts = [];
+
+  // Phase history as causal chain from event replay
+  const { phase, mission, history } = replayEventLog(projectKey, deps);
+
+  // FTS5 query: mission title + current phase (fixed rule, no smart inference)
+  const query = ((mission?.title || '') + ' ' + (phase || '')).trim();
+  if (!query) return '';
+
+  let facts = [];
+  try {
+    const memory = require('./memory');
+    memory.acquire();
+    try {
+      facts = memory.searchFacts(query, { limit: 5, project: projectKey });
+    } finally {
+      memory.release();
+    }
+  } catch { /* memory.db unavailable — graceful degradation */ }
+
+  if (facts.length > 0) {
+    parts.push('## Long-term Context');
+    for (const f of facts) {
+      const tag = f.relation || f.entity || 'fact';
+      parts.push(`- [${tag}] ${f.value}`);
+    }
+  }
+
+  if (parts.length === 0) return '';
+  return parts.join('\n');
+}
+
+/**
+ * Persist unified memory file (L1 + L2 merged).
+ * L1 rebuilds every round; L2 refreshes every 5 rounds or on phase change.
+ *
+ * @param {string} projectKey
+ * @param {object} config
+ * @param {object} deps
+ * @param {object} [opts]
+ * @param {boolean} [opts.phaseChanged]
+ */
+function persistMemoryFiles(projectKey, config, deps, opts = {}) {
+  const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
+  const memDir = path.join(metameDir, 'memory', 'now');
+  fs.mkdirSync(memDir, { recursive: true });
+  const memPath = path.join(memDir, `${projectKey}_memory.md`);
+
+  // Single parse of event log — shared across L1 and round counting
+  const events = parseEventLog(projectKey, deps);
+
+  // Derive round count and mission title from parsed events
+  let roundCount = 0;
+  let missionTitle = 'unknown';
+  let maxDepth = 50;
+  for (const evt of events) {
+    if (evt.type === 'MEMBER_COMPLETE') roundCount++;
+    if (evt.type === 'MISSION_START') { missionTitle = evt.mission_title || 'unknown'; roundCount = 0; }
+    if (evt.type === 'MISSION_COMPLETE') roundCount = 0;
+  }
+
+  // Read manifest for max_depth
+  const projectCwd = resolveProjectCwd(projectKey, config);
+  if (projectCwd) {
+    const manifest = loadProjectManifest(projectCwd);
+    if (manifest?.max_depth) maxDepth = manifest.max_depth;
+  }
+
+  // Always rebuild L1 (pass pre-parsed events to avoid re-read)
+  const l1 = buildRunningMemory(projectKey, config, deps, events);
+  const artifacts = scanRelevantArtifacts(projectKey, config, deps);
+
+  // Conditionally rebuild L2 (every 5 rounds or phase change)
+  const shouldRefreshL2 = opts.phaseChanged || (roundCount % 5 === 0);
+  let l2 = '';
+  if (shouldRefreshL2) {
+    l2 = buildWorkingMemory(projectKey, config, deps);
+    // Stash L2 for next time
+    try {
+      const l2CachePath = path.join(memDir, `${projectKey}_l2cache.md`);
+      fs.writeFileSync(l2CachePath, l2, 'utf8');
+    } catch { /* non-critical */ }
+  } else {
+    // Read stale L2 from cache
+    try {
+      const l2CachePath = path.join(memDir, `${projectKey}_l2cache.md`);
+      if (fs.existsSync(l2CachePath)) {
+        l2 = fs.readFileSync(l2CachePath, 'utf8').trim();
+      }
+    } catch { /* non-critical */ }
+  }
+
+  // Build merged document
+  const parts = [`# Memory Context: ${missionTitle} (round ${roundCount}/${maxDepth})`];
+
+  if (l1) parts.push('', l1);
+
+  if (artifacts.length > 0) {
+    parts.push('', '## Current Artifacts');
+    for (const a of artifacts) {
+      parts.push(`- ${a.path} — ${a.desc}`);
+    }
+  }
+
+  if (l2) parts.push('', l2);
+
+  const content = parts.join('\n') + '\n';
+  fs.writeFileSync(memPath, content, 'utf8');
+  return memPath;
+}
+
+/**
+ * Pattern-based inline fact extraction from agent output.
+ * Zero LLM, zero agent format dependency.
+ *
+ * @param {string} projectKey
+ * @param {string} memberOutput
+ * @param {string} [phase]
+ * @returns {Array<{ entity: string, relation: string, value: string, confidence: string }>}
+ */
+function extractInlineFacts(projectKey, memberOutput, phase) {
+  if (!memberOutput || typeof memberOutput !== 'string') return [];
+
+  const facts = [];
+  const CAP = 3;
+
+  // Pattern 1: Error/OOM patterns → bug_lesson
+  const errorRe = /(?:OOM|out of memory|CUDA error|killed|Error:|Exception:|Failed:)\s*(.{15,150})/gi;
+  let match;
+  while ((match = errorRe.exec(memberOutput)) !== null && facts.length < CAP) {
+    facts.push({
+      entity: projectKey,
+      relation: 'bug_lesson',
+      value: match[0].trim().slice(0, 150),
+      confidence: 'medium',
+    });
+  }
+
+  // Pattern 2: Decision verbs → tech_decision
+  const decisionRe = /(?:decided|chose|selected|switched to|rejected|using|adopted)\s+(.{20,150})/gi;
+  while ((match = decisionRe.exec(memberOutput)) !== null && facts.length < CAP) {
+    facts.push({
+      entity: projectKey,
+      relation: 'tech_decision',
+      value: match[0].trim().slice(0, 150),
+      confidence: 'low',
+    });
+  }
+
+  return facts.slice(0, CAP);
+}
+
+/**
+ * Extract a high-density summary from agent output.
+ * Tail-biased: conclusions and results are usually at the end.
+ * Zero LLM — pure heuristic.
+ *
+ * Strategy:
+ *   - Head (~200 chars): who's speaking, opening context
+ *   - Key lines: lines containing signal words (conclusions, decisions, errors)
+ *   - Tail (~600 chars): final output, conclusions, recommendations
+ *
+ * @param {string} output - Raw agent output
+ * @param {number} [maxLen=1200] - Max total length
+ * @returns {string}
+ */
+function extractOutputSummary(output, maxLen = 1200) {
+  if (!output || output.length <= maxLen) return output || '';
+
+  // Adaptive head/tail sizes — scale down for small maxLen
+  const HEAD_LEN = Math.min(200, Math.floor(maxLen * 0.25));
+  const TAIL_LEN = Math.min(600, Math.floor(maxLen * 0.6));
+  const KEY_BUDGET = Math.max(0, maxLen - HEAD_LEN - TAIL_LEN - 40);
+
+  const head = output.slice(0, HEAD_LEN);
+  const tail = output.slice(-TAIL_LEN);
+
+  // Extract key signal lines from the middle (skip head/tail zones)
+  let keyLines = '';
+  if (KEY_BUDGET > 0 && output.length > HEAD_LEN + TAIL_LEN) {
+    const middleZone = output.slice(HEAD_LEN, -TAIL_LEN);
+    const signalRe = /(?:结论|conclusion|found that|result|决定|recommend|建议|发现|关键|key finding|error|OOM|failed|chose|decided|switched|important|注意|warning)/i;
+    keyLines = middleZone.split('\n')
+      .filter(line => line.trim().length > 15 && signalRe.test(line))
+      .slice(0, 5)
+      .join('\n')
+      .slice(0, KEY_BUDGET);
+  }
+
+  const parts = [head.trimEnd()];
+  if (keyLines) parts.push('[...key findings...]', keyLines);
+  else parts.push('[...]');
+  parts.push(tail.trimStart());
+
+  return parts.join('\n').slice(0, maxLen);
+}
+
 // ── Main handler ────────────────────────────────────────────────
 
 /**
@@ -601,6 +975,10 @@ function handleReactiveOutput(targetProject, output, config, deps) {
         new_session: true,
       }, config);
     }
+
+    // Point B: Persist memory after parent dispatches
+    try { persistMemoryFiles(projectKey, config, deps); } catch { /* non-critical */ }
+
     return;
   }
 
@@ -684,13 +1062,31 @@ function handleReactiveOutput(targetProject, output, config, deps) {
     try { generateStateFile(parentKey, config, deps); } catch { /* non-critical */ }
   }
 
-  // Trigger parent with member's output summary
+  // Point A: Persist memory + extract inline facts after verifier, before waking parent
+  const phaseChanged = verifyResult?.passed && !!verifyResult?.phase;
+  try { persistMemoryFiles(parentKey, config, deps, { phaseChanged }); } catch { /* non-critical */ }
+
+  // Inline fact extraction from member output
+  try {
+    const inlineFacts = extractInlineFacts(parentKey, output, verifyResult?.phase);
+    if (inlineFacts.length > 0) {
+      const memory = require('./memory');
+      memory.acquire();
+      try {
+        memory.saveFacts(`reactive-${parentKey}-${Date.now()}`, parentKey, inlineFacts);
+      } finally {
+        memory.release();
+      }
+    }
+  } catch { /* non-critical */ }
+
+  // Trigger parent with member's output summary (tail-biased extraction)
   const parentManifest = parentCwd ? loadProjectManifest(parentCwd) : null;
   const signal = parentManifest?.completion_signal || 'MISSION_COMPLETE';
-  const summary = output.slice(0, 1200);
+  const summary = extractOutputSummary(output);
   deps.handleDispatchItem({
     target: parentKey,
-    prompt: `[Team delivery] ${targetProject} completed task.\n\nOutput summary:\n${summary}${verifierBlock}\n\nEvaluate quality and decide next step.\nTo dispatch tasks, use NEXT_DISPATCH.\nWhen all tasks are done, output ${signal}.`,
+    prompt: `[${targetProject} delivery]${verifierBlock}\n\n${summary}\n\nDecide next step. Use NEXT_DISPATCH or ${signal}.`,
     from: targetProject,
     _reactive: true,
     new_session: true,
@@ -702,5 +1098,5 @@ module.exports = {
   parseReactiveSignals,
   reconcilePerpetualProjects,
   replayEventLog,
-  __test: { runProjectVerifier, readPhaseFromState, resolveProjectCwd, appendEvent, projectProgressTsv, generateStateFile, loadProjectManifest, resolveProjectScripts },
+  __test: { runProjectVerifier, readPhaseFromState, resolveProjectCwd, appendEvent, projectProgressTsv, generateStateFile, loadProjectManifest, resolveProjectScripts, parseEventLog, buildRunningMemory, scanRelevantArtifacts, buildWorkingMemory, persistMemoryFiles, extractInlineFacts, extractOutputSummary },
 };

package/scripts/daemon-session-commands.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { normalizeEngineName: _normalizeEngine } = require('./daemon-utils');
+
 function createSessionCommandHandler(deps) {
   const {
     fs,
@@ -29,8 +31,7 @@ function createSessionCommandHandler(deps) {
   } = deps;
 
   function normalizeEngineName(name) {
-    const n = String(name || '').trim().toLowerCase();
-    return n === 'codex' ? 'codex' : getDefaultEngine();
+    return _normalizeEngine(name, getDefaultEngine);
   }
 
   function inferStoredEngine(rawSession) {

package/scripts/daemon-session-store.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const crypto = require('crypto');
+const { normalizeEngineName } = require('./daemon-utils');
 
 function normalizeCodexSandboxMode(value, fallback = null) {
   const text = String(value || '').trim().toLowerCase();
@@ -45,10 +46,6 @@ function normalizeCodexPermissionMeta(meta = {}) {
   };
 }
 
-function normalizeEngineName(name) {
-  return String(name || 'claude').trim().toLowerCase() === 'codex' ? 'codex' : 'claude';
-}
-
 function stripCodexInjectedHints(text) {
   return String(text || '')
     .replace(/\r\n/g, '\n')
@@ -217,17 +214,36 @@ function createSessionStore(deps) {
   }
 
   // [M3] 共享辅助：从 reversed JSONL 行数组中提取最后一条外部用户消息（统一规则）
+  function _extractMessageText(d) {
+    const content = d.message && d.message.content;
+    let raw = typeof content === 'string' ? content
+      : Array.isArray(content) ? (content.find(c => c.type === 'text') || {}).text || '' : '';
+    raw = raw.replace(/\[System hints[\s\S]*/i, '')
+      .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+    return raw;
+  }
+
   function extractLastUserFromLines(lines) {
     for (const line of lines) {
       if (!line) continue;
       try {
         const d = JSON.parse(line);
         if (d.type === 'user' && d.message && d.userType !== 'internal') {
-          const content = d.message.content;
-          let raw = typeof content === 'string' ? content
-            : Array.isArray(content) ? (content.find(c => c.type === 'text') || {}).text || '' : '';
-          raw = raw.replace(/\[System hints[\s\S]*/i, '')
-            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+          const raw = _extractMessageText(d);
+          if (raw.length > 2) return raw.slice(0, 80);
+        }
+      } catch { /* skip */ }
+    }
+    return '';
+  }
+
+  function extractLastAssistantFromLines(lines) {
+    for (const line of lines) {
+      if (!line) continue;
+      try {
+        const d = JSON.parse(line);
+        if (d.type === 'assistant' && d.message) {
+          const raw = _extractMessageText(d);
           if (raw.length > 2) return raw.slice(0, 80);
         }
       } catch { /* skip */ }
@@ -256,11 +272,30 @@ function createSessionStore(deps) {
               }
             }
           }
-          // Fallback: decode projectPath from directory name (e.g. -Users-yaron-AGI-AChat → /Users/yaron/AGI/AChat)
+          // Fallback: decode projectPath from directory name (macOS: -Users-foo → /Users/foo)
           if (!projPathCache.has(proj) && proj.startsWith('-')) {
             const decoded = proj.replace(/-/g, '/');
             if (fs.existsSync(decoded)) projPathCache.set(proj, decoded);
           }
+          // Fallback 2: read cwd from first JSONL entry (works on all platforms,
+          // handles directory names that can't be reliably decoded, e.g. Windows paths
+          // with drive letters or filenames containing hyphens)
+          if (!projPathCache.has(proj)) {
+            try {
+              const _jsonls = fs.readdirSync(projDir).filter(f => f.endsWith('.jsonl'));
+              if (_jsonls.length > 0) {
+                const _fd = fs.openSync(path.join(projDir, _jsonls[0]), 'r');
+                try {
+                  const _buf = Buffer.alloc(4096);
+                  const _bytes = fs.readSync(_fd, _buf, 0, 4096, 0);
+                  for (const _line of _buf.toString('utf8', 0, _bytes).split('\n')) {
+                    if (!_line) continue;
+                    try { const _d = JSON.parse(_line); if (_d.cwd) { projPathCache.set(proj, path.resolve(_d.cwd)); break; } } catch {}
+                  }
+                } finally { fs.closeSync(_fd); }
+              }
+            } catch {}
+          }
         } catch { /* skip */ }
 
         try {
@@ -287,6 +322,8 @@ function createSessionStore(deps) {
       }
 
       const all = Array.from(sessionMap.values()).map((entry) => ({ ...entry, engine: 'claude' }));
+      // Sort by recency BEFORE enrichment so we enrich the most recent sessions first
+      all.sort((a, b) => (b.fileMtime || 0) - (a.fileMtime || 0));
       const ENRICH_LIMIT = 20;
       for (let i = 0; i < Math.min(all.length, ENRICH_LIMIT); i++) {
         const s = all[i];
@@ -338,6 +375,9 @@ function createSessionStore(deps) {
             if (!s.lastUser) {
               s.lastUser = extractLastUserFromLines(tailLines);
             }
+            if (!s.lastAssistant) {
+              s.lastAssistant = extractLastAssistantFromLines(tailLines);
+            }
           } finally {
             fs.closeSync(fd);
           }
@@ -613,6 +653,13 @@ function createSessionStore(deps) {
     return s.sessionId ? s.sessionId.slice(0, 8) : '';
   }
 
+  // ── Display helpers (shared by sessionRichLabel & buildSessionCardElements) ──
+  const _escapeMd = (t) => t.replace(/[_*`\\]/g, '\\$&');
+  function _cleanSnippet(raw, maxLen) {
+    if (!raw || raw.length <= 2) return '';
+    return _escapeMd(raw.replace(/\n/g, ' ').slice(0, maxLen)) + (raw.length > maxLen ? '…' : '');
+  }
+
   function sessionRichLabel(s, index, sessionTags) {
     sessionTags = sessionTags || loadSessionTags();
     const title = sessionDisplayTitle(s, 50, sessionTags);
@@ -622,17 +669,15 @@ function createSessionStore(deps) {
     const tags = (sessionTags[s.sessionId] && sessionTags[s.sessionId].tags || []).slice(0, 3);
     const engineLabel = (s.engine || 'claude') === 'codex' ? 'codex' : 'claude';
 
-    // [M2] 转义 markdown 特殊字符，防止用户历史消息破坏渲染
-    const escapeMd = (t) => t.replace(/[_*`\\]/g, '\\$&');
-    // fallback to firstPrompt when lastUser not found in tail
-    const snippetRaw = s.lastUser || (s.firstPrompt || '').replace(/<[^>]+>/g, '').replace(/\[System hints[\s\S]*/i, '').trim().slice(0, 80);
-    let line = `${index}. ${title}${title.length >= 50 ? '..' : ''}`;  // [M4] title 已有 sessionId 兜底，不会为空
+    let line = `${index}. ${title}${title.length >= 50 ? '..' : ''}`;
     if (tags.length) line += `  ${tags.map(t => `#${t}`).join(' ')}`;
     line += `\n   📁${proj} · ${ago} · ${engineLabel}`;
-    if (snippetRaw && snippetRaw.length > 2) {
-      const snippet = escapeMd(snippetRaw.replace(/\n/g, ' ').slice(0, 60));
-      line += `\n   💬 ${snippet}${snippetRaw.length > 60 ? '…' : ''}`;
-    }
+    const firstSnippet = _cleanSnippet(s.firstPrompt, 50);
+    const lastUserSnippet = _cleanSnippet(s.lastUser, 50);
+    const lastAiSnippet = _cleanSnippet(s.lastAssistant, 50);
+    if (firstSnippet) line += `\n   📝 ${firstSnippet}`;
+    if (lastUserSnippet && lastUserSnippet !== firstSnippet) line += `\n   💬 ${lastUserSnippet}`;
+    if (lastAiSnippet) line += `\n   🤖 ${lastAiSnippet}`;
     line += `\n   /resume ${shortId}`;
     return line;
   }
@@ -648,15 +693,16 @@ function createSessionStore(deps) {
       const shortId = s.sessionId.slice(0, 6);
       const tags = (sessionTags[s.sessionId] && sessionTags[s.sessionId].tags || []).slice(0, 4);
       const engineLabel = (s.engine || 'claude') === 'codex' ? 'codex' : 'claude';
-      // [M2] 转义 markdown 特殊字符；[M4] title 已有 sessionId 兜底
-      const escapeMd = (t) => t.replace(/[_*`\\]/g, '\\$&');
-      const snippetRaw = s.lastUser || (s.firstPrompt || '').replace(/<[^>]+>/g, '').replace(/\[System hints[\s\S]*/i, '').trim().slice(0, 80);
+
       let desc = `**${i + 1}. ${title}**\n📁${proj} · ${ago} · ${engineLabel}`;
       if (tags.length) desc += `\n${tags.map(t => `\`${t}\``).join(' ')}`;
-      if (snippetRaw && snippetRaw.length > 2) {
-        const snippet = escapeMd(snippetRaw.replace(/\n/g, ' ').slice(0, 60));
-        desc += `\n💬 ${snippet}${snippetRaw.length > 60 ? '…' : ''}`;
-      }
+      // Show first prompt, last user message, and last assistant reply
+      const firstSnippet = _cleanSnippet(s.firstPrompt, 50);
+      const lastUserSnippet = _cleanSnippet(s.lastUser, 50);
+      const lastAiSnippet = _cleanSnippet(s.lastAssistant, 50);
+      if (firstSnippet) desc += `\n📝 ${firstSnippet}`;
+      if (lastUserSnippet && lastUserSnippet !== firstSnippet) desc += `\n💬 ${lastUserSnippet}`;
+      if (lastAiSnippet) desc += `\n🤖 ${lastAiSnippet}`;
       elements.push({ tag: 'div', text: { tag: 'lark_md', content: desc } });
       elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: `▶️ Switch #${shortId}` }, type: 'primary', value: { cmd: `/resume ${s.sessionId}` } }] });
     });
@@ -924,6 +970,9 @@ function createSessionStore(deps) {
       }
       slot.started = true;
       s.last_active = Date.now();
+      // Clear stale findSessionFile cache: the JSONL/SQLite file now exists
+      // but may have been cached as null during createSession (before CLI created it).
+      if (slot.id) clearSessionFileCache(slot.id);
     } else {
       s.started = true; // old flat format
       s.last_active = Date.now();
@@ -970,7 +1019,13 @@ function createSessionStore(deps) {
   // Best approach: read cwd directly from session file content (not from dir name)
   function _isClaudeSessionValid(sessionId, normCwd) {
     try {
-      const sessionFile = findSessionFile(sessionId);
+      let sessionFile = findSessionFile(sessionId);
+      if (!sessionFile) {
+        // Cache may hold a stale null from createSession (before CLI wrote the JSONL).
+        // Clear and retry once to avoid false invalidation.
+        clearSessionFileCache(sessionId);
+        sessionFile = findSessionFile(sessionId);
+      }
       if (!sessionFile) {
         log('WARN', `[SessionValid] ${sessionId.slice(0, 8)}: JSONL file not found`);
         return false;