metame-cli 1.5.19 → 1.5.21

package/scripts/daemon-session-store.js

@@ -85,13 +85,69 @@ function createSessionStore(deps) {
   } = deps;
 
   const CLAUDE_PROJECTS_DIR = path.join(HOME, '.claude', 'projects');
-  const CODEX_DB = path.join(HOME, '.codex', 'state_5.sqlite');
+  const GLOBAL_CODEX_DB = path.join(HOME, '.codex', 'state_5.sqlite');
   const _sessionFileCache = new Map(); // sessionId -> { path, ts }
   const _codexRolloutCache = new Map(); // sessionId -> { path, ts }
   let _sessionCache = null;
   let _sessionCacheTime = 0;
   const SESSION_CACHE_TTL = 30000; // 30s — scan is expensive, 10s was too frequent
 
+  function resolveCodexHomeForCwd(cwd) {
+    const safeCwd = sanitizeCwd(cwd);
+    if (!safeCwd || safeCwd === HOME) return path.join(HOME, '.codex');
+    return path.join(safeCwd, '.codex');
+  }
+
+  function resolveCodexDbForCwd(cwd) {
+    return path.join(resolveCodexHomeForCwd(cwd), 'state_5.sqlite');
+  }
+
+  function getKnownCodexDbPaths(preferredCwd = '') {
+    const paths = [];
+    const seen = new Set();
+    const add = (candidate) => {
+      const value = String(candidate || '').trim();
+      if (!value || seen.has(value)) return;
+      seen.add(value);
+      paths.push(value);
+    };
+
+    const preferredDb = preferredCwd ? resolveCodexDbForCwd(preferredCwd) : '';
+    if (preferredDb) add(preferredDb);
+
+    try {
+      const state = loadState() || {};
+      const sessions = state.sessions || {};
+      for (const raw of Object.values(sessions)) {
+        if (!raw || typeof raw !== 'object') continue;
+        const candidateCwd = sanitizeCwd(raw.cwd || '');
+        if (candidateCwd) add(resolveCodexDbForCwd(candidateCwd));
+      }
+    } catch { /* ignore */ }
+
+    add(GLOBAL_CODEX_DB);
+    return paths;
+  }
+
+  function queryCodexDbs(preferredCwd, queryFn) {
+    const dbPaths = getKnownCodexDbPaths(preferredCwd);
+    for (const dbPath of dbPaths) {
+      let db = null;
+      try {
+        if (!fs.existsSync(dbPath)) continue;
+        const { DatabaseSync } = require('node:sqlite');
+        db = new DatabaseSync(dbPath, { readonly: true });
+        const result = queryFn(db, dbPath);
+        db.close();
+        db = null;
+        if (result) return result;
+      } catch {
+        if (db) { try { db.close(); } catch { /* ignore */ } }
+      }
+    }
+    return null;
+  }
+
   function findSessionFile(sessionId) {
     if (!sessionId || !fs.existsSync(CLAUDE_PROJECTS_DIR)) return null;
     const cached = _sessionFileCache.get(sessionId);
@@ -177,6 +233,51 @@ function createSessionStore(deps) {
     }
   }
 
+  /**
+   * Strip thinking block signatures from a session JSONL file.
+   * This allows resuming sessions after switching models (e.g. MiniMax → Claude)
+   * without hitting "Invalid signature in thinking block" errors.
+   * Returns the number of signatures stripped, or 0 if nothing changed.
+   */
+  function stripThinkingSignatures(sessionId) {
+    try {
+      const sessionFile = findSessionFile(sessionId);
+      if (!sessionFile) return 0;
+      const fileContent = fs.readFileSync(sessionFile, 'utf8');
+      const lines = fileContent.split('\n');
+      let changed = 0;
+      const patched = lines.map(line => {
+        if (!line.trim()) return line;
+        try {
+          const obj = JSON.parse(line);
+          const content = obj && obj.message && obj.message.content;
+          if (!Array.isArray(content)) return line;
+          let lineChanged = false;
+          for (const block of content) {
+            if (block && block.type === 'thinking' && block.signature) {
+              delete block.signature;
+              lineChanged = true;
+            }
+          }
+          if (lineChanged) {
+            changed++;
+            return JSON.stringify(obj);
+          }
+        } catch { /* skip malformed lines */ }
+        return line;
+      });
+      if (changed > 0) {
+        fs.writeFileSync(sessionFile, patched.join('\n'), 'utf8');
+        _sessionFileCache.delete(sessionId);
+        log('INFO', `stripThinkingSignatures: patched ${changed} lines in ${path.basename(sessionFile)}`);
+      }
+      return changed;
+    } catch (e) {
+      log('WARN', `stripThinkingSignatures failed: ${e.message}`);
+      return 0;
+    }
+  }
+
   function invalidateSessionCache() { _sessionCache = null; }
 
   // 监听 ~/.claude/projects 目录，手机端新建 session 后桌面端无需重启即可感知
@@ -296,8 +397,8 @@ function createSessionStore(deps) {
               }
             } catch {}
           }
-        } catch (err) {
-          log('WARN', `scanClaudeSessions project ${proj}: ${err.message}`);
+        } catch (e) {
+          log('WARN', `[session-store] scanClaudeSessions project ${proj} index error: ${e.message}`);
         }
 
         try {
@@ -320,8 +421,8 @@ function createSessionStore(deps) {
               });
             }
           }
-        } catch (err) {
-          log('WARN', `scanClaudeSessions project ${proj}: ${err.message}`);
+        } catch (e) {
+          log('WARN', `[session-store] scanClaudeSessions project ${proj} file error: ${e.message}`);
         }
       }
 
@@ -389,37 +490,52 @@ function createSessionStore(deps) {
         } catch { /* non-fatal */ }
       }
       return all;
-    } catch (err) {
-      log('WARN', `scanClaudeSessions: ${err.message}`);
+    } catch (e) {
+      log('WARN', `[session-store] scanClaudeSessions failed: ${e.message}`);
       return [];
     }
   }
 
   function scanCodexSessions() {
-    let db = null;
     try {
-      if (!fs.existsSync(CODEX_DB)) return [];
-      const { DatabaseSync } = require('node:sqlite');
-      db = new DatabaseSync(CODEX_DB, { readonly: true });
-      const rows = db.prepare(`
-        SELECT
-          id,
-          cwd,
-          title,
-          first_user_message,
-          source,
-          rollout_path,
-          created_at,
-          updated_at,
-          tokens_used,
-          archived
-        FROM threads
-        ORDER BY updated_at DESC
-        LIMIT 200
-      `).all();
-      db.close();
-      db = null;
-      return rows
+      const seen = new Set();
+      const merged = [];
+      for (const dbPath of getKnownCodexDbPaths()) {
+        if (!fs.existsSync(dbPath)) continue;
+        let db = null;
+        try {
+          const { DatabaseSync } = require('node:sqlite');
+          db = new DatabaseSync(dbPath, { readonly: true });
+          const rows = db.prepare(`
+            SELECT
+              id,
+              cwd,
+              title,
+              first_user_message,
+              source,
+              rollout_path,
+              created_at,
+              updated_at,
+              tokens_used,
+              archived
+            FROM threads
+            ORDER BY updated_at DESC
+            LIMIT 200
+          `).all();
+          db.close();
+          db = null;
+          for (const row of rows) {
+            const key = String(row && row.id || '').trim();
+            if (!key || seen.has(key)) continue;
+            seen.add(key);
+            merged.push(row);
+          }
+        } catch (e) {
+          log('WARN', `[session-store] scanCodexSessions failed for ${dbPath}: ${e.message}`);
+          if (db) { try { db.close(); } catch { /* ignore */ } }
+        }
+      }
+      return merged
         .filter((row) => {
           if (row.archived || !row.id || !row.cwd) return false;
           const seedText = String(row.first_user_message || row.title || '').trim();
@@ -449,31 +565,22 @@ function createSessionStore(deps) {
           };
         })
         .map((session) => enrichCodexSession(session));
-    } catch (err) {
-      if (db) { try { db.close(); } catch { /* ignore */ } }
-      log('WARN', `scanCodexSessions ${CODEX_DB}: ${err.message}`);
+    } catch (e) {
+      log('WARN', `[session-store] scanCodexSessions failed: ${e.message}`);
       return [];
     }
   }
 
-  function findCodexSessionFile(sessionId) {
-    if (!sessionId || !fs.existsSync(CODEX_DB)) return null;
+  function findCodexSessionFile(sessionId, cwd = '') {
+    if (!sessionId) return null;
     const cached = _codexRolloutCache.get(sessionId);
     if (cached && Date.now() - cached.ts < 30000) return cached.path;
-    let db = null;
-    try {
-      const { DatabaseSync } = require('node:sqlite');
-      db = new DatabaseSync(CODEX_DB, { readonly: true });
+    const result = queryCodexDbs(cwd, (db) => {
       const row = db.prepare('SELECT rollout_path FROM threads WHERE id = ?').get(sessionId);
-      db.close();
-      db = null;
-      const rolloutPath = row && row.rollout_path ? String(row.rollout_path) : null;
-      _codexRolloutCache.set(sessionId, { path: rolloutPath, ts: Date.now() });
-      return rolloutPath;
-    } catch {
-      if (db) { try { db.close(); } catch { /* ignore */ } }
-      return null;
-    }
+      return row && row.rollout_path ? String(row.rollout_path) : null;
+    });
+    _codexRolloutCache.set(sessionId, { path: result, ts: Date.now() });
+    return result;
   }
 
   function extractCodexMessageText(payload) {
@@ -550,15 +657,19 @@ function createSessionStore(deps) {
 
   function scanAllSessions() {
     if (_sessionCache && (Date.now() - _sessionCacheTime < SESSION_CACHE_TTL)) return _sessionCache;
-    const all = [...scanClaudeSessions(), ...scanCodexSessions()];
-    all.sort((a, b) => {
-      const aTime = a.fileMtime || new Date(a.modified).getTime();
-      const bTime = b.fileMtime || new Date(b.modified).getTime();
-      return bTime - aTime;
-    });
-    _sessionCache = all;
-    _sessionCacheTime = Date.now();
-    return all;
+    try {
+      const all = [...scanClaudeSessions(), ...scanCodexSessions()];
+      all.sort((a, b) => {
+        const aTime = a.fileMtime || new Date(a.modified).getTime();
+        const bTime = b.fileMtime || new Date(b.modified).getTime();
+        return bTime - aTime;
+      });
+      _sessionCache = all;
+      _sessionCacheTime = Date.now();
+      return all;
+    } catch {
+      return [];
+    }
   }
 
   function listRecentSessions(limit, cwd, engine) {
@@ -573,6 +684,111 @@ function createSessionStore(deps) {
     return all.slice(0, limit || 10);
   }
 
+  function buildPendingStateSessions(engine, cwd) {
+    const safeEngine = normalizeEngineName(engine);
+    const normCwd = cwd ? path.resolve(cwd) : null;
+    const state = loadState();
+    const sessions = state && state.sessions && typeof state.sessions === 'object' ? state.sessions : {};
+    const items = [];
+
+    for (const [chatKey, raw] of Object.entries(sessions)) {
+      const upgraded = upgradeSessionRecord(raw || {}, safeEngine);
+      const slot = upgraded.engines && upgraded.engines[safeEngine];
+      const sessionCwd = upgraded.cwd ? path.resolve(upgraded.cwd) : null;
+      if (!slot || !sessionCwd) continue;
+      if (normCwd && sessionCwd !== normCwd) continue;
+
+      const compactContext = String(slot.compactContext || '').trim();
+      const hasBridgeContext = compactContext.length > 0;
+      const hasPlaceholder = safeEngine === 'codex' && slot.runtimeSessionObserved === false;
+      const hasId = !!String(slot.id || '').trim();
+      const validId = hasId ? isEngineSessionValid(safeEngine, slot.id, sessionCwd) : false;
+      if (validId) continue;
+      if (!hasBridgeContext && !hasPlaceholder) continue;
+
+      const ts = Number(raw && raw.last_active) || 0;
+      const compactLines = compactContext.split('\n').map(line => line.trim()).filter(Boolean);
+      const lastUserLine = compactLines.find(line => /^last user message:/i.test(line));
+      const lastAssistantLine = compactLines.find(line => /^last assistant reply:/i.test(line));
+      const summary = hasBridgeContext
+        ? (
+            lastUserLine
+            || lastAssistantLine
+            || compactLines[0]
+            || '待接续上下文'
+          )
+        : '待接续上下文';
+      items.push({
+        sessionId: '',
+        projectPath: sessionCwd,
+        fileMtime: ts,
+        modified: new Date(ts || Date.now()).toISOString(),
+        messageCount: '?',
+        customTitle: '待接续上下文',
+        summary,
+        firstPrompt: summary,
+        lastUser: '',
+        _enriched: true,
+        engine: safeEngine,
+        pendingState: true,
+        pendingChatKey: chatKey,
+        compactContext,
+        started: false,
+        runtimeSessionObserved: false,
+        ...(slot.sandboxMode ? { sandboxMode: slot.sandboxMode } : {}),
+        ...(slot.approvalPolicy ? { approvalPolicy: slot.approvalPolicy } : {}),
+        ...(slot.permissionMode ? { permissionMode: slot.permissionMode } : {}),
+      });
+    }
+
+    items.sort((a, b) => (b.fileMtime || 0) - (a.fileMtime || 0));
+    return items;
+  }
+
+  function findAttachableSession(options = {}) {
+    const safeEngine = normalizeEngineName(options.engine);
+    const cwd = options.cwd ? path.resolve(options.cwd) : null;
+    const preferredSessionId = String(options.preferredSessionId || '').trim();
+    const excludeSessionId = String(options.excludeSessionId || '').trim();
+    const limit = Number(options.limit) > 0 ? Number(options.limit) : 20;
+    const allowGlobalFallback = !!options.allowGlobalFallback;
+    const includePendingState = options.includePendingState !== false;
+
+    const matches = listRecentSessions(limit, cwd, safeEngine)
+      .filter((session) => !excludeSessionId || session.sessionId !== excludeSessionId);
+    if (preferredSessionId) {
+      const preferred = matches.find(session => session.sessionId === preferredSessionId);
+      if (preferred) return preferred;
+    }
+    if (matches.length > 0) return matches[0];
+
+    if (includePendingState) {
+      const pending = buildPendingStateSessions(safeEngine, cwd)
+        .filter((session) => !excludeSessionId || session.sessionId !== excludeSessionId);
+      if (preferredSessionId) {
+        const preferredPending = pending.find(session => session.sessionId === preferredSessionId);
+        if (preferredPending) return preferredPending;
+      }
+      if (pending.length > 0) return pending[0];
+    }
+
+    if (allowGlobalFallback) {
+      const global = listRecentSessions(limit, null, safeEngine)
+        .filter((session) => !excludeSessionId || session.sessionId !== excludeSessionId);
+      if (preferredSessionId) {
+        const preferredGlobal = global.find(session => session.sessionId === preferredSessionId);
+        if (preferredGlobal) return preferredGlobal;
+      }
+      if (global.length > 0) return global[0];
+    }
+
+    if (!includePendingState) return null;
+    if (!allowGlobalFallback) return null;
+    const globalPending = buildPendingStateSessions(safeEngine, null)
+      .filter((session) => !excludeSessionId || session.sessionId !== excludeSessionId);
+    return globalPending[0] || null;
+  }
+
   function loadSessionTags() {
     try {
       return JSON.parse(fs.readFileSync(path.join(HOME, '.metame', 'session_tags.json'), 'utf8'));
@@ -1063,33 +1279,33 @@ function createSessionStore(deps) {
   }
 
   function _isCodexSessionValid(sessionId, normCwd) {
-    let db = null;
-    try {
-      const { DatabaseSync } = require('node:sqlite');
-      db = new DatabaseSync(CODEX_DB, { readonly: true });
-      const row = db.prepare('SELECT cwd FROM threads WHERE id = ?').get(sessionId);
-      db.close();
-      db = null;
-      return !!row && path.resolve(row.cwd) === normCwd;
-    } catch (e) {
-      if (db) { try { db.close(); } catch { /* ignore */ } }
-      // Transient errors (DB locked, busy) should not invalidate a live session.
-      // Only treat "session truly not found" as invalid; infra failures are conservative.
-      const msg = (e && e.message) || '';
-      if (msg.includes('SQLITE_BUSY') || msg.includes('SQLITE_LOCKED')) return true;
-      return false;
+    const preferredDb = resolveCodexDbForCwd(normCwd);
+    for (const dbPath of getKnownCodexDbPaths(normCwd)) {
+      let db = null;
+      try {
+        if (!fs.existsSync(dbPath)) continue;
+        const { DatabaseSync } = require('node:sqlite');
+        db = new DatabaseSync(dbPath, { readonly: true });
+        const row = db.prepare('SELECT cwd FROM threads WHERE id = ?').get(sessionId);
+        db.close();
+        db = null;
+        if (!row) continue;
+        const rowCwd = path.resolve(String(row.cwd || ''));
+        if (rowCwd === normCwd) return true;
+        if (dbPath === preferredDb) return false;
+      } catch (e) {
+        if (db) { try { db.close(); } catch { /* ignore */ } }
+        const msg = (e && e.message) || '';
+        if (msg.includes('SQLITE_BUSY') || msg.includes('SQLITE_LOCKED')) return true;
+      }
     }
+    return false;
   }
 
-  function getCodexSessionSandboxProfile(sessionId) {
-    let db = null;
+  function getCodexSessionSandboxProfile(sessionId, cwd = '') {
     try {
       if (!sessionId) return null;
-      const { DatabaseSync } = require('node:sqlite');
-      db = new DatabaseSync(CODEX_DB, { readonly: true });
-      const row = db.prepare('SELECT sandbox_policy, approval_mode FROM threads WHERE id = ?').get(sessionId);
-      db.close();
-      db = null;
+      const row = queryCodexDbs(cwd, (db) => db.prepare('SELECT sandbox_policy, approval_mode FROM threads WHERE id = ?').get(sessionId));
       if (!row || !row.sandbox_policy) return null;
       const policy = JSON.parse(String(row.sandbox_policy));
       const sandboxMode = normalizeCodexSandboxMode(
@@ -1107,13 +1323,12 @@ function createSessionStore(deps) {
         permissionMode: sandboxMode || 'danger-full-access',
       };
     } catch {
-      if (db) { try { db.close(); } catch { /* ignore */ } }
       return null;
     }
   }
 
-  function getCodexSessionPermissionMode(sessionId) {
-    const profile = getCodexSessionSandboxProfile(sessionId);
+  function getCodexSessionPermissionMode(sessionId, cwd = '') {
+    const profile = getCodexSessionSandboxProfile(sessionId, cwd);
     return profile ? profile.permissionMode : null;
   }
 
@@ -1134,9 +1349,11 @@ function createSessionStore(deps) {
     findCodexSessionFile,
     clearSessionFileCache,
     truncateSessionToCheckpoint,
+    stripThinkingSignatures,
     watchSessionFiles,
     stopWatchingSessionFiles,
     listRecentSessions,
+    findAttachableSession,
     loadSessionTags,
     getSessionFileMtime,
     sessionLabel,
@@ -1161,6 +1378,7 @@ function createSessionStore(deps) {
       stripCodexInjectedHints,
       looksLikeInternalCodexPrompt,
       parseCodexSessionPreview,
+      buildPendingStateSessions,
     },
   };
 }

package/scripts/daemon-team-dispatch.js

@@ -15,6 +15,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { resolveReactivePaths } = require('./core/reactive-paths');
 
 const METAME_DIR = path.join(os.homedir(), '.metame');
 
@@ -165,12 +166,12 @@ function updateDispatchContextFiles({ fs: fsMod = fs, path: pathMod = path, base
   const logWarn = (msg) => {
     if (typeof logger === 'function') logger(msg);
   };
-  const nowDir = pathMod.join(baseDir, 'memory', 'now');
+  const rp = resolveReactivePaths(targetProject, baseDir);
   const sharedDir = pathMod.join(baseDir, 'memory', 'shared');
-  const targetNowPath = pathMod.join(nowDir, `${targetProject}.md`);
-  const sharedNowPath = pathMod.join(nowDir, 'shared.md');
+  const targetNowPath = rp.state;
+  const sharedNowPath = pathMod.join(baseDir, 'memory', 'now', 'shared.md');
   const tasksFilePath = pathMod.join(sharedDir, 'tasks.md');
-  fsMod.mkdirSync(nowDir, { recursive: true });
+  fsMod.mkdirSync(rp.dir, { recursive: true });
 
   const projects = (config && config.projects) || {};
   const actor = resolveDispatchActor((fullMsg && fullMsg.source_sender_key) || (fullMsg && fullMsg.from), projects);
@@ -192,6 +193,7 @@ function updateDispatchContextFiles({ fs: fsMod = fs, path: pathMod = path, base
 
   if (!isSharedTeamTask) return { targetNowPath, sharedNowPath: null, tasksFilePath: null };
 
+  fsMod.mkdirSync(pathMod.dirname(sharedNowPath), { recursive: true });
   fsMod.writeFileSync(sharedNowPath, buildSharedNowContent({
     actor, target, title, prompt, timeStr,
     dispatchId: fullMsg.id, taskId, scopeId, chain: fullMsg.chain,
@@ -252,14 +254,14 @@ function updateDispatchContextFiles({ fs: fsMod = fs, path: pathMod = path, base
 function buildEnrichedPrompt(target, rawPrompt, metameDir, opts = {}) {
   const base = metameDir || METAME_DIR;
   const includeShared = !!(opts && opts.includeShared);
+  const rp = resolveReactivePaths(target, base);
   let ctx = '';
 
-  // 1. Target private now file
+  // 1. Target state file (reactive/<target>/state.md)
   try {
-    const targetNowFile = path.join(base, 'memory', 'now', `${target}.md`);
-    if (fs.existsSync(targetNowFile)) {
-      const content = fs.readFileSync(targetNowFile, 'utf8').trim();
-      if (content) ctx += `[当前进度 now/${target}.md]\n${content}\n\n`;
+    if (fs.existsSync(rp.state)) {
+      const content = fs.readFileSync(rp.state, 'utf8').trim();
+      if (content) ctx += `[当前进度 ${target}/state.md]\n${content}\n\n`;
     }
   } catch { /* non-critical */ }
 
@@ -274,13 +276,12 @@ function buildEnrichedPrompt(target, rawPrompt, metameDir, opts = {}) {
     } catch { /* non-critical */ }
   }
 
-  // 3+5. Structured memory (L1+L2) OR legacy _latest.md fallback
+  // 3+5. Structured memory (L1+L2) OR legacy latest.md fallback
   //       Single stat — structured memory supersedes raw last output
   let hasStructuredMemory = false;
   try {
-    const memFile = path.join(base, 'memory', 'now', `${target}_memory.md`);
-    if (fs.existsSync(memFile)) {
-      const content = fs.readFileSync(memFile, 'utf8').trim();
+    if (fs.existsSync(rp.memory)) {
+      const content = fs.readFileSync(rp.memory, 'utf8').trim();
       if (content) {
         ctx += `[Memory Context]\n${content}\n\n`;
         hasStructuredMemory = true;
@@ -291,9 +292,8 @@ function buildEnrichedPrompt(target, rawPrompt, metameDir, opts = {}) {
   if (!hasStructuredMemory) {
     // Fallback: raw last output (for non-reactive projects without memory system)
     try {
-      const latestFile = path.join(base, 'memory', 'agents', `${target}_latest.md`);
-      if (fs.existsSync(latestFile)) {
-        const content = fs.readFileSync(latestFile, 'utf8').trim();
+      if (fs.existsSync(rp.latest)) {
+        const content = fs.readFileSync(rp.latest, 'utf8').trim();
         if (content) ctx += `[${target} 上次产出]\n${content}\n\n`;
       }
     } catch { /* non-critical */ }