metame-cli 1.5.23 → 1.5.24

package/scripts/daemon-session-commands.js

@@ -1,7 +1,11 @@
 'use strict';
 
 const { normalizeEngineName: _normalizeEngine } = require('./daemon-utils');
-const { rawChatId: _rawChatId } = require('./core/thread-chat-id');
+const {
+  resolveSessionRoute: _resolveSessionRoute,
+  resolveResumeRouteForTarget: _resolveResumeRouteForTarget,
+  applyResumeRouteState: _applyResumeRouteState,
+} = require('./core/team-session-route');
 
 function createSessionCommandHandler(deps) {
   const {
@@ -49,45 +53,16 @@ function createSessionCommandHandler(deps) {
     return available.length === 1 ? normalizeEngineName(available[0]) : getDefaultEngine();
   }
 
-  function buildBoundSessionChatId(projectKey) {
-    const key = String(projectKey || '').trim();
-    return key ? `_bound_${key}` : '';
-  }
-
   function getSessionRoute(chatId) {
-    const cfg = loadConfig();
-    const state = loadState();
-    const chatKey = String(chatId);
-    const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
-    const boundKey = agentMap[chatKey] || agentMap[_rawChatId(chatKey)] || null;
-    const boundProj = boundKey && cfg.projects ? cfg.projects[boundKey] : null;
-    const stickyKey = state && state.team_sticky ? (state.team_sticky[chatKey] || state.team_sticky[_rawChatId(chatKey)]) : null;
-    const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
-      ? boundProj.team.find((m) => m && m.key === stickyKey)
-      : null;
-
-    if (stickyMember) {
-      return {
-        sessionChatId: `_agent_${stickyMember.key}`,
-        cwd: stickyMember.cwd ? normalizeCwd(stickyMember.cwd) : (boundProj && boundProj.cwd ? normalizeCwd(boundProj.cwd) : null),
-        engine: normalizeEngineName(stickyMember.engine || (boundProj && boundProj.engine)),
-      };
-    }
-
-    if (boundProj) {
-      return {
-        sessionChatId: buildBoundSessionChatId(boundKey),
-        cwd: boundProj.cwd ? normalizeCwd(boundProj.cwd) : null,
-        engine: normalizeEngineName(boundProj.engine),
-      };
-    }
-
-    const rawSession = getSession(chatId);
-    return {
-      sessionChatId: String(chatId),
-      cwd: rawSession && rawSession.cwd ? normalizeCwd(rawSession.cwd) : null,
-      engine: inferStoredEngine(rawSession),
-    };
+    return _resolveSessionRoute({
+      chatId,
+      cfg: loadConfig(),
+      state: loadState(),
+      getSession,
+      normalizeCwd,
+      normalizeEngineName,
+      inferStoredEngine,
+    });
   }
 
   function getCurrentEngine(chatId) {
@@ -101,8 +76,8 @@ function createSessionCommandHandler(deps) {
   }
 
   // Write per-engine session slot, preserving cwd and other engine slots.
-  function attachEngineSession(state, chatId, engine, sessionId, cwd, meta = {}) {
-    const effectiveId = getSessionRoute(chatId).sessionChatId;
+  function attachEngineSession(state, chatId, engine, sessionId, cwd, meta = {}, options = {}) {
+    const effectiveId = options.sessionChatId || getSessionRoute(chatId).sessionChatId;
     const existing = state.sessions[effectiveId] || {};
     const existingEngines = existing.engines || {};
     const nextSlot = {
@@ -134,6 +109,17 @@ function createSessionCommandHandler(deps) {
     return null;
   }
 
+  function resolveResumeRouteForTarget(chatId, targetCwd, state, cfg) {
+    return _resolveResumeRouteForTarget({
+      chatId,
+      targetCwd,
+      cfg,
+      state,
+      normalizeCwd,
+      fallbackSessionChatId: getSessionRoute(chatId).sessionChatId,
+    });
+  }
+
   function resolveAttachableSession(engine, cwd, options = {}) {
     if (typeof findAttachableSession === 'function') {
       return findAttachableSession({ engine, cwd, ...options });
@@ -147,6 +133,9 @@ function createSessionCommandHandler(deps) {
 
   function attachResolvedTarget(state, chatId, engine, target, fallbackCwd) {
     const targetCwd = target && target.projectPath ? target.projectPath : fallbackCwd;
+    const cfg = loadConfig();
+    const resumeRoute = resolveResumeRouteForTarget(chatId, targetCwd, state, cfg);
+    _applyResumeRouteState(state, chatId, resumeRoute);
     if (target && target.pendingState) {
       attachEngineSession(state, chatId, engine, null, targetCwd, {
         started: false,
@@ -155,7 +144,7 @@ function createSessionCommandHandler(deps) {
         ...(target.sandboxMode ? { sandboxMode: target.sandboxMode } : {}),
         ...(target.approvalPolicy ? { approvalPolicy: target.approvalPolicy } : {}),
         ...(target.permissionMode ? { permissionMode: target.permissionMode } : {}),
-      });
+      }, { sessionChatId: resumeRoute.sessionChatId });
       return {
         cwd: targetCwd,
         pendingState: true,
@@ -166,7 +155,7 @@ function createSessionCommandHandler(deps) {
       started: true,
       runtimeSessionObserved: true,
       clearCompactContext: true,
-    });
+    }, { sessionChatId: resumeRoute.sessionChatId });
     return {
       cwd: targetCwd,
       pendingState: false,
@@ -437,6 +426,7 @@ function createSessionCommandHandler(deps) {
       const title = target.customTitle || target.summary || target.sessionId.slice(0, 8);
       const lines = [`▶️ Resumed: ${title}`];
       if (attached.cwd) lines.push(`📁 ${path.basename(attached.cwd)}`);
+      lines.push(`ID: ${target.sessionId}`);
       if (Array.isArray(recentDialogue) && recentDialogue.length > 0) {
         lines.push('');
         lines.push('最近对话:');

package/scripts/daemon-session-store.js

@@ -960,6 +960,7 @@ function createSessionStore(deps) {
     const proj = s.projectPath ? path.basename(s.projectPath) : '~';
     const ago = getSessionRelativeTimeLabel(s);
     const shortId = s.sessionId.slice(0, 8);
+    const visibleId = s.sessionId.slice(0, 18);
     const tags = (sessionTags[s.sessionId] && sessionTags[s.sessionId].tags || []).slice(0, 3);
     const engineLabel = (s.engine || 'claude') === 'codex' ? 'codex' : 'claude';
 
@@ -972,6 +973,7 @@ function createSessionStore(deps) {
     if (firstSnippet) line += `\n   📝 ${firstSnippet}`;
     if (lastUserSnippet && lastUserSnippet !== firstSnippet) line += `\n   💬 ${lastUserSnippet}`;
     if (lastAiSnippet) line += `\n   🤖 ${lastAiSnippet}`;
+    line += `\n   ID ${visibleId}`;
     line += `\n   /resume ${shortId}`;
     return line;
   }
@@ -984,11 +986,12 @@ function createSessionStore(deps) {
       const title = sessionDisplayTitle(s, 60, sessionTags);
       const proj = s.projectPath ? path.basename(s.projectPath) : '~';
       const ago = getSessionRelativeTimeLabel(s);
-      const shortId = s.sessionId.slice(0, 6);
+      const visibleId = s.sessionId.slice(0, 18);
       const tags = (sessionTags[s.sessionId] && sessionTags[s.sessionId].tags || []).slice(0, 4);
       const engineLabel = (s.engine || 'claude') === 'codex' ? 'codex' : 'claude';
 
       let desc = `**${i + 1}. ${title}**\n📁${proj} · ${ago} · ${engineLabel}`;
+      desc += `\nID: ${visibleId}`;
       if (tags.length) desc += `\n${tags.map(t => `\`${t}\``).join(' ')}`;
       // Show first prompt, last user message, and last assistant reply
       const firstSnippet = _cleanSnippet(s.firstPrompt, 50);
@@ -998,7 +1001,7 @@ function createSessionStore(deps) {
       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}` } }] });
+      elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: `▶️ Resume ${visibleId}` }, type: 'primary', value: { cmd: `/resume ${s.sessionId}` } }] });
     });
     return elements;
   }

package/scripts/daemon-warm-pool.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { execSync } = require('child_process');
+
 /**
  * daemon-warm-pool.js
  *
@@ -20,11 +22,15 @@
  */
 
 function createWarmPool(deps) {
-  const { log } = deps;
+  const {
+    log,
+    idleTimeoutMs = 5 * 60 * 1000,
+    hasBackgroundDescendants = defaultHasBackgroundDescendants,
+  } = deps;
 
   // Pool: sessionKey -> { child, sessionId, cwd, idleTimer }
   const pool = new Map();
-  const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+  const IDLE_TIMEOUT_MS = idleTimeoutMs;
 
   /**
    * Acquire a warm process for the given session key.
@@ -67,17 +73,6 @@ function createWarmPool(deps) {
       return;
     }
 
-    // Set idle timeout
-    const idleTimer = setTimeout(() => {
-      const e = pool.get(sessionKey);
-      if (e && e.child === child) {
-        log('INFO', `[WarmPool] Idle timeout, killing warm process pid=${child.pid} for ${sessionKey}`);
-        _killEntry(e);
-        pool.delete(sessionKey);
-      }
-    }, IDLE_TIMEOUT_MS);
-    if (typeof idleTimer.unref === 'function') idleTimer.unref();
-
     // Auto-cleanup on unexpected death
     const onExit = () => {
       const e = pool.get(sessionKey);
@@ -94,8 +89,9 @@ function createWarmPool(deps) {
       child,
       sessionId: meta.sessionId || '',
       cwd: meta.cwd || '',
-      idleTimer,
+      idleTimer: null,
     });
+    _armIdleTimer(sessionKey, child);
     log('INFO', `[WarmPool] Stored warm process pid=${child.pid} for ${sessionKey} (pool size: ${pool.size})`);
   }
 
@@ -137,6 +133,34 @@ function createWarmPool(deps) {
     pool.delete(sessionKey);
   }
 
+  function _armIdleTimer(sessionKey, child) {
+    const entry = pool.get(sessionKey);
+    if (!entry || entry.child !== child) return;
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
+    entry.idleTimer = setTimeout(() => {
+      const current = pool.get(sessionKey);
+      if (!current || current.child !== child) return;
+      if (_hasLiveBackgroundDescendants(child.pid)) {
+        log('INFO', `[WarmPool] Idle timeout skipped for ${sessionKey}: pid=${child.pid} still has background descendants`);
+        _armIdleTimer(sessionKey, child);
+        return;
+      }
+      log('INFO', `[WarmPool] Idle timeout, killing warm process pid=${child.pid} for ${sessionKey}`);
+      _killEntry(current);
+      pool.delete(sessionKey);
+    }, IDLE_TIMEOUT_MS);
+    if (typeof entry.idleTimer.unref === 'function') entry.idleTimer.unref();
+  }
+
+  function _hasLiveBackgroundDescendants(pid) {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    try {
+      return !!hasBackgroundDescendants(pid);
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Build the stream-json user message for stdin.
    */
@@ -159,4 +183,31 @@ function createWarmPool(deps) {
   };
 }
 
+function defaultHasBackgroundDescendants(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+
+  if (process.platform === 'win32') {
+    try {
+      const output = execSync(
+        `powershell -NoProfile -Command "(Get-CimInstance Win32_Process -Filter \\"ParentProcessId=${pid}\\").Count"`,
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, windowsHide: true }
+      ).trim();
+      return Number(output) > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  try {
+    const output = execSync(`pgrep -P ${pid}`, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 3000,
+    }).trim();
+    return output.length > 0;
+  } catch {
+    return false;
+  }
+}
+
 module.exports = { createWarmPool };

package/scripts/ops-mission-queue.js

@@ -17,6 +17,7 @@ const MISSIONS_FILE = 'workspace/missions.md';
 const SECTIONS = ['pending', 'active', 'completed', 'abandoned'];
 const RECENT_LOG_LINES = 500;
 const ERROR_THRESHOLD = 3;
+const BOOTSTRAP_MISSION_ID = 'bootstrap-001';
 
 function getMetameDir() {
   return process.env.METAME_DIR || path.join(os.homedir(), '.metame');
@@ -211,6 +212,20 @@ function completeMission(cwd, id) {
   return { success: true, topic: { id: mission.id, title: mission.title, status: 'completed' } };
 }
 
+function completeBootstrapMission(cwd) {
+  const sections = readSections(cwd);
+  const found = findMission(sections, BOOTSTRAP_MISSION_ID);
+  if (!found || found.section !== 'active') {
+    return { success: false, completed: false, reason: found ? `bootstrap_${found.section}` : 'bootstrap_missing' };
+  }
+
+  const mission = sections.active.splice(found.index, 1)[0];
+  mission.status = 'completed';
+  sections.completed.push(mission);
+  writeSections(cwd, sections);
+  return { success: true, completed: true, topic: { id: mission.id, title: mission.title, status: 'completed' } };
+}
+
 function listMissions(cwd) {
   const sections = readSections(cwd);
   const topics = [];
@@ -320,4 +335,12 @@ if (require.main === module) {
   process.stdout.write(JSON.stringify(result) + '\n');
 }
 
-module.exports = { nextMission, activateMission, completeMission, listMissions, pruneObsoleteMissions, scanLogs };
+module.exports = {
+  nextMission,
+  activateMission,
+  completeMission,
+  completeBootstrapMission,
+  listMissions,
+  pruneObsoleteMissions,
+  scanLogs,
+};

package/scripts/ops-reactive-bootstrap.js

@@ -6,7 +6,7 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 
 const yaml = require('./resolve-yaml');
-const { pruneObsoleteMissions, scanLogs } = require('./ops-mission-queue');
+const { pruneObsoleteMissions, scanLogs, completeBootstrapMission } = require('./ops-mission-queue');
 const { bootstrapReactiveProject } = require('./daemon-reactive-lifecycle');
 
 const HOME = os.homedir();
@@ -52,6 +52,40 @@ function dispatchReactiveItem(item) {
   return { success: true };
 }
 
+function buildScanSummary(pruned, scanned, bootstrapCompleted, bootstrap) {
+  const findings = [];
+
+  if ((pruned?.pruned || 0) > 0) {
+    findings.push(`pruned ${pruned.pruned} obsolete mission${pruned.pruned === 1 ? '' : 's'}`);
+  }
+  if ((scanned?.new_missions || 0) > 0) {
+    findings.push(`detected ${scanned.new_missions} new repair mission${scanned.new_missions === 1 ? '' : 's'}`);
+  }
+  if (bootstrapCompleted?.completed) {
+    findings.push('completed legacy bootstrap-001');
+  }
+  if (bootstrap?.started) {
+    const missionLabel = [bootstrap.missionId, bootstrap.mission].filter(Boolean).join(' ');
+    findings.push(`started repair ${missionLabel}`.trim());
+  }
+
+  const quiet = findings.length === 0;
+  const action = bootstrap?.started
+    ? 'repair_started'
+    : quiet
+      ? 'quiet_scan'
+      : 'findings_only';
+
+  return {
+    quiet,
+    action,
+    findings,
+    summary: quiet
+      ? 'ops-scan completed: no new recurring issues, no repair started'
+      : `ops-scan completed: ${findings.join('; ')}`,
+  };
+}
+
 function main() {
   const config = loadConfig();
   const project = config?.projects?.[PROJECT_KEY];
@@ -63,7 +97,7 @@ function main() {
   const cwd = project.cwd.replace(/^~/, HOME);
   const pruned = pruneObsoleteMissions(cwd);
   const scanned = scanLogs(cwd);
-
+  const bootstrapCompleted = completeBootstrapMission(cwd);
   const result = bootstrapReactiveProject(PROJECT_KEY, config, {
     metameDir: METAME_DIR,
     loadState,
@@ -73,14 +107,24 @@ function main() {
     log: () => {},
     notifyUser: () => {},
   });
+  const summary = buildScanSummary(pruned, scanned, bootstrapCompleted, result);
 
   process.stdout.write(JSON.stringify({
     success: true,
     pruned: pruned.pruned || 0,
     new_missions: scanned.new_missions || 0,
     total_pending: scanned.total_pending || 0,
+    bootstrap_completed: !!bootstrapCompleted.completed,
+    quiet: summary.quiet,
+    action: summary.action,
+    findings: summary.findings,
+    summary: summary.summary,
     bootstrap: result,
   }) + '\n');
 }
 
 if (require.main === module) main();
+
+module.exports = {
+  buildScanSummary,
+};