agentlytics 0.2.11 → 0.2.13

package/editors/gsd.js

@@ -0,0 +1,366 @@
+const path = require('path');
+const fs = require('fs');
+
+const name = 'gsd';
+const labels = { gsd: 'GSD Workflow' };
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function readFileSafe(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); } catch { return null; }
+}
+
+function statSafe(filePath) {
+  try { return fs.statSync(filePath); } catch { return null; }
+}
+
+function countFiles(dir) {
+  try { return fs.readdirSync(dir).filter(f => !f.startsWith('.')).length; } catch { return 0; }
+}
+
+/**
+ * Parse YAML frontmatter from STATE.md.
+ * Returns { status, milestone, stoppedAt, progress } or null.
+ */
+function parseStateMd(content) {
+  if (!content) return null;
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const yaml = m[1];
+  function get(key) {
+    const r = yaml.match(new RegExp(`^${key}:\\s*(.+)`, 'm'));
+    return r ? r[1].trim().replace(/^["']|["']$/g, '') : null;
+  }
+  function getInt(key) { const v = get(key); return v ? parseInt(v) : null; }
+  const progressBlock = yaml.match(/^progress:\s*\n((?:[ \t]+.+\n?)*)/m);
+  let progress = null;
+  if (progressBlock) {
+    const pb = progressBlock[1];
+    function pgGet(key) {
+      const r = pb.match(new RegExp(`${key}:\\s*(\\d+)`));
+      return r ? parseInt(r[1]) : null;
+    }
+    progress = {
+      total_phases: pgGet('total_phases'),
+      completed_phases: pgGet('completed_phases'),
+      total_plans: pgGet('total_plans'),
+      completed_plans: pgGet('completed_plans'),
+    };
+  }
+  return {
+    status: get('status'),
+    milestone: get('milestone'),
+    stoppedAt: get('stopped_at'),
+    lastUpdated: get('last_updated'),
+    progress,
+  };
+}
+
+/**
+ * Parse ROADMAP.md phase checkboxes into a map of phase_number → completed.
+ * Phase lines look like: - [x] **Phase 1: Name** or - [ ] Phase 2: Name
+ */
+function parseRoadmapPhaseStatus(content) {
+  if (!content) return new Map();
+  const statusMap = new Map(); // phase_number (int) → 'completed' | 'planned'
+  for (const line of content.split('\n')) {
+    const cbMatch = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (!cbMatch) continue;
+    const text = cbMatch[2];
+    if (/\d+-\d+-PLAN\.md/i.test(text) || /PLAN\.md\s*[—–-]/i.test(text)) continue;
+    // Extract phase number from patterns: "Phase 1:", "Phase 01:", "**Phase 2:**"
+    const numMatch = text.match(/phase\s+(\d+)/i);
+    if (!numMatch) continue;
+    const num = parseInt(numMatch[1]);
+    if (!isNaN(num)) {
+      statusMap.set(num, cbMatch[1].toLowerCase() === 'x' ? 'completed' : 'planned');
+    }
+  }
+  return statusMap;
+}
+
+/**
+ * Parse PROJECT.md — first # heading = project name, rest = description.
+ */
+function parseProjectMd(content) {
+  if (!content) return { name: null, description: null };
+  const lines = content.split('\n');
+  let projectName = null;
+  const descLines = [];
+  for (const line of lines) {
+    const h1 = line.match(/^#\s+(.+)/);
+    if (h1 && !projectName) {
+      projectName = h1[1].trim();
+      continue;
+    }
+    if (projectName && line.trim()) descLines.push(line.trim());
+  }
+  return {
+    name: projectName,
+    description: descLines.slice(0, 3).join(' ').substring(0, 300) || null,
+  };
+}
+
+/**
+ * Parse ROADMAP.md for phase completion.
+ * Supports: - [ ] **Phase N: Name** ...  and  - [x] **Phase N: Name** ...
+ * Also supports emoji: ✅ completed, 🚧 in-progress, □ planned
+ */
+function parseRoadmapMd(content) {
+  if (!content) return [];
+  const phases = [];
+  for (const line of content.split('\n')) {
+    // Checkbox style: - [ ] or - [x]
+    // Only count lines that look like phase entries, NOT plan file listings (e.g. "01-01-PLAN.md")
+    const cbMatch = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (cbMatch) {
+      const text = cbMatch[2];
+      // Skip plan file entries like "01-01-PLAN.md — description"
+      if (/\d+-\d+-PLAN\.md/i.test(text) || /PLAN\.md\s*[—–-]/i.test(text)) continue;
+      phases.push({ text: text.replace(/\*\*/g, '').trim(), completed: cbMatch[1].toLowerCase() === 'x' });
+      continue;
+    }
+    // Emoji style: ✅ completed, 🚧 in-progress (milestone-level)
+    const emojiMatch = line.match(/^[-*]\s+(✅|🚧|⬜|□)\s+(.+)/);
+    if (emojiMatch) {
+      phases.push({ text: emojiMatch[2].replace(/\*\*/g, '').trim(), completed: emojiMatch[1] === '✅' });
+    }
+  }
+  return phases;
+}
+
+/**
+ * Detect the currently active milestone name from ROADMAP.md.
+ * Looks for 🚧 milestone entries or the first uncompleted milestone block.
+ */
+function detectActiveMilestone(content) {
+  if (!content) return null;
+  for (const line of content.split('\n')) {
+    const m = line.match(/🚧\s+\*?\*?([^*\n-]+)/);
+    if (m) return m[1].trim().split(' - ')[0].trim();
+    // Also handle "in progress" text
+    if (/in.progress/i.test(line)) {
+      const nm = line.match(/\*?\*?([vV][\d.]+[^*]*)\*?\*?/);
+      if (nm) return nm[1].trim();
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract phase number prefix from a phase directory name.
+ * e.g. "01-auth-ve-giris" → "01"
+ * e.g. "999.1-backlog-item" → "999.1"
+ */
+function extractPhasePrefix(dirName) {
+  const m = dirName.match(/^(\d+(?:\.\d+)?)-/);
+  return m ? m[1] : null;
+}
+
+/**
+ * Parse checkbox tasks from a PLAN.md file.
+ */
+function parseCheckboxes(content) {
+  if (!content) return { total: 0, completed: 0, tasks: [] };
+  const tasks = [];
+  for (const line of content.split('\n')) {
+    const m = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (!m) continue;
+    tasks.push({ name: m[2].trim(), completed: m[1].toLowerCase() === 'x' });
+  }
+  return { total: tasks.length, completed: tasks.filter(t => t.completed).length, tasks };
+}
+
+// ============================================================
+// Public API
+// ============================================================
+
+/**
+ * Scan known project folders for GSD .planning/ directories.
+ * Returns project-level summary for each GSD project found.
+ */
+function getGSDProjects(knownFolders) {
+  const results = [];
+
+  for (const folder of knownFolders) {
+    if (!folder) continue;
+    const planningDir = path.join(folder, '.planning');
+    if (!fs.existsSync(planningDir)) continue;
+
+    // Must have at least PROJECT.md or ROADMAP.md to be a GSD project
+    const hasProject = fs.existsSync(path.join(planningDir, 'PROJECT.md'));
+    const hasRoadmap = fs.existsSync(path.join(planningDir, 'ROADMAP.md'));
+    if (!hasProject && !hasRoadmap) continue;
+
+    const projectContent = readFileSafe(path.join(planningDir, 'PROJECT.md'));
+    const roadmapContent = readFileSafe(path.join(planningDir, 'ROADMAP.md'));
+    const stateContent = readFileSafe(path.join(planningDir, 'STATE.md'));
+    const stateData = parseStateMd(stateContent);
+
+    const { name: projectName, description } = parseProjectMd(projectContent);
+
+    // Use filesystem as source of truth for phase counts
+    // Filter out malformed directory names (e.g. dirs with JSON content in name)
+    const phases = getGSDPhases(folder, roadmapContent);
+    const validPhases = phases.filter(ph => ph.number !== null);
+
+    const totalPhases = validPhases.length;
+    const completedPhases = validPhases.filter(p => p.status === 'completed').length;
+    const firstIncomplete = validPhases.find(p => p.status !== 'completed');
+    const activePhase = stateData?.stoppedAt || (firstIncomplete ? firstIncomplete.name : null);
+
+    // Prefer STATE.md milestone, fallback to ROADMAP detection
+    const activeMilestone = stateData?.milestone || detectActiveMilestone(roadmapContent);
+
+    // Count todos/seeds/quick (common GSD directories)
+    const todos = countFiles(path.join(planningDir, 'todos'))
+      + countFiles(path.join(planningDir, 'seeds'));
+    const notes = countFiles(path.join(planningDir, 'quick'));
+    const backlog = countFiles(path.join(planningDir, 'backlog'));
+
+    const planStat = statSafe(planningDir);
+    const lastModified = planStat ? Math.round(planStat.mtimeMs) : null;
+
+    results.push({
+      folder,
+      name: projectName || path.basename(folder),
+      description,
+      milestone: activeMilestone,
+      totalPhases,
+      completedPhases,
+      activePhase,
+      todos,
+      backlog,
+      notes,
+      lastModified,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Return phase details for a single GSD project.
+ * Phases live in .planning/phases/<phaseDir>/
+ * roadmapContent is optionally passed to cross-reference checkbox status.
+ */
+function getGSDPhases(folder, roadmapContent) {
+  if (roadmapContent === undefined) {
+    roadmapContent = readFileSafe(path.join(folder, '.planning', 'ROADMAP.md'));
+  }
+  const roadmapStatus = parseRoadmapPhaseStatus(roadmapContent);
+  const phasesDir = path.join(folder, '.planning', 'phases');
+  let phaseDirs;
+  try {
+    phaseDirs = fs.readdirSync(phasesDir)
+      .filter(f => {
+        try { return fs.statSync(path.join(phasesDir, f)).isDirectory(); } catch { return false; }
+      })
+      .sort((a, b) => {
+        // Sort by numeric prefix (supports decimals like 999.1)
+        const na = parseFloat(extractPhasePrefix(a) || '9999');
+        const nb = parseFloat(extractPhasePrefix(b) || '9999');
+        return na - nb;
+      });
+  } catch { return []; }
+
+  const phases = [];
+  for (const phaseDir of phaseDirs) {
+    const phaseFullDir = path.join(phasesDir, phaseDir);
+    const prefix = extractPhasePrefix(phaseDir);
+
+    // Phase name: everything after the leading number prefix
+    const nameRaw = phaseDir.replace(/^\d+(?:\.\d+)?-/, '').replace(/-/g, ' ');
+    const phaseName = nameRaw.length > 0 ? nameRaw : phaseDir;
+
+    // Phase number (numeric value for display)
+    const phaseNumber = prefix ? parseFloat(prefix) : null;
+
+    // Detect artifact files using the phase prefix pattern
+    let hasPlan = false, hasResearch = false, hasVerification = false;
+    let planCount = 0, summaryCount = 0;
+    let latestMtime = 0;
+
+    try {
+      const files = fs.readdirSync(phaseFullDir);
+      for (const f of files) {
+        const fPath = path.join(phaseFullDir, f);
+        const st = statSafe(fPath);
+        if (st && st.mtimeMs > latestMtime) latestMtime = st.mtimeMs;
+
+        // PLAN files: {prefix}-{n}-PLAN.md
+        if (f.match(/PLAN\.md$/i)) { hasPlan = true; planCount++; }
+        // SUMMARY files: indicates a plan was executed
+        if (f.match(/SUMMARY\.md$/i)) summaryCount++;
+        // VERIFICATION
+        if (f.match(/VERIFICATION\.md$/i)) hasVerification = true;
+        // RESEARCH
+        if (f.match(/RESEARCH\.md$/i)) hasResearch = true;
+      }
+    } catch { /* skip */ }
+
+    // Determine status: file-based first, then cross-reference ROADMAP.md checkboxes
+    let status = 'planned';
+    if (hasVerification) {
+      status = 'completed';
+    } else if (roadmapStatus.get(phaseNumber) === 'completed') {
+      // ROADMAP.md marks this phase [x] even without VERIFICATION.md
+      status = 'completed';
+    } else if (summaryCount > 0) {
+      status = 'executing';
+    } else if (hasPlan) {
+      status = 'planned';
+    }
+
+    phases.push({
+      phaseDir,
+      number: phaseNumber,
+      name: phaseName,
+      status,
+      tasks: { total: planCount, completed: summaryCount },
+      hasVerification,
+      hasPlan,
+      hasResearch,
+      lastModified: latestMtime || null,
+    });
+  }
+
+  return phases;
+}
+
+/**
+ * Return combined PLAN.md content for a phase.
+ * Aggregates all *-PLAN.md files in order.
+ */
+function getGSDPlanDetail(folder, phaseDir) {
+  const phaseFullDir = path.join(folder, '.planning', 'phases', phaseDir);
+  if (!fs.existsSync(phaseFullDir)) return null;
+
+  let files;
+  try { files = fs.readdirSync(phaseFullDir).filter(f => f.match(/PLAN\.md$/i)).sort(); }
+  catch { return null; }
+  if (files.length === 0) return null;
+
+  const sections = [];
+  const allTasks = [];
+
+  for (const f of files) {
+    const content = readFileSafe(path.join(phaseFullDir, f));
+    if (!content) continue;
+    sections.push(`## ${f}\n\n${content}`);
+    const { tasks } = parseCheckboxes(content);
+    allTasks.push(...tasks);
+  }
+
+  return { content: sections.join('\n\n---\n\n'), tasks: allTasks };
+}
+
+module.exports = {
+  name,
+  labels,
+  getGSDProjects,
+  getGSDPhases,
+  getGSDPlanDetail,
+};

package/editors/index.js

@@ -1,5 +1,5 @@
 const cursor = require('./cursor');
-const windsurf = require('./windsurf');
+const devin = require('./windsurf');
 const antigravity = require('./antigravity');
 const claude = require('./claude');
 const vscode = require('./vscode');
@@ -12,8 +12,9 @@ const cursorAgent = require('./cursor-agent');
 const commandcode = require('./commandcode');
 const goose = require('./goose');
 const kiro = require('./kiro');
+const codebuff = require('./codebuff');
 
-const editors = [cursor, windsurf, antigravity, claude, vscode, zed, opencode, codex, gemini, copilot, cursorAgent, commandcode, goose, kiro];
+const editors = [cursor, devin, antigravity, claude, vscode, zed, opencode, codex, gemini, copilot, cursorAgent, commandcode, goose, kiro, codebuff];
 
 // Build a unified source → display-label map from all editor modules
 const editorLabels = {};
@@ -47,9 +48,13 @@ function getAllChats() {
  */
 function getMessages(chat) {
   const editor = editors.find((e) => e.name === chat.source);
-  // Match variants: windsurf-next, antigravity, claude-code, vscode-insiders etc.
+  // Match variants: devin-next, antigravity, claude-code, vscode-insiders, plus legacy aliases.
   const resolvedEditor = editor || editors.find((e) =>
-    chat.source && (chat.source.startsWith(e.name) || (e.sources && e.sources.includes(chat.source)))
+    chat.source && (
+      chat.source.startsWith(e.name) ||
+      (e.sources && e.sources.includes(chat.source)) ||
+      (e.legacySources && e.legacySources.includes(chat.source))
+    )
   );
   if (!resolvedEditor) return [];
   return resolvedEditor.getMessages(chat);
@@ -72,7 +77,7 @@ async function getAllUsage() {
     try {
       const usage = await editor.getUsage();
       if (!usage) continue;
-      // Windsurf returns an array (one per variant), Cursor returns a single object
+      // Devin returns an array (one per variant), Cursor returns a single object
       if (Array.isArray(usage)) results.push(...usage);
       else results.push(usage);
     } catch { /* skip broken adapters */ }

package/editors/windsurf.js

@@ -3,10 +3,24 @@ const path = require('path');
 const os = require('os');
 const fs = require('fs');
 
-// Windsurf variants: Windsurf, Windsurf Next
+// Devin variants. Keep legacy Windsurf identifiers only for detection/config compatibility.
 const VARIANTS = [
-  { id: 'windsurf', matchKey: 'ide', matchVal: 'windsurf', https: false, appName: 'Windsurf', needsMetadata: true },
-  { id: 'windsurf-next', matchKey: 'ide', matchVal: 'windsurf-next', https: false, appName: 'Windsurf - Next', needsMetadata: true },
+  {
+    id: 'devin',
+    matchKey: 'ide',
+    matchVals: ['windsurf', 'devin', 'devin-desktop'],
+    https: false,
+    appNames: ['Devin Desktop', 'Devin', 'Windsurf'],
+    needsMetadata: true,
+  },
+  {
+    id: 'devin-next',
+    matchKey: 'ide',
+    matchVals: ['windsurf-next', 'devin-next', 'devin-desktop-next'],
+    https: false,
+    appNames: ['Devin Desktop - Next', 'Devin - Next', 'Windsurf - Next'],
+    needsMetadata: true,
+  },
 ];
 
 // ============================================================
@@ -85,7 +99,7 @@ function getListeningPorts(pid) {
 }
 
 // ============================================================
-// Find running Windsurf language server (port + CSRF token)
+// Find running Devin language server (port + CSRF token)
 // ============================================================
 
 let _lsCache = null;
@@ -101,13 +115,13 @@ function findLanguageServers() {
       ? 'language_server_macos'
       : 'language_server_linux';
 
-  // On macOS/Linux, also check env vars for WINDSURF_CSRF_TOKEN (newer Windsurf Next passes CSRF via env, not CLI arg)
+  // On macOS/Linux, also check env vars for CSRF tokens (some variants pass CSRF via env, not CLI arg)
   const envCsrfByPid = {};
   if (!IS_WINDOWS) {
     try {
       const psEnv = execSync('ps eww -A', { encoding: 'utf-8', maxBuffer: 2 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'] });
       for (const envLine of psEnv.split('\n')) {
-        const envCsrf = envLine.match(/WINDSURF_CSRF_TOKEN=(\S+)/);
+        const envCsrf = envLine.match(/(?:WINDSURF|DEVIN)_CSRF_TOKEN=(\S+)/);
         if (envCsrf) {
           const envPid = envLine.match(/^\s*(\d+)/);
           if (envPid) envCsrfByPid[envPid[1]] = envCsrf[1];
@@ -162,10 +176,11 @@ function findLanguageServers() {
 function getLsForVariant(variant) {
   const servers = findLanguageServers();
   let matches;
+  const matchVals = variant.matchVals || [variant.matchVal];
   if (variant.matchKey === 'appDataDir') {
-    matches = servers.filter(s => s.appDataDir?.includes(variant.matchVal));
+    matches = servers.filter(s => matchVals.some(matchVal => s.appDataDir?.includes(matchVal)));
   } else {
-    matches = servers.filter(s => s.ide === variant.matchVal);
+    matches = servers.filter(s => matchVals.includes(s.ide));
   }
   return matches.length > 0 ? matches[0] : null;
 }
@@ -197,8 +212,9 @@ function callRpc(port, csrf, method, body, extCsrf = null) {
 // Adapter interface
 // ============================================================
 
-const name = 'windsurf';
-const sources = ['windsurf', 'windsurf-next'];
+const name = 'devin';
+const sources = ['devin', 'devin-next'];
+const legacySources = ['windsurf', 'windsurf-next'];
 
 function getChats() {
   const chats = [];
@@ -449,29 +465,39 @@ function getMessages(chat) {
 // Usage / quota data from language server RPC
 // ============================================================
 
-function getWindsurfApiKey(appName) {
-  if (!appName) return null;
+function getDevinApiKey(appNames) {
+  if (!appNames) return null;
+  const names = Array.isArray(appNames) ? appNames : [appNames];
+  const keys = ['windsurfAuthStatus', 'devinAuthStatus'];
   try {
     const HOME = os.homedir();
-    let dbPath;
-    switch (process.platform) {
-      case 'darwin':
-        dbPath = path.join(HOME, 'Library', 'Application Support', appName, 'User', 'globalStorage', 'state.vscdb');
-        break;
-      case 'win32':
-        dbPath = path.join(HOME, 'AppData', 'Roaming', appName, 'User', 'globalStorage', 'state.vscdb');
-        break;
-      default:
-        dbPath = path.join(HOME, '.config', appName, 'User', 'globalStorage', 'state.vscdb');
+    for (const appName of names) {
+      let dbPath;
+      switch (process.platform) {
+        case 'darwin':
+          dbPath = path.join(HOME, 'Library', 'Application Support', appName, 'User', 'globalStorage', 'state.vscdb');
+          break;
+        case 'win32':
+          dbPath = path.join(HOME, 'AppData', 'Roaming', appName, 'User', 'globalStorage', 'state.vscdb');
+          break;
+        default:
+          dbPath = path.join(HOME, '.config', appName, 'User', 'globalStorage', 'state.vscdb');
+      }
+      if (!fs.existsSync(dbPath)) continue;
+      const Database = require('better-sqlite3');
+      const db = new Database(dbPath, { readonly: true });
+      try {
+        for (const key of keys) {
+          const row = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(key);
+          if (!row) continue;
+          const parsed = JSON.parse(row.value);
+          if (parsed.apiKey) return parsed.apiKey;
+        }
+      } finally {
+        db.close();
+      }
     }
-    if (!fs.existsSync(dbPath)) return null;
-    const Database = require('better-sqlite3');
-    const db = new Database(dbPath, { readonly: true });
-    const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'windsurfAuthStatus'").get();
-    db.close();
-    if (!row) return null;
-    const parsed = JSON.parse(row.value);
-    return parsed.apiKey || null;
+    return null;
   } catch { return null; }
 }
 
@@ -485,7 +511,7 @@ function getUsage() {
     const ls = getLsForVariant(variant);
     if (!ls) continue;
 
-    const apiKey = getWindsurfApiKey(variant.appName);
+    const apiKey = getDevinApiKey(variant.appNames);
     if (!apiKey) continue;
     const body = {
       metadata: {
@@ -579,13 +605,13 @@ function getUsage() {
 
 function resetCache() { _lsCache = null; }
 
-const labels = { 'windsurf': 'Windsurf', 'windsurf-next': 'Windsurf Next' };
+const labels = { 'devin': 'Devin', 'devin-next': 'Devin Next' };
 
 function getArtifacts(folder) {
   const { scanArtifacts } = require('./base');
   return scanArtifacts(folder, {
-    editor: 'windsurf',
-    label: 'Windsurf',
+    editor: 'devin',
+    label: 'Devin',
     files: ['.windsurfrules'],
     dirs: ['.windsurf/workflows', '.windsurf/rules', '.windsurf/plans', '.windsurf/skills'],
   });
@@ -595,8 +621,9 @@ function getMCPServers() {
   const { parseMcpConfigFile } = require('./base');
   const results = [];
   const configs = [
-    { file: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'), editor: 'windsurf', label: 'Windsurf' },
-    { file: path.join(os.homedir(), '.codeium', 'windsurf-next', 'mcp_config.json'), editor: 'windsurf-next', label: 'Windsurf Next' },
+    { file: path.join(os.homedir(), '.windsurf', 'mcp_config.json'), editor: 'devin', label: 'Devin' },
+    { file: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'), editor: 'devin', label: 'Devin' },
+    { file: path.join(os.homedir(), '.codeium', 'windsurf-next', 'mcp_config.json'), editor: 'devin-next', label: 'Devin Next' },
   ];
   for (const c of configs) {
     results.push(...parseMcpConfigFile(c.file, { editor: c.editor, label: c.label, scope: 'global' }));
@@ -604,4 +631,4 @@ function getMCPServers() {
   return results;
 }
 
-module.exports = { name, sources, labels, getChats, getMessages, resetCache, getUsage, getArtifacts, getMCPServers };
+module.exports = { name, sources, legacySources, labels, getChats, getMessages, resetCache, getUsage, getArtifacts, getMCPServers };

package/index.js

@@ -247,11 +247,21 @@ if (noCache) {
   }
 }
 
-// ── Warn about installed-but-not-running Windsurf variants (macOS only) ─
+// ── Warn about installed-but-not-running Devin variants (macOS only) ─
 if (process.platform === 'darwin') {
-const WINDSURF_VARIANTS = [
-  { name: 'Windsurf', app: '/Applications/Windsurf.app', dataDir: path.join(HOME, '.codeium', 'windsurf'), ide: 'windsurf' },
-  { name: 'Windsurf Next', app: '/Applications/Windsurf Next.app', dataDir: path.join(HOME, '.codeium', 'windsurf-next'), ide: 'windsurf-next' },
+const DEVIN_DESKTOP_VARIANTS = [
+  {
+    name: 'Devin',
+    apps: ['/Applications/Devin Desktop.app', '/Applications/Devin.app', '/Applications/Windsurf.app'],
+    dataDirs: [path.join(HOME, '.windsurf'), path.join(HOME, '.codeium', 'windsurf')],
+    ides: ['devin-desktop', 'devin', 'windsurf'],
+  },
+  {
+    name: 'Devin Next',
+    apps: ['/Applications/Devin Desktop Next.app', '/Applications/Devin Next.app', '/Applications/Windsurf Next.app'],
+    dataDirs: [path.join(HOME, '.codeium', 'windsurf-next')],
+    ides: ['devin-desktop-next', 'devin-next', 'windsurf-next'],
+  },
   { name: 'Antigravity', app: '/Applications/Antigravity.app', dataDir: path.join(HOME, '.codeium', 'antigravity'), ide: 'antigravity' },
 ];
 
@@ -269,9 +279,12 @@ const WINDSURF_VARIANTS = [
     }
   } catch {}
 
-  const installedNotRunning = WINDSURF_VARIANTS.filter(v => {
-    const installed = fs.existsSync(v.app) || fs.existsSync(v.dataDir);
-    const running = runningIdes.some(r => r === v.ide || r.includes(v.ide));
+  const installedNotRunning = DEVIN_DESKTOP_VARIANTS.filter(v => {
+    const apps = v.apps || [v.app];
+    const dataDirs = v.dataDirs || [v.dataDir];
+    const ides = v.ides || [v.ide];
+    const installed = apps.some(app => fs.existsSync(app)) || dataDirs.some(dataDir => fs.existsSync(dataDir));
+    const running = runningIdes.some(r => ides.some(ide => r === ide || r.includes(ide)));
     return installed && !running;
   });
 
@@ -304,11 +317,18 @@ allChats.sort((a, b) => (b.lastUpdatedAt || b.createdAt || 0) - (a.lastUpdatedAt
 const bySource = {};
 for (const chat of allChats) bySource[chat.source] = (bySource[chat.source] || 0) + 1;
 
-const displayList = Object.entries(editorLabels)
-  .map(([src, label]) => [src, label, bySource[src] || 0])
-  .sort((a, b) => b[2] - a[2]);
+const displayByLabel = new Map();
+for (const [src, label] of Object.entries(editorLabels)) {
+  const existing = displayByLabel.get(label) || { label, count: 0 };
+  existing.count += bySource[src] || 0;
+  displayByLabel.set(label, existing);
+}
+
+const displayList = Array.from(displayByLabel.values())
+  .map(({ label, count }) => [label, count])
+  .sort((a, b) => b[1] - a[1]);
 
-for (const [src, label, count] of displayList) {
+for (const [label, count] of displayList) {
   if (count > 0) {
     console.log(`  ${chalk.green('✓')} ${chalk.bold(label.padEnd(18))} ${chalk.dim(`${count} session${count === 1 ? '' : 's'}`)}`);
   } else {
@@ -344,7 +364,7 @@ const BOT_STYLES = [
     console.log(chalk.dim('      • Copilot      – ~/.config/github-copilot/apps.json'));
     console.log(chalk.dim('      • VS Code      – ~/.config/github-copilot/apps.json'));
     console.log(chalk.dim('      • Codex        – local auth.json (JWT decode only)'));
-    console.log(chalk.dim('      • Windsurf     – local SQLite (state.vscdb)'));
+    console.log(chalk.dim('      • Devin        – local SQLite (state.vscdb)'));
     console.log('');
     console.log(chalk.dim('    These tokens are used to query each editor\'s own API for'));
     console.log(chalk.dim('    your plan name and usage limits.'));