stigmergy 1.3.20-beta.0 → 1.3.22-beta.0

package/config/builtin-skills.json

@@ -0,0 +1,43 @@
+{
+  "version": "1.0.0",
+  "description": "Stigmergy built-in skills configuration",
+  "skills": [
+    {
+      "name": "resumesession",
+      "displayName": "ResumeSession",
+      "description": "Cross-CLI session recovery and history management",
+      "version": "1.0.0",
+      "author": "stigmergy",
+      "type": "builtin",
+      "category": "session-management",
+      "entryPoint": "src/cli/commands/stigmergy-resume.js",
+      "agentskills": {
+        "name": "resumesession",
+        "description": "Cross-CLI session recovery and history management",
+        "version": "1.0.0",
+        "author": "stigmergy"
+      },
+      "deployment": {
+        "autoDeploy": true,
+        "targetCLIs": ["claude", "codex", "iflow", "qwen", "qodercli", "codebuddy"],
+        "files": [
+          {
+            "source": ".claude/skills/resumesession/SKILL.md",
+            "destination": "skills/resumesession/SKILL.md"
+          },
+          {
+            "source": ".claude/skills/resumesession/__init__.py",
+            "destination": "skills/resumesession/__init__.py"
+          }
+        ]
+      },
+      "commands": {
+        "stigmergy": {
+          "name": "resume",
+          "description": "Resume session - Cross-CLI session recovery and history management",
+          "handler": "src/cli/commands/stigmergy-resume.js"
+        }
+      }
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.3.20-beta.0",
+  "version": "1.3.22-beta.0",
   "description": "Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System",
   "main": "src/index.js",
   "bin": {

package/src/cli/commands/autoinstall.js

@@ -1,191 +1,65 @@
-/**
- * Auto-install Command
- * Modular implementation for automated CLI tool installation (npm postinstall)
- */
-
-const chalk = require('chalk');
-const { handleInstallCommand } = require('./install');
-const { handleDeployCommand } = require('./project');
-
-/**
- * Handle auto-install command - Automated installation for npm postinstall
- * @param {Object} options - Command options
- */
-async function handleAutoInstallCommand(options = {}) {
+import chalk from 'chalk';
+import { handleInstallCommand } from './install.js';
+import { handleDeployCommand } from './project.js';
+import BuiltinSkillsDeployer from '../../core/skills/BuiltinSkillsDeployer.js';
+
+export async function handleAutoInstallCommand(options) {
+  console.log(chalk.blue('🚀 Stigmergy Auto-Installation'));
+  console.log(chalk.gray('=====================================\n'));
+
+  // Step 1: Install CLI tools
+  console.log(chalk.blue('📦 Step 1/3: Installing CLI tools...'));
+  
   try {
-    // Detect npm environment for better output visibility
-    const isNpmPostinstall = process.env.npm_lifecycle_event === 'postinstall';
-
-    // Use stderr for critical messages in npm environment (more likely to be shown)
-    const criticalLog = isNpmPostinstall ? console.error : console.log;
-
-    criticalLog(chalk.cyan('🚀 STIGMERGY CLI AUTO-INSTALL STARTING'));
-    criticalLog('='.repeat(60));
-    criticalLog('Installing CLI tools and deploying hooks (including ResumeSession)...');
-    criticalLog('='.repeat(60));
-
-    console.log(chalk.blue('[AUTO-INSTALL] Stigmergy CLI automated setup'));
-    console.log('='.repeat(60));
-
-    // Check if we're in npm postinstall environment
-    if (isNpmPostinstall) {
-      console.log(chalk.yellow('📦 Detected npm postinstall environment'));
-      console.log(chalk.gray('Setting up CLI integrations and hooks automatically...'));
-    }
-
-    // Auto-install options - non-interactive mode
-    const autoInstallOptions = {
-      cli: 'all', // Install all available CLI tools
+    await handleInstallCommand({
       verbose: options.verbose || process.env.DEBUG === 'true',
-      force: options.force || false,
-      nonInteractive: true, // Critical for automated installation
-      autoDetect: true, // Auto-detect available tools
-      skipPermissionCheck: process.env.STIGMERGY_SKIP_PERMISSION_CHECK === 'true'
-    };
-
-    console.log(chalk.blue('🔍 Scanning for available CLI tools...'));
-
-    // Step 1: Install CLI tools
-    console.log(chalk.blue('🛠️  Step 1/2: Installing CLI tools...'));
-
-    const installResult = await handleInstallCommand(autoInstallOptions);
-
-    if (installResult.success) {
-      console.log(chalk.green('\n✅ CLI tools installed successfully!'));
-
-      if (isNpmPostinstall) {
-        criticalLog(chalk.green('✅ CLI TOOLS INSTALLED'));
-      }
-
-      // Show summary of what was installed
-      if (installResult.installed && installResult.installed.length > 0) {
-        console.log(chalk.blue('\n📋 Installation Summary:'));
-        installResult.installed.forEach(tool => {
-          console.log(`  ${chalk.green('✅')} ${tool}`);
-        });
-      }
-
-      if (installResult.failed && installResult.failed.length > 0) {
-        console.log(chalk.blue('\n❌ Failed Tools:'));
-        installResult.failed.forEach(tool => {
-          console.log(`  ${chalk.red('❌')} ${tool} (installation failed)`);
-        });
-      }
-
-      if (installResult.existing && installResult.existing.length > 0) {
-        console.log(chalk.blue('\n🔧 Already Available:'));
-        installResult.existing.forEach(tool => {
-          console.log(`  ${chalk.yellow('⚠️')} ${tool} (already installed)`);
-        });
-      }
+      force: options.force || false
+    });
+  } catch (error) {
+    console.error(chalk.red('✗ CLI tools installation failed:'), error.message);
+    // Continue with next step even if CLI tools installation fails
+  }
 
-      // Step 2: Deploy hooks and ResumeSession
-      console.log(chalk.blue('\n🚀 Step 2/2: Deploying hooks and ResumeSession integration...'));
-      
-      try {
-        const deployResult = await handleDeployCommand({
-          verbose: options.verbose || process.env.DEBUG === 'true',
-          force: options.force || false
-        });
+  // Step 2: Deploy hooks and ResumeSession
+  console.log(chalk.blue('\n🚀 Step 2/3: Deploying hooks and ResumeSession integration...'));
 
-        if (deployResult.success) {
-          console.log(chalk.green('\n✅ Hooks and ResumeSession deployed successfully!'));
-          
-          if (isNpmPostinstall) {
-            criticalLog(chalk.green('✅ HOOKS AND RESUMESESSION DEPLOYED'));
-            criticalLog(chalk.green('✅ /stigmergy-resume command is now available in all CLIs'));
-          }
-        } else {
-          console.log(chalk.yellow('\n⚠️  Hook deployment encountered issues'));
-          console.log(chalk.yellow('Run: stigmergy deploy --verbose for details'));
-        }
-      } catch (deployError) {
-        console.log(chalk.red(`\n❌ Hook deployment failed: ${deployError.message}`));
-        console.log(chalk.yellow('Run: stigmergy deploy manually to complete setup'));
-      }
+  try {
+    const deployResult = await handleDeployCommand({
+      verbose: options.verbose || process.env.DEBUG === 'true',
+      force: options.force || false
+    });
 
+    if (deployResult.success) {
+      console.log(chalk.green('✓ Hooks deployed successfully'));
     } else {
-      console.log(chalk.red('\n❌ Auto-install encountered issues'));
-
-      if (isNpmPostinstall) {
-        criticalLog(chalk.red('❌ STIGMERGY CLI SETUP INCOMPLETE'));
-        criticalLog(chalk.yellow('Run: stigmergy install && stigmergy deploy to complete setup manually'));
-      }
-
-      if (installResult.error) {
-        console.log(chalk.red(`Error: ${installResult.error}`));
-      }
+      console.warn(chalk.yellow('⚠ Hooks deployment completed with warnings'));
     }
+  } catch (error) {
+    console.error(chalk.red('✗ Hooks deployment failed:'), error.message);
+    // Continue with next step even if hooks deployment fails
+  }
 
-    // Setup verification
-    console.log(chalk.blue('\n🔍 Verifying installation...'));
-
-    // Quick verification of core functionality
-    const verificationChecks = [
-      { name: 'Core modules accessible', check: () => require('../utils/formatters') && require('../utils/environment') },
-      { name: 'Error handler available', check: () => require('../../core/error_handler') },
-      { name: 'Smart router available', check: () => require('../../core/smart_router') },
-      { name: 'Hook deployment manager', check: () => require('../../core/coordination/nodejs/HookDeploymentManager') },
-      { name: 'ResumeSession generator', check: () => require('../../core/coordination/nodejs/generators/ResumeSessionGenerator') }
-    ];
-
-    let verificationPassed = 0;
-    for (const check of verificationChecks) {
-      try {
-        check.check();
-        console.log(`  ${chalk.green('✅')} ${check.name}`);
-        verificationPassed++;
-      } catch (error) {
-        console.log(`  ${chalk.red('❌')} ${check.name}`);
-      }
-    }
+  // Step 3: Deploy built-in skills
+  console.log(chalk.blue('\n🚀 Step 3/3: Deploying built-in skills...'));
 
-    if (verificationPassed === verificationChecks.length) {
-      console.log(chalk.green('\n✅ All verification checks passed!'));
+  try {
+    const skillsDeployer = new BuiltinSkillsDeployer();
+    const skillsResult = await skillsDeployer.deployAll();
 
-      if (isNpmPostinstall) {
-        criticalLog(chalk.green('🎉 STIGMERGY CLI IS READY TO USE!'));
-        criticalLog(chalk.green('🎯 All CLI tools configured with ResumeSession support'));
-      }
+    if (skillsResult.success) {
+      console.log(chalk.green('✓ Built-in skills deployed successfully'));
     } else {
-      console.log(chalk.yellow('\n⚠️  Some verification checks failed'));
-      console.log(chalk.yellow('Run: stigmergy diagnostic for full system check'));
-    }
-
-    // Final summary for npm environment
-    if (isNpmPostinstall) {
-      criticalLog('='.repeat(60));
-      criticalLog(chalk.cyan('🎯 STIGMERGY CLI AUTO-INSTALL FINISHED'));
-      criticalLog('='.repeat(60));
-      criticalLog(chalk.green('✅ All CLI tools installed and configured'));
-      criticalLog(chalk.green('✅ Hooks deployed for all CLIs'));
-      criticalLog(chalk.green('✅ ResumeSession integration enabled'));
-      criticalLog(chalk.cyan('📝 Usage: /stigmergy-resume in any CLI'));
-      criticalLog('='.repeat(60));
+      console.warn(chalk.yellow('⚠ Built-in skills deployment completed with warnings'));
     }
-
-    return {
-      success: installResult.success,
-      verificationPassed,
-      installed: installResult.installed || [],
-      existing: installResult.existing || []
-    };
-
   } catch (error) {
-    const isNpmPostinstall = process.env.npm_lifecycle_event === 'postinstall';
-    const criticalLog = isNpmPostinstall ? console.error : console.log;
-
-    console.error(chalk.red('[ERROR] Auto-install failed:'), error.message);
-
-    if (isNpmPostinstall) {
-      criticalLog(chalk.red('💥 AUTO-INSTALL FAILED'));
-      criticalLog(chalk.yellow('Run: stigmergy install --verbose && stigmergy deploy --verbose'));
-    }
-
-    return { success: false, error: error.message };
+    console.error(chalk.red('✗ Built-in skills deployment failed:'), error.message);
+    // Continue even if skills deployment fails
   }
-}
 
-module.exports = {
-  handleAutoInstallCommand
-};
+  console.log(chalk.green('\n🎉 Auto-installation completed successfully!'));
+  console.log(chalk.cyan('\nNext steps:'));
+  console.log('  • Run: stigmergy --help');
+  console.log('  • Try: stigmergy claude "Hello World"');
+  console.log('  • Check: stigmergy status');
+  console.log('  • Resume sessions: stigmergy resume --limit 10');
+}

package/src/cli/commands/stigmergy-resume.js

@@ -0,0 +1,708 @@
+#!/usr/bin/env node
+/**
+ * ResumeSession Command
+ * Cross-CLI session recovery and history management
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class ResumeSessionCommand {
+  constructor() {
+    this.projectPath = process.cwd();
+  }
+
+  // Get all CLI session paths (with dynamic detection)
+  getAllCLISessionPaths() {
+    const homeDir = os.homedir();
+    const paths = {};
+
+    // Detect Claude CLI session paths
+    paths.claude = this.detectCLISessionPaths([
+      path.join(homeDir, '.claude', 'projects'),
+      path.join(homeDir, '.claude', 'sessions'),
+      path.join(homeDir, '.claude', 'history')
+    ]);
+
+    // Detect Gemini CLI session paths
+    paths.gemini = this.detectCLISessionPaths([
+      path.join(homeDir, '.config', 'gemini', 'tmp'),
+      path.join(homeDir, '.gemini', 'sessions'),
+      path.join(homeDir, '.gemini', 'history')
+    ]);
+
+    // Detect Qwen CLI session paths
+    paths.qwen = this.detectCLISessionPaths([
+      path.join(homeDir, '.qwen', 'projects'),
+      path.join(homeDir, '.qwen', 'sessions'),
+      path.join(homeDir, '.qwen', 'history')
+    ]);
+
+    // Detect IFlow CLI session paths
+    paths.iflow = this.detectCLISessionPaths([
+      path.join(homeDir, '.iflow', 'projects'),
+      path.join(homeDir, '.iflow', 'sessions'),
+      path.join(homeDir, '.iflow', 'history')
+    ]);
+
+    // Detect QoderCLI session paths
+    paths.qodercli = this.detectCLISessionPaths([
+      path.join(homeDir, '.qoder', 'projects'),
+      path.join(homeDir, '.qoder', 'sessions')
+    ]);
+
+    // Detect CodeBuddy session paths
+    paths.codebuddy = this.detectCLISessionPaths([
+      path.join(homeDir, '.codebuddy'),
+      path.join(homeDir, '.codebuddy', 'sessions'),
+      path.join(homeDir, '.codebuddy', 'history')
+    ]);
+
+    // Detect Codex session paths
+    paths.codex = this.detectCLISessionPaths([
+      path.join(homeDir, '.config', 'codex'),
+      path.join(homeDir, '.codex', 'sessions'),
+      path.join(homeDir, '.codex', 'history')
+    ]);
+
+    // Detect Kode session paths
+    paths.kode = this.detectCLISessionPaths([
+      path.join(homeDir, '.kode', 'projects'),
+      path.join(homeDir, '.kode', 'sessions')
+    ]);
+
+    return paths;
+  }
+
+  // Detect which session paths actually exist and contain session files
+  detectCLISessionPaths(candidatePaths) {
+    const validPaths = [];
+
+    for (const candidatePath of candidatePaths) {
+      if (!fs.existsSync(candidatePath)) {
+        continue;
+      }
+
+      // Check if this directory contains session files
+      const hasSessionFiles = this.hasSessionFiles(candidatePath);
+      if (hasSessionFiles) {
+        validPaths.push(candidatePath);
+      }
+    }
+
+    return validPaths.length > 0 ? validPaths : candidatePaths.filter(p => fs.existsSync(p));
+  }
+
+  // Check if a directory contains session files
+  hasSessionFiles(dirPath) {
+    try {
+      const files = fs.readdirSync(dirPath);
+      return files.some(file =>
+        file.endsWith('.jsonl') ||
+        file.endsWith('.json') ||
+        file.endsWith('.session')
+      );
+    } catch (error) {
+      return false;
+    }
+  }
+
+  // Scan sessions for a specific CLI
+  scanSessions(cliType, sessionsPath, projectPath) {
+    const sessions = [];
+    if (!sessionsPath || !projectPath) return sessions;
+
+    try {
+      if (!fs.existsSync(sessionsPath)) return sessions;
+
+      // For IFlow, Claude, QoderCLI, Kode: scan projects subdirectories (one level)
+      if ((cliType === 'iflow' || cliType === 'claude' || cliType === 'qodercli' || cliType === 'kode') && sessionsPath.includes('projects')) {
+        const subdirs = fs.readdirSync(sessionsPath);
+        for (const subdir of subdirs) {
+          const subdirPath = path.join(sessionsPath, subdir);
+          try {
+            const stat = fs.statSync(subdirPath);
+            if (stat.isDirectory()) {
+              sessions.push(...this.scanSessionFiles(cliType, subdirPath, projectPath));
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+        return sessions;
+      }
+
+      // For Gemini: scan tmp/<hash>/chats subdirectories (multiple levels)
+      if (cliType === 'gemini' && sessionsPath.includes('tmp')) {
+        const hashDirs = fs.readdirSync(sessionsPath);
+        for (const hashDir of hashDirs) {
+          const hashDirPath = path.join(sessionsPath, hashDir);
+          try {
+            const stat = fs.statSync(hashDirPath);
+            if (stat.isDirectory()) {
+              const chatsPath = path.join(hashDirPath, 'chats');
+              if (fs.existsSync(chatsPath)) {
+                sessions.push(...this.scanSessionFiles(cliType, chatsPath, projectPath));
+              }
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+        return sessions;
+      }
+
+      // For Qwen: scan projects/<projectName>/chats subdirectories (two levels)
+      if (cliType === 'qwen' && sessionsPath.includes('projects')) {
+        const projectDirs = fs.readdirSync(sessionsPath);
+        for (const projectDir of projectDirs) {
+          const projectDirPath = path.join(sessionsPath, projectDir);
+          try {
+            const stat = fs.statSync(projectDirPath);
+            if (stat.isDirectory()) {
+              const chatsPath = path.join(projectDirPath, 'chats');
+              if (fs.existsSync(chatsPath)) {
+                sessions.push(...this.scanSessionFiles(cliType, chatsPath, projectPath));
+              }
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+        return sessions;
+      }
+
+      // For CodeBuddy: scan both projects subdirectories and root history.jsonl
+      if (cliType === 'codebuddy') {
+        const projectsPath = path.join(sessionsPath, 'projects');
+        if (fs.existsSync(projectsPath)) {
+          const projectDirs = fs.readdirSync(projectsPath);
+          for (const projectDir of projectDirs) {
+            const projectDirPath = path.join(projectsPath, projectDir);
+            try {
+              const stat = fs.statSync(projectDirPath);
+              if (stat.isDirectory()) {
+                sessions.push(...this.scanSessionFiles(cliType, projectDirPath, projectPath));
+              }
+            } catch (error) {
+              continue;
+            }
+          }
+        }
+        sessions.push(...this.scanSessionFiles(cliType, sessionsPath, projectPath));
+        return sessions;
+      }
+
+      return this.scanSessionFiles(cliType, sessionsPath, projectPath);
+    } catch (error) {
+      console.warn(`Warning: Could not scan ${cliType} sessions:`, error.message);
+    }
+
+    return sessions;
+  }
+
+  // Scan session files in a directory
+  scanSessionFiles(cliType, sessionsPath, projectPath) {
+    const sessions = [];
+    try {
+      const files = fs.readdirSync(sessionsPath);
+      for (const file of files) {
+        if (file.endsWith('.json') || file.endsWith('.session') || file.endsWith('.jsonl')) {
+          try {
+            const filePath = path.join(sessionsPath, file);
+            let sessionData;
+
+            if (file.endsWith('.jsonl')) {
+              const content = fs.readFileSync(filePath, 'utf8');
+              const lines = content.trim().split('\n').filter(line => line.trim());
+              const messages = lines.map(line => JSON.parse(line));
+
+              if (messages.length === 0) continue;
+              sessionData = this.parseJSONLSession(messages, file);
+            } else {
+              const content = fs.readFileSync(filePath, 'utf8');
+              sessionData = JSON.parse(content);
+            }
+
+            if (this.isProjectSession(sessionData, projectPath)) {
+              sessions.push({
+                cliType,
+                sessionId: sessionData.id || sessionData.sessionId || file.replace(/\.(json|session|jsonl)$/, ''),
+                title: sessionData.title || sessionData.topic || 'Untitled',
+                content: this.extractContent(sessionData),
+                updatedAt: new Date(sessionData.updatedAt || sessionData.timestamp || fs.statSync(filePath).mtime),
+                messageCount: sessionData.messageCount || this.countMessages(sessionData),
+                projectPath
+              });
+            }
+          } catch (error) {
+            console.warn(`Warning: Could not parse ${file}:`, error.message);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('Warning: Could not scan files:', error.message);
+    }
+
+    return sessions;
+  }
+
+  // Parse JSONL session format
+  parseJSONLSession(messages, filename) {
+    const firstMsg = messages[0];
+    const lastMsg = messages[messages.length - 1];
+    const userMessages = messages.filter(m => m.type === 'user' || m.role === 'user');
+
+    let title = 'Untitled Session';
+    if (userMessages.length > 0) {
+      const firstUserMsg = userMessages[0];
+      let content = firstUserMsg.message?.content || firstUserMsg.content || '';
+      if (typeof content === 'object') {
+        content = JSON.stringify(content);
+      }
+      if (typeof content === 'string' && content.trim()) {
+        title = content.substring(0, 100) || title;
+      }
+    }
+
+    const contentParts = messages
+      .map(m => {
+        if (m.message && typeof m.message === 'object') {
+          return m.message.content || m.message.text || '';
+        }
+        return m.content || m.text || '';
+      })
+      .filter(text => text && typeof text === 'string' && text.trim());
+
+    return {
+      sessionId: firstMsg.sessionId || filename.replace('.jsonl', ''),
+      title: title,
+      content: contentParts.join(' '),
+      timestamp: lastMsg.timestamp || new Date().toISOString(),
+      projectPath: firstMsg.cwd || firstMsg.workingDirectory,
+      messageCount: messages.filter(m => m.type === 'user' || m.type === 'assistant' || m.role === 'user' || m.role === 'assistant').length,
+      messages: messages
+    };
+  }
+
+  // Scan all CLI sessions
+  scanAllCLISessions(projectPath) {
+    const allSessions = [];
+    const cliPathsMap = this.getAllCLISessionPaths();
+
+    for (const [cliType, sessionsPaths] of Object.entries(cliPathsMap)) {
+      for (const sessionsPath of sessionsPaths) {
+        const sessions = this.scanSessions(cliType, sessionsPath, projectPath);
+        allSessions.push(...sessions);
+      }
+    }
+
+    return allSessions;
+  }
+
+  // Check if session belongs to current project
+  isProjectSession(session, projectPath) {
+    const sessionProject = session.projectPath || session.workingDirectory || session.cwd;
+    if (!sessionProject) return true;
+
+    return sessionProject === projectPath ||
+           sessionProject.startsWith(projectPath) ||
+           projectPath.startsWith(sessionProject);
+  }
+
+  // Extract content from session data
+  extractContent(sessionData) {
+    if (sessionData.content && typeof sessionData.content === 'string') {
+      return sessionData.content;
+    }
+
+    if (sessionData.messages && Array.isArray(sessionData.messages)) {
+      return sessionData.messages
+        .map(msg => {
+          if (msg.message && typeof msg.message === 'object') {
+            const content = msg.message.content || msg.message.text || '';
+            return this.extractTextFromContent(content);
+          }
+          const content = msg.content || msg.text || '';
+          return this.extractTextFromContent(content);
+        })
+        .filter(text => text && typeof text === 'string' && text.trim())
+        .join(' ');
+    }
+
+    if (Array.isArray(sessionData)) {
+      return sessionData
+        .map(item => {
+          if (item.message && typeof item.message === 'object') {
+            const content = item.message.content || item.message.text || '';
+            return this.extractTextFromContent(content);
+          }
+          const content = item.content || item.text || '';
+          return this.extractTextFromContent(content);
+        })
+        .filter(text => text && typeof text === 'string' && text.trim())
+        .join(' ');
+    }
+
+    return '';
+  }
+
+  // Extract text from content
+  extractTextFromContent(content) {
+    if (typeof content === 'string') {
+      return content;
+    }
+
+    if (Array.isArray(content)) {
+      return content
+        .map(item => {
+          if (typeof item === 'string') return item;
+          if (item && typeof item === 'object') {
+            return item.text || item.content || '';
+          }
+          return '';
+        })
+        .filter(text => text && typeof text === 'string')
+        .join(' ');
+    }
+
+    if (content && typeof content === 'object') {
+      return content.text || content.content || JSON.stringify(content);
+    }
+
+    return '';
+  }
+
+  // Count messages in session
+  countMessages(sessionData) {
+    if (sessionData.messages) {
+      return Array.isArray(sessionData.messages) ? sessionData.messages.length : 0;
+    }
+
+    if (Array.isArray(sessionData)) {
+      return sessionData.length;
+    }
+
+    return 0;
+  }
+
+  // Filter sessions by CLI
+  filterByCLI(sessions, cliType) {
+    if (!cliType) return sessions;
+    return sessions.filter(session => session.cliType === cliType);
+  }
+
+  // Filter sessions by search term
+  filterBySearch(sessions, searchTerm) {
+    if (!searchTerm) return sessions;
+
+    const lowerSearch = searchTerm.toLowerCase();
+    return sessions.filter(session =>
+      session.title.toLowerCase().includes(lowerSearch) ||
+      session.content.toLowerCase().includes(lowerSearch)
+    );
+  }
+
+  // Filter sessions by date range
+  filterByDateRange(sessions, timeRange = 'all') {
+    if (timeRange === 'all') return sessions;
+
+    const now = new Date();
+    return sessions.filter(session => {
+      const sessionDate = new Date(session.updatedAt);
+
+      switch (timeRange) {
+        case 'today':
+          return sessionDate.toDateString() === now.toDateString();
+        case 'week':
+          const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+          return sessionDate >= weekAgo;
+        case 'month':
+          const monthAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+          return sessionDate >= monthAgo;
+        default:
+          return true;
+      }
+    });
+  }
+
+  // Sort sessions by date
+  sortByDate(sessions) {
+    return [...sessions].sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+  }
+
+  // Apply all filters
+  applyFilters(sessions, options, projectPath) {
+    let filteredSessions = [...sessions];
+
+    filteredSessions = filteredSessions.filter(session => this.isProjectSession(session, projectPath));
+
+    if (options.cli) {
+      filteredSessions = this.filterByCLI(filteredSessions, options.cli);
+    }
+
+    if (options.search) {
+      filteredSessions = this.filterBySearch(filteredSessions, options.search);
+    }
+
+    if (options.timeRange) {
+      filteredSessions = this.filterByDateRange(filteredSessions, options.timeRange);
+    }
+
+    filteredSessions = this.sortByDate(filteredSessions);
+
+    if (options.limit && options.limit > 0) {
+      filteredSessions = filteredSessions.slice(0, options.limit);
+    }
+
+    return filteredSessions;
+  }
+
+  // Format sessions as summary
+  formatSummary(sessions) {
+    if (sessions.length === 0) {
+      return `📭 当前项目暂无历史会话\n\n💡 **提示:** 尝试: stigmergy resume --search <关键词>`;
+    }
+
+    let response = `📁 **项目历史会话**\n\n📊 共找到 ${sessions.length} 个会话\n\n`;
+
+    const byCLI = {};
+    sessions.forEach(session => {
+      if (!byCLI[session.cliType]) byCLI[session.cliType] = [];
+      byCLI[session.cliType].push(session);
+    });
+
+    Object.entries(byCLI).forEach(([cli, cliSessions]) => {
+      const icon = this.getCLIIcon(cli);
+      response += `${icon} **${cli.toUpperCase()}** (${cliSessions.length}个)\n`;
+
+      cliSessions.slice(0, 3).forEach((session, i) => {
+        const date = this.formatDate(session.updatedAt);
+        const title = session.title.substring(0, 50);
+        response += `   ${i + 1}. ${title}...\n`;
+        response += `      📅 ${date} • 💬 ${session.messageCount}条消息\n`;
+      });
+
+      if (cliSessions.length > 3) {
+        response += `   ... 还有 ${cliSessions.length - 3} 个会话\n`;
+      }
+      response += '\n';
+    });
+
+    response += `💡 **使用方法:**\n`;
+    response += `• 'stigmergy resume --cli <工具>' - 查看特定CLI\n`;
+    response += `• 'stigmergy resume --search <关键词>' - 搜索内容\n`;
+    response += `• 'stigmergy resume --format timeline' - 时间线视图`;
+
+    return response;
+  }
+
+  // Format sessions as timeline
+  formatTimeline(sessions) {
+    if (sessions.length === 0) {
+      return '📭 暂无会话时间线。';
+    }
+
+    let response = `⏰ **时间线视图**\n\n`;
+
+    sessions.forEach((session, index) => {
+      const date = this.formatDate(session.updatedAt);
+      const cliIcon = this.getCLIIcon(session.cliType);
+
+      response += `${index + 1}. ${cliIcon} ${session.title}\n`;
+      response += `   📅 ${date} • 💬 ${session.messageCount}条消息\n`;
+      response += `   🔑 ${session.cliType}:${session.sessionId}\n\n`;
+    });
+
+    return response;
+  }
+
+  // Format sessions as detailed
+  formatDetailed(sessions) {
+    if (sessions.length === 0) {
+      return '📭 暂无详细会话信息。';
+    }
+
+    let response = `📋 **详细视图**\n\n`;
+
+    sessions.forEach((session, index) => {
+      const cliIcon = this.getCLIIcon(session.cliType);
+      const date = session.updatedAt.toLocaleString();
+
+      response += `${index + 1}. ${cliIcon} **${session.title}**\n`;
+      response += `   📅 ${date}\n`;
+      response += `   🔧 CLI: ${session.cliType}\n`;
+      response += `   💬 消息数: ${session.messageCount}\n`;
+      response += `   🆔 会话ID: '${session.sessionId}'\n\n`;
+    });
+
+    return response;
+  }
+
+  // Format session context
+  formatContext(session) {
+    if (!session) {
+      return `📭 暂无可恢复的上下文。`;
+    }
+
+    let response = `🔄 **上下文恢复**\n\n`;
+    response += `📅 会话时间: ${session.updatedAt.toLocaleString()}\n`;
+    response += `🔧 来源CLI: ${session.cliType}\n`;
+    response += `💬 消息数: ${session.messageCount}\n`;
+    response += `🆔 会话ID: ${session.sessionId}\n\n`;
+    response += `---\n\n`;
+    response += `**上次讨论内容:**\n`;
+    response += session.content.substring(0, 500);
+    if (session.content.length > 500) {
+      response += `...`;
+    }
+
+    return response;
+  }
+
+  // Get CLI icon
+  getCLIIcon(cliType) {
+    const icons = {
+      'claude': '🟢',
+      'gemini': '🔵',
+      'qwen': '🟡',
+      'iflow': '🔴',
+      'codebuddy': '🟣',
+      'codex': '🟪',
+      'qodercli': '🟠',
+      'kode': '⚡'
+    };
+    return icons[cliType] || '🔹';
+  }
+
+  // Format date
+  formatDate(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const days = Math.floor(diff / (24 * 60 * 60 * 1000));
+
+    if (days === 0) {
+      return date.toLocaleTimeString();
+    } else if (days === 1) {
+      return '昨天';
+    } else if (days < 7) {
+      return `${days}天前`;
+    } else if (days < 30) {
+      return `${Math.floor(days / 7)}周前`;
+    } else {
+      return `${Math.floor(days / 30)}个月前`;
+    }
+  }
+
+  // Parse command options
+  parseOptions(args) {
+    const options = {
+      limit: 10,
+      format: 'summary',
+      timeRange: 'all',
+      cli: null,
+      search: null
+    };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+
+      if (arg === '--cli' && i + 1 < args.length) {
+        options.cli = args[++i];
+      } else if (arg === '--search' && i + 1 < args.length) {
+        options.search = args[++i];
+      } else if (arg === '--limit' && i + 1 < args.length) {
+        options.limit = parseInt(args[++i]);
+      } else if (arg === '--format' && i + 1 < args.length) {
+        const format = args[++i]?.toLowerCase();
+        if (['summary', 'timeline', 'detailed', 'context'].includes(format)) {
+          options.format = format;
+        }
+      } else if (arg === '--today') {
+        options.timeRange = 'today';
+      } else if (arg === '--week') {
+        options.timeRange = 'week';
+      } else if (arg === '--month') {
+        options.timeRange = 'month';
+      } else if (!arg.startsWith('--') && !options.search) {
+        options.search = arg;
+      }
+    }
+
+    return options;
+  }
+
+  // Execute resume command
+  execute(args) {
+    try {
+      const options = this.parseOptions(args);
+      const allSessions = this.scanAllCLISessions(this.projectPath);
+      const filteredSessions = this.applyFilters(allSessions, options, this.projectPath);
+
+      let response;
+      switch (options.format) {
+        case 'timeline':
+          response = this.formatTimeline(filteredSessions);
+          break;
+        case 'detailed':
+          response = this.formatDetailed(filteredSessions);
+          break;
+        case 'context':
+          response = this.formatContext(filteredSessions[0] || null);
+          break;
+        case 'summary':
+        default:
+          response = this.formatSummary(filteredSessions);
+          break;
+      }
+
+      console.log(response);
+      return 0;
+    } catch (error) {
+      console.error(`❌ 历史查询失败: ${error.message}`);
+      return 1;
+    }
+  }
+}
+
+// Export for use as module
+module.exports = ResumeSessionCommand;
+
+// Export handler function for router
+module.exports.handleResumeCommand = async function(args, options) {
+  const command = new ResumeSessionCommand();
+  return command.execute(args);
+};
+
+// Export help function
+module.exports.printResumeHelp = function() {
+  console.log(`
+ResumeSession - Cross-CLI session recovery and history management
+
+Usage: stigmergy resume [options]
+
+Options:
+  --cli <name>        Filter by CLI tool (claude, gemini, qwen, etc.)
+  --search <term>     Search sessions by content
+  --limit <num>       Maximum sessions to show (default: 10)
+  --format <type>     Output format: summary, timeline, detailed, context
+  --today             Show today's sessions only
+  --week              Show sessions from last 7 days
+  --month             Show sessions from last 30 days
+
+Examples:
+  stigmergy resume
+  stigmergy resume --cli claude
+  stigmergy resume --search react
+  stigmergy resume --format timeline
+  stigmergy resume --today
+`);
+};
+
+// Run as CLI command
+if (require.main === module) {
+  const command = new ResumeSessionCommand();
+  const args = process.argv.slice(2);
+  process.exit(command.execute(args));
+}

package/src/cli/router-beta.js

@@ -35,7 +35,7 @@ const { handleDiagnosticCommand, handleCleanCommand } = require('./commands/syst
 const { handleSkillMainCommand, printSkillsHelp } = require('./commands/skills');
 const { handleErrorsCommand } = require('./commands/errors');
 const { handleAutoInstallCommand } = require('./commands/autoinstall');
-const { handleResumeCommand, printResumeHelp } = require('./commands/resume');
+const { handleResumeCommand, printResumeHelp } = require('./commands/stigmergy-resume');
 const { getCLIPath } = require('../core/cli_tools');
 const {
   handleUpgradeCommand,
@@ -330,7 +330,7 @@ async function main() {
   // Resume session command
   program
     .command('resume')
-    .description('Resume session (forwards to @stigmergy/resume CLI tool)')
+    .description('Resume session - Cross-CLI session recovery and history management')
     .argument('[args...]', 'Arguments to pass to resumesession')
     .option('-v, --verbose', 'Verbose output')
     .action(async (args, options) => {

package/src/core/cli_tools.js

@@ -80,11 +80,11 @@ const CLI_TOOLS = {
   },
   resumesession: {
     name: 'ResumeSession CLI',
-    version: 'resumesession --version',
-    install: 'npm install -g @stigmergy/resume',
+    version: 'stigmergy resume --version',
+    install: 'Built-in with stigmergy CLI',
     hooksDir: path.join(os.homedir(), '.resumesession', 'hooks'),
     config: path.join(os.homedir(), '.resumesession', 'config.json'),
-    autoInstall: false, // 内部功能，不单独安装
+    autoInstall: false, // 内置功能，无需单独安装
   },
   opencode: {
     name: 'OpenCode AI CLI',

package/src/core/skills/BuiltinSkillsDeployer.js

@@ -0,0 +1,154 @@
+/**
+ * BuiltinSkillsDeployer - Deploy built-in skills to CLI tools
+ * Automatically deploys stigmergy built-in skills during installation
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+class BuiltinSkillsDeployer {
+  constructor() {
+    this.configPath = path.join(process.cwd(), 'config', 'builtin-skills.json');
+    this.skillsBaseDir = process.cwd();
+  }
+
+  /**
+   * Load built-in skills configuration
+   */
+  loadConfig() {
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        console.warn('[BUILTIN_SKILLS] No built-in skills configuration found');
+        return null;
+      }
+
+      const content = fs.readFileSync(this.configPath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.error('[BUILTIN_SKILLS] Failed to load configuration:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Deploy built-in skills to all CLI tools
+   */
+  async deployAll() {
+    const config = this.loadConfig();
+    if (!config) {
+      return { success: false, message: 'No built-in skills configuration found' };
+    }
+
+    console.log(`[BUILTIN_SKILLS] Found ${config.skills.length} built-in skill(s)`);
+
+    const results = [];
+    for (const skill of config.skills) {
+      if (skill.deployment && skill.deployment.autoDeploy) {
+        const result = await this.deploySkill(skill);
+        results.push(result);
+      }
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    console.log(`[BUILTIN_SKILLS] Deployed ${successCount}/${results.length} skill(s)`);
+
+    return { success: true, results };
+  }
+
+  /**
+   * Deploy a single built-in skill to target CLIs
+   */
+  async deploySkill(skill) {
+    const targetCLIs = skill.deployment.targetCLIs || [];
+    const results = [];
+
+    for (const cliName of targetCLIs) {
+      const result = await this.deployToCLI(skill, cliName);
+      results.push(result);
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    return {
+      success: successCount === results.length,
+      skillName: skill.name,
+      targetCLIs: targetCLIs,
+      deployedCount: successCount,
+      results
+    };
+  }
+
+  /**
+   * Deploy skill to a specific CLI
+   */
+  async deployToCLI(skill, cliName) {
+    try {
+      const cliHomeDir = path.join(os.homedir(), `.${cliName}`);
+      const cliSkillsDir = path.join(cliHomeDir, 'skills', skill.name);
+
+      // Create skills directory
+      if (!fs.existsSync(cliSkillsDir)) {
+        fs.mkdirSync(cliSkillsDir, { recursive: true });
+      }
+
+      // Copy skill files
+      const files = skill.deployment.files || [];
+      for (const file of files) {
+        const sourcePath = path.join(this.skillsBaseDir, file.source);
+        const destPath = path.join(cliSkillsDir, path.basename(file.destination));
+
+        if (fs.existsSync(sourcePath)) {
+          const content = fs.readFileSync(sourcePath, 'utf8');
+          fs.writeFileSync(destPath, content);
+          console.log(`[BUILTIN_SKILLS] Deployed ${file.source} to ${cliName}`);
+        } else {
+          console.warn(`[BUILTIN_SKILLS] Source file not found: ${sourcePath}`);
+        }
+      }
+
+      return { success: true, cliName, skillName: skill.name };
+    } catch (error) {
+      console.error(`[BUILTIN_SKILLS] Failed to deploy ${skill.name} to ${cliName}:`, error.message);
+      return { success: false, cliName, skillName: skill.name, error: error.message };
+    }
+  }
+
+  /**
+   * Check if a skill is deployed to a CLI
+   */
+  isDeployed(skillName, cliName) {
+    const cliSkillsDir = path.join(os.homedir(), `.${cliName}`, 'skills', skillName);
+    return fs.existsSync(cliSkillsDir);
+  }
+
+  /**
+   * Get deployment status for all built-in skills
+   */
+  getDeploymentStatus() {
+    const config = this.loadConfig();
+    if (!config) {
+      return null;
+    }
+
+    const status = [];
+    for (const skill of config.skills) {
+      const skillStatus = {
+        name: skill.name,
+        displayName: skill.displayName,
+        version: skill.version,
+        deployment: {}
+      };
+
+      const targetCLIs = skill.deployment.targetCLIs || [];
+      for (const cliName of targetCLIs) {
+        skillStatus.deployment[cliName] = this.isDeployed(skill.name, cliName);
+      }
+
+      status.push(skillStatus);
+    }
+
+    return status;
+  }
+}
+
+export default BuiltinSkillsDeployer;

package/src/cli/commands/resume.js

@@ -1,134 +0,0 @@
-/**
- * Resume Session Commands
- * Modular implementation for resume command
- */
-
-const chalk = require('chalk');
-const { spawnSync } = require('child_process');
-const { getCLIPath } = require('../../core/cli_tools');
-
-/**
- * Handle resume session command - Forward to @stigmergy/resume CLI tool
- * @param {Array} args - Arguments to pass to resumesession
- * @param {Object} options - Command options
- */
-async function handleResumeCommand(args = [], options = {}) {
-  try {
-    console.log(chalk.blue('[RESUME] Checking for ResumeSession CLI tool...'));
-
-    // Check if resumesession command is available
-    const resumesessionPath = await getCLIPath('resumesession');
-
-    if (resumesessionPath) {
-      console.log(chalk.green(`[RESUME] Found ResumeSession at: ${resumesessionPath}`));
-
-      // Forward all arguments to the resumesession CLI tool
-      const resumeArgs = args; // Pass all arguments through
-      console.log(chalk.blue(`[RESUME] Forwarding to resumesession: ${resumeArgs.join(' ') || '(no args)'}`));
-
-      // Execute resumesession with the provided arguments
-      const result = spawnSync(resumesessionPath, resumeArgs, {
-        stdio: 'inherit',
-        shell: true,
-        cwd: process.cwd(),
-        env: { ...process.env, FORCE_COLOR: '1' } // Ensure colors are preserved
-      });
-
-      if (result.status !== 0) {
-        console.log(chalk.yellow(`[WARN] ResumeSession exited with code ${result.status}`));
-        return { success: false, exitCode: result.status, forwarded: true };
-      }
-
-      return { success: true, exitCode: result.status, forwarded: true };
-
-    } else {
-      // ResumeSession CLI tool not found
-      console.log(chalk.red('[ERROR] ResumeSession CLI tool not found'));
-      console.log(chalk.yellow('[INFO] ResumeSession is an optional component for session recovery'));
-
-      console.log(chalk.blue('\n📦 To install ResumeSession:'));
-      console.log('  npm install -g resumesession');
-      console.log('');
-      console.log(chalk.blue('🔧 ResumeSession provides:'));
-      console.log('  • Cross-CLI session history');
-      console.log('  • Memory sharing between CLI tools');
-      console.log('  • Session recovery and continuation');
-      console.log('  • Centralized configuration management');
-      console.log('');
-      console.log(chalk.blue('📋 Usage examples:'));
-      console.log('  stigmergy resume list                    # Show session history');
-      console.log('  stigmergy resume continue <session-id>    # Continue a session');
-      console.log('  stigmergy resume export                   # Export session data');
-      console.log('  stigmergy resume --help                   # Show all options');
-
-      return { success: false, error: 'ResumeSession CLI tool not found', forwarded: false };
-    }
-
-  } catch (error) {
-    console.error(chalk.red('[ERROR] Resume command failed:'), error.message);
-
-    if (options.verbose) {
-      console.error(chalk.red('Stack trace:'), error.stack);
-    }
-
-    return { success: false, error: error.message, forwarded: false };
-  }
-}
-
-/**
- * Handle resumesession command alias
- * @param {Array} args - Arguments
- * @param {Object} options - Options
- */
-async function handleResumeSessionCommand(args = [], options = {}) {
-  return await handleResumeCommand(args, options);
-}
-
-/**
- * Handle sg-resume command alias
- * @param {Array} args - Arguments
- * @param {Object} options - Options
- */
-async function handleSgResumeCommand(args = [], options = {}) {
-  return await handleResumeCommand(args, options);
-}
-
-/**
- * Print resume help information
- */
-function printResumeHelp() {
-  console.log(chalk.cyan(`
-🔄 Stigmergy Resume Session System
-
-📋 ResumeSession forwards to the resumesession CLI tool for session management.
-
-🛠️  Available Commands:
-  stigmergy resume [args]              Forward to resumesession CLI
-
-📦 Requirements:
-  resumesession CLI tool must be installed separately.
-
-💾 Installation:
-  npm install -g resumesession
-
-🔍 Common Usage:
-  stigmergy resume list                # Show available sessions
-  stigmergy resume continue <id>       # Continue a specific session
-  stigmergy resume export              # Export session data
-  stigmergy resume clean               # Clean old sessions
-
-📚 More Information:
-  ResumeSession provides cross-CLI memory sharing and session recovery
-  capabilities, allowing you to maintain context across different AI CLI tools.
-
-  If ResumeSession is not installed, you can still use all other Stigmergy
-  CLI features normally.
-  `));
-}
-
-module.exports = {
-  handleResumeCommand,
-  handleResumeSessionCommand,
-  handleSgResumeCommand,
-  printResumeHelp
-};