swarmdo 1.58.1 → 1.58.12

package/v3/@swarmdo/cli/.claude/helpers/statusline.cjs

@@ -1,77 +1,378 @@
 #!/usr/bin/env node
 /**
- * Swarmdo V3.5 Statusline Generator
- * Displays real-time V3 implementation progress and system status
+ * Swarmdo V3 Statusline — delegation build (#2195)
  *
- * Usage: node statusline.cjs [options]
+ * Fix for upstream/swarmdo#2195: the previous version re-implemented all data
+ * readers locally using fragile file probes that missed AgentDB patterns,
+ * the v3/docs/adr/ ADR directory, and the real vector count.
  *
- * Options:
- *   (default)   Safe multi-line output with collision zone avoidance
- *   --single    Single-line output (completely avoids collision)
- *   --unsafe    Legacy multi-line without collision avoidance
- *   --legacy    Alias for --unsafe
- *   --json      JSON output with pretty printing
- *   --compact   JSON output without formatting
+ * This version delegates to 'npx @swarmdo/cli hooks statusline --json'
+ * as the single source of truth. That command queries AgentDB directly,
+ * counts ADRs in both directories, and reports the real intelligence pct.
  *
- * Collision Zone Fix (Issue #985):
- * Claude Code writes its internal status (e.g., "7s • 1p") at absolute
- * terminal coordinates (columns 15-25 on second-to-last line). The safe
- * mode pads the collision line with spaces to push content past column 25.
+ * ADR counting falls back to local file reads so the display still works
+ * without network access (counts both v3/docs/adr/ and v3/implementation/adrs/).
  *
- * IMPORTANT: This file uses .cjs extension to work in ES module projects.
- * The require() syntax is intentional for CommonJS compatibility.
+ * Cache: JSON result is cached in /tmp for 10s so rapid prompt triggers
+ * (every keystroke in some shells) don't hammer the CLI on every call.
+ *
+ * Usage: node statusline.cjs [--json] [--compact] [--dashboard]
  */
 
 /* eslint-disable @typescript-eslint/no-var-requires */
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
 const os = require('os');
-const { execSync, execFileSync } = require('child_process');
-
-// Read the installed plugin version once at startup. Probe the plugin's own
-// install location first (`~/.claude/plugins/marketplaces/swarmdo/package.json`),
-// then npm-style installs, then the source-checkout location. The previous
-// code hardcoded `Swarmdo V3.5` in the header — so users on alpha.27+ still
-// saw V3.5 in the statusline even though `swarmdo doctor` reported the real
-// version (#1951).
-let SWARMDO_VERSION = '3.6';
-try {
-  const home = os.homedir();
-  const cwd = process.cwd();
-  const pkgPaths = [
-    path.join(home, '.claude', 'plugins', 'marketplaces', 'swarmdo', 'package.json'),
-    path.join(cwd, 'node_modules', '@swarmdo', 'cli', 'package.json'),
-    path.join(cwd, 'node_modules', 'swarmdo', 'package.json'),
-    path.join(cwd, 'v3', '@swarmdo', 'cli', 'package.json'),
-  ];
-  for (const p of pkgPaths) {
-    if (!fs.existsSync(p)) continue;
-    try {
-      const pkg = JSON.parse(fs.readFileSync(p, 'utf-8'));
-      if (pkg && typeof pkg.version === 'string' && pkg.version.length > 0) {
-        SWARMDO_VERSION = pkg.version;
-        break;
-      }
-    } catch { /* malformed package.json — try next */ }
-  }
-} catch { /* fall through to the hardcoded default */ }
 
 // Configuration
 const CONFIG = {
-  enabled: true,
-  showProgress: true,
-  showSecurity: true,
-  showSwarm: true,
-  showHooks: true,
-  showPerformance: true,
-  refreshInterval: 5000,
   maxAgents: 15,
-  topology: 'hierarchical-mesh',
+  // Session-cost display. Claude Code's cost.total_cost_usd is a client-side
+  // estimate that "may differ from your actual bill" and reads as misleading on
+  // subscription plans, where token usage is not billed per dollar. These let
+  // each user pick what the segment means to them without changing the default.
+  //   SWARMDO_STATUSLINE_COST_SYMBOL  override the leading '$' (e.g. ⚡, €, 🌱);
+  //                                 set to an empty string for the number alone.
+  //   SWARMDO_STATUSLINE_HIDE_COST    1/true/yes/on removes the segment entirely.
+  costSymbol: process.env.SWARMDO_STATUSLINE_COST_SYMBOL ?? '$',
+  hideCost: /^(1|true|yes|on)$/i.test(process.env.SWARMDO_STATUSLINE_HIDE_COST || ''),
+};
+
+const CWD = process.cwd();
+
+// ─── Delegation cache ───────────────────────────────────────────
+// Cache the CLI JSON result for 60s so rapid prompt re-renders
+// (Claude Code refreshes the statusline several times a second while
+// streaming) don't re-invoke the CLI each time. #2337: bumped 10s→60s
+// because 10s was far too short for how often Claude Code re-renders.
+const CACHE_FILE = path.join(os.tmpdir(), 'swarmdo-statusline-cache-' + require('crypto').createHash('md5').update(CWD).digest('hex').slice(0, 8) + '.json');
+const CACHE_TTL_MS = 60000;
+
+// ─── User-selectable segments (SWARMDO_STATUSLINE) ───────────────────────────
+// The full statusline is busy by design; users pick what they want to see.
+// Resolution order: SWARMDO_STATUSLINE env var → .swarmdo/statusline.json in
+// the project → ~/.swarmdo/statusline.json → 'full'.
+// Value is a preset name ('full' | 'compact' | 'minimal') or a comma list of
+// segment names: version,project,branch,model,duration,context,cost,
+// domains,swarm,architecture,agentdb
+const SEGMENT_PRESETS = {
+  full: ['version','project','branch','model','duration','context','cost','domains','swarm','architecture','agentdb'],
+  compact: ['version','project','branch','model','context','cost','swarm'],
+  minimal: ['project','branch','model','context'],
 };
+function resolveSegments() {
+  let spec = (process.env.SWARMDO_STATUSLINE || '').trim();
+  if (!spec) {
+    const candidates = [
+      path.join(CWD, '.swarmdo', 'statusline.json'),
+      path.join(os.homedir(), '.swarmdo', 'statusline.json'),
+    ];
+    for (const cand of candidates) {
+      try {
+        const j = JSON.parse(fs.readFileSync(cand, 'utf8'));
+        if (typeof j.preset === 'string' && j.preset) { spec = j.preset; break; }
+        if (Array.isArray(j.segments) && j.segments.length) { spec = j.segments.join(','); break; }
+      } catch { /* absent or invalid — keep looking */ }
+    }
+  }
+  if (!spec) spec = 'full';
+  const preset = SEGMENT_PRESETS[spec.toLowerCase()];
+  const list = preset || spec.split(',').map(function (x) { return x.trim().toLowerCase(); }).filter(Boolean);
+  return new Set(list.length ? list : SEGMENT_PRESETS.full);
+}
+const SEGMENTS = resolveSegments();
+function seg(name) { return SEGMENTS.has(name); }
+
+// ─── Cost slot: plan-aware mode + account display ────────────────────────────
+// Resolution mirrors resolveSegments: env → project config → global config →
+// default. mode: auto|dollars|limits|off (auto → limits for a subscription
+// account, dollars otherwise); showAccount prefixes the account label.
+function resolveCostOptions() {
+  let mode = null;
+  let showAccount = null;
+  const envMode = (process.env.SWARMDO_STATUSLINE_COST_MODE || '').trim().toLowerCase();
+  if (envMode === 'auto' || envMode === 'dollars' || envMode === 'limits' || envMode === 'off') mode = envMode;
+  const envShow = (process.env.SWARMDO_STATUSLINE_SHOW_ACCOUNT || '').trim();
+  if (/^(1|true|yes|on)$/i.test(envShow)) showAccount = true;
+  else if (/^(0|false|no|off)$/i.test(envShow)) showAccount = false;
+  if (mode === null || showAccount === null) {
+    const files = [
+      path.join(CWD, '.swarmdo', 'statusline.json'),
+      path.join(os.homedir(), '.swarmdo', 'statusline.json'),
+    ];
+    for (const f of files) {
+      try {
+        const j = JSON.parse(fs.readFileSync(f, 'utf8'));
+        const cost = j && j.cost;
+        if (cost && typeof cost === 'object') {
+          if (mode === null && typeof cost.mode === 'string') {
+            const m = cost.mode.trim().toLowerCase();
+            if (m === 'auto' || m === 'dollars' || m === 'limits' || m === 'off') mode = m;
+          }
+          if (showAccount === null && typeof cost.showAccount === 'boolean') showAccount = cost.showAccount;
+        }
+      } catch (e) { /* absent/invalid — keep looking */ }
+      if (mode !== null && showAccount !== null) break;
+    }
+  }
+  if (CONFIG.hideCost) mode = 'off'; // legacy SWARMDO_STATUSLINE_HIDE_COST
+  return { mode: mode || 'auto', showAccount: showAccount === true };
+}
+const COST_OPTS = resolveCostOptions();
+
+// #2337: resolve an already-installed @swarmdo/cli (or swarmdo) bin so we
+// can invoke it directly via `node`. The previous version called
+// `npx --yes @swarmdo/cli@latest` on every uncached render, which forces
+// a registry resolution + cold-start of the entire CLI per render. With
+// multiple concurrent Claude Code sessions this storms the host (reporter
+// saw load average 40-65 on a 12-core box).
+//
+// Returns the absolute path to bin/cli.js or null. Mirrors getPkgVersion()'s
+// path probing (project, monorepo, plugin marketplace, global node_modules
+// including custom-prefix layouts like ~/.npm-global).
+function resolveCliBin() {
+  try {
+    const home = os.homedir();
+    const candidates = [
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'swarmdo', 'bin', 'cli.js'),
+      path.join(CWD, 'node_modules', '@swarmdo', 'cli', 'bin', 'cli.js'),
+      path.join(CWD, 'node_modules', 'swarmdo', 'bin', 'cli.js'),
+      path.join(CWD, 'v3', '@swarmdo', 'cli', 'bin', 'cli.js'),
+    ];
+    try {
+      const binDir = path.dirname(process.execPath);
+      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules'), '/opt/homebrew/lib/node_modules', '/usr/local/lib/node_modules'];
+      for (const prefix of [process.env.npm_config_prefix, process.env.PREFIX, path.join(home, '.npm-global')]) {
+        if (prefix) globalModuleDirs.push(path.join(prefix, 'lib', 'node_modules'));
+      }
+      for (const gm of globalModuleDirs) {
+        candidates.push(
+          path.join(gm, 'swarmdo', 'bin', 'cli.js'),
+          path.join(gm, '@swarmdo', 'cli', 'bin', 'cli.js'),
+        );
+      }
+    } catch { /* ignore */ }
+    for (const p of candidates) {
+      if (fs.existsSync(p)) return p;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+function readCache() {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      const raw = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+      if (raw && raw._ts && (Date.now() - raw._ts) < CACHE_TTL_MS) {
+        return raw.data;
+      }
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+function writeCache(data) {
+  try { fs.writeFileSync(CACHE_FILE, JSON.stringify({ _ts: Date.now(), data }), 'utf-8'); } catch { /* ignore */ }
+}
+
+/**
+ * Single source of truth: delegate to the CLI hooks statusline --json command.
+ * Falls back to a minimal static object on failure so the statusline still renders.
+ *
+ * Fix for swarmdo#2195: the previous local readers returned 0 for AgentDB patterns
+ * (missed the .swarm/memory.db → AgentDB path), computed dddProgress wrong,
+ * and only counted ADRs in v3/implementation/adrs/ (missed v3/docs/adr/).
+ */
+function getStatuslineData() {
+  // SWARMDO_STATUSLINE_NO_CLI: skip the CLI-delegation fork and render from local
+  // reads + stdin only. A cold render otherwise forks the hooks-statusline CLI
+  // (now more reachable via the global-node_modules probes below), and that fork
+  // can disturb the stdin cost payload; skipping it keeps renders fast, hermetic,
+  // and subprocess-free. Set by the statusline tests; usable by anyone who wants
+  // a no-fork statusline.
+  if (process.env.SWARMDO_STATUSLINE_NO_CLI) return buildLocalFallback();
+  const cached = readCache();
+  if (cached) return cached;
+
+  try {
+    // #2337: prefer an already-installed CLI bin via direct `node` invocation
+    // — no npx, no registry round-trip, no @latest re-resolve per render.
+    // Fall back to `npx --prefer-offline @swarmdo/cli` (no @latest) only
+    // when nothing is installed locally, so a cold environment still works.
+    const cliBin = resolveCliBin();
+    const cmd = cliBin
+      ? '"' + process.execPath + '" "' + cliBin + '" hooks statusline --json 2>/dev/null'
+      : 'npx --prefer-offline @swarmdo/cli hooks statusline --json 2>/dev/null';
+    const raw = execSync(
+      cmd,
+      { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD }
+    ).trim();
+    // The CLI may emit preamble lines before the JSON — find the first '{'.
+    const jsonStart = raw.indexOf('{');
+    if (jsonStart === -1) throw new Error('no JSON in CLI output');
+    const data = JSON.parse(raw.slice(jsonStart));
+    // Overlay every block the CLI JSON omits (adrs/agentdb/tests/hooks/integration)
+    // with real local reads, so those segments reflect actual state instead of 0.
+    applyLocalOverlays(data);
+    writeCache(data);
+    return data;
+  } catch { /* CLI unavailable or timed out */ }
+
+  // Fallback: use local file probes only (will be less accurate, but non-zero
+  // when CLI is available and accurate when it's not).
+  return buildLocalFallback();
+}
+
+// Count ADRs from BOTH known directories (fix for swarmdo#2195: old code missed
+// v3/docs/adr/ which holds ADR-088..ADR-137, i.e. 41 of the 128 total ADRs).
+function getLocalADRCount() {
+  const adrDirs = [
+    path.join(CWD, 'v3', 'implementation', 'adrs'),
+    path.join(CWD, 'v3', 'docs', 'adr'),
+    path.join(CWD, 'docs', 'adrs'),
+    path.join(CWD, '.swarmdo', 'adrs'),
+  ];
+  let total = 0;
+  for (const dir of adrDirs) {
+    try {
+      if (fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir).filter(function(f) {
+          return f.endsWith('.md') && (f.startsWith('ADR-') || f.startsWith('adr-') || /^\d{4}-/.test(f));
+        });
+        total += files.length;
+      }
+    } catch { /* ignore */ }
+  }
+  return { count: total, implemented: total, compliance: 0 };
+}
 
-// Cross-platform helpers
-const isWindows = process.platform === 'win32';
-const nullDevice = isWindows ? 'NUL' : '/dev/null';
+// ─── Local overlays for segments the CLI JSON omits ──────────────
+// 'hooks statusline --json' only returns user/v3Progress/security/swarm/system.
+// agentdb/tests/hooks/integration are never populated, so without these overlays
+// they render as a permanent 0. Each reader is cheap and degrades to zeros.
+
+// Real AgentDB stats from the local memory DB. Vectors live in .swarm/memory.db
+// (sql.js + HNSW); vector.db is an opaque redb store counted only toward size.
+// One read-only sqlite3 query (mode=ro never takes a write lock the daemon owns).
+function getLocalAgentDB() {
+  const result = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
+  try {
+    let bytes = 0;
+    for (const f of ['.swarm/memory.db', 'vector.db']) {
+      try { bytes += fs.statSync(path.join(CWD, f)).size; } catch { /* missing */ }
+    }
+    result.dbSizeKB = Math.round(bytes / 1024);
+
+    const memDb = path.join(CWD, '.swarm', 'memory.db');
+    if (fs.existsSync(memDb)) {
+      const Q = String.fromCharCode(34);
+      const sql = Q + 'SELECT (SELECT COUNT(*) FROM memory_entries WHERE embedding IS NOT NULL)||' + "'|'" + '||(SELECT COUNT(*) FROM vector_indexes);' + Q;
+      const out = safeExec("sqlite3 'file:" + memDb + "?mode=ro' " + sql, 1500);
+      if (out && out.indexOf('|') !== -1) {
+        const parts = out.split('|');
+        result.vectorCount = parseInt(parts[0], 10) || 0;
+        result.hasHnsw = (parseInt(parts[1], 10) || 0) > 0;
+      }
+    }
+  } catch { /* ignore */ }
+  return result;
+}
+
+// Count test files via a bounded directory walk (no file reads).
+function getLocalTests() {
+  let testFiles = 0;
+  function countTests(dir, depth) {
+    if ((depth || 0) > 4) return;
+    try {
+      if (!fs.existsSync(dir)) return;
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules') {
+          countTests(path.join(dir, e.name), (depth || 0) + 1);
+        } else if (e.isFile() && (e.name.includes('.test.') || e.name.includes('.spec.') || e.name.startsWith('test_') || e.name.startsWith('spec_'))) {
+          testFiles++;
+        }
+      }
+    } catch { /* ignore */ }
+  }
+  for (const d of ['tests', 'test', '__tests__', 'src', 'v3']) countTests(path.join(CWD, d));
+  return { testFiles, testCases: testFiles * 4 };
+}
+
+// Count configured hooks from project .claude/settings.json. Claude Code hooks
+// have no enabled/disabled flag, so every configured hook counts as enabled.
+function getLocalHooks() {
+  const result = { enabled: 0, total: 0 };
+  try {
+    const settings = readJSON(path.join(CWD, '.claude', 'settings.json'));
+    const hooks = settings && settings.hooks;
+    if (hooks && typeof hooks === 'object') {
+      let n = 0;
+      for (const ev of Object.keys(hooks)) {
+        const groups = hooks[ev];
+        if (Array.isArray(groups)) {
+          for (const g of groups) {
+            if (g && Array.isArray(g.hooks)) n += g.hooks.length;
+          }
+        }
+      }
+      result.total = n;
+      result.enabled = n;
+    }
+  } catch { /* ignore */ }
+  return result;
+}
+
+// Best-effort integration block: DB presence + locally-configured stdio MCP
+// servers (project .mcp.json + global ~/.claude.json). Remote connectors are
+// account-managed and not present in local config, so they are not counted.
+function getLocalIntegration() {
+  const integration = { mcpServers: { enabled: 0, total: 0 }, hasDatabase: false };
+  try {
+    for (const f of ['.swarm/memory.db', 'vector.db']) {
+      if (fs.existsSync(path.join(CWD, f))) { integration.hasDatabase = true; break; }
+    }
+    const names = new Set();
+    const projMcp = readJSON(path.join(CWD, '.mcp.json'));
+    if (projMcp && projMcp.mcpServers) for (const k of Object.keys(projMcp.mcpServers)) names.add(k);
+    const claudeJson = readJSON(path.join(os.homedir(), '.claude.json'));
+    if (claudeJson) {
+      if (claudeJson.mcpServers) for (const k of Object.keys(claudeJson.mcpServers)) names.add(k);
+      const proj = claudeJson.projects && claudeJson.projects[CWD];
+      if (proj && proj.mcpServers && !Array.isArray(proj.mcpServers)) {
+        for (const k of Object.keys(proj.mcpServers)) names.add(k);
+      }
+    }
+    integration.mcpServers.total = names.size;
+    integration.mcpServers.enabled = names.size;
+  } catch { /* ignore */ }
+  return integration;
+}
+
+// Overlay every locally-derived block onto the CLI data (mutates in place).
+function applyLocalOverlays(data) {
+  data.adrs = getLocalADRCount();
+  data.agentdb = getLocalAgentDB();
+  data.tests = getLocalTests();
+  data.hooks = getLocalHooks();
+  data.integration = getLocalIntegration();
+  return data;
+}
+
+// Minimal local fallback when the CLI is not installed or times out.
+// Returns a structure that matches the CLI JSON schema so the renderer works.
+function buildLocalFallback() {
+  const memMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
+
+  return applyLocalOverlays({
+    user: { name: 'user', gitBranch: '', modelName: 'Claude Code' },
+    v3Progress: { domainsCompleted: 0, totalDomains: 5, dddProgress: 0, patternsLearned: 0, sessionsCompleted: 0 },
+    security: { status: 'NONE', critical: 0, high: 0, total: 0 },
+    swarm: { activeSwarms: 0, activeAgents: 0, coordinationActive: false },
+    system: { memoryMB: memMB, contextPct: 0, intelligencePct: 0 },
+    lastUpdated: new Date().toISOString(),
+  });
+}
 
 // ANSI colors
 const c = {
@@ -93,512 +394,483 @@ const c = {
   brightWhite: '\x1b[1;37m',
 };
 
-// Get user info
-function getUserInfo() {
-  let name = 'user';
-  let gitBranch = '';
-  let modelName = 'Unknown';
-
-  // audit_1776853149979: previously used execSync with a shell string. Switched
-  // to execFileSync('git', argv) on both platforms so there is no shell
-  // interpretation. Cross-platform behavior is preserved by relying on git's
-  // own exit code instead of `|| echo` fallbacks: missing repo / no user.name
-  // throws, caught below, defaults retained.
-  try {
-    name = execFileSync('git', ['config', 'user.name'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || 'user';
-  } catch { /* keep default */ }
+// Safe execSync with strict timeout (returns empty string on failure)
+function safeExec(cmd, timeoutMs) {
   try {
-    gitBranch = execFileSync('git', ['branch', '--show-current'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-  } catch { /* keep empty */ }
+    return execSync(cmd, {
+      encoding: 'utf-8',
+      timeout: timeoutMs || 2000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return '';
+  }
+}
 
-  // Auto-detect model from Claude Code's config
+// Safe JSON file reader (returns null on failure)
+function readJSON(filePath) {
   try {
-    const homedir = require('os').homedir();
-    const claudeConfigPath = path.join(homedir, '.claude.json');
-    if (fs.existsSync(claudeConfigPath)) {
-      const claudeConfig = JSON.parse(fs.readFileSync(claudeConfigPath, 'utf-8'));
-      // Try to find lastModelUsage - check current dir and parent dirs
-      let lastModelUsage = null;
-      const cwd = process.cwd();
-      if (claudeConfig.projects) {
-        // Try exact match first, then check if cwd starts with any project path
-        for (const [projectPath, projectConfig] of Object.entries(claudeConfig.projects)) {
-          if (cwd === projectPath || cwd.startsWith(projectPath + '/')) {
-            lastModelUsage = projectConfig.lastModelUsage;
-            break;
-          }
-        }
-      }
-      if (lastModelUsage) {
-        const modelIds = Object.keys(lastModelUsage);
-        if (modelIds.length > 0) {
-          // Take the last model (most recently added to the object)
-          // Or find the one with most tokens (most actively used this session)
-          let modelId = modelIds[modelIds.length - 1];
-          if (modelIds.length > 1) {
-            // If multiple models, pick the one with most total tokens
-            let maxTokens = 0;
-            for (const id of modelIds) {
-              const usage = lastModelUsage[id];
-              const total = (usage.inputTokens || 0) + (usage.outputTokens || 0);
-              if (total > maxTokens) {
-                maxTokens = total;
-                modelId = id;
-              }
-            }
-          }
-          // Parse model ID to human-readable name
-          if (modelId.includes('opus')) modelName = 'Opus 4.6 (1M context)';
-          else if (modelId.includes('sonnet')) modelName = 'Sonnet 4.6';
-          else if (modelId.includes('haiku')) modelName = 'Haiku 4.5';
-          else modelName = modelId.split('-').slice(1, 3).join(' ');
-        }
-      }
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
     }
-  } catch (e) {
-    // Fallback to Unknown if can't read config
-  }
-
-  return { name, gitBranch, modelName };
+  } catch { /* ignore */ }
+  return null;
 }
 
-// Get learning stats from intelligence loop data (ADR-050)
-function getLearningStats() {
-  let patterns = 0;
-  let sessions = 0;
-  let trajectories = 0;
-  let edges = 0;
-  let confidenceMean = 0;
-  let accessedCount = 0;
-  let trend = 'STABLE';
-
-  // PRIMARY: Read from intelligence loop data files
-  const dataDir = path.join(process.cwd(), '.swarmdo', 'data');
+// ─── Git info (pure-Node / single exec — needed for branch display) ──────────
 
-  // 1. graph-state.json — authoritative node/edge counts
-  const graphPath = path.join(dataDir, 'graph-state.json');
-  if (fs.existsSync(graphPath)) {
-    try {
-      const graph = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
-      patterns = graph.nodes ? Object.keys(graph.nodes).length : 0;
-      edges = Array.isArray(graph.edges) ? graph.edges.length : 0;
-    } catch (e) { /* ignore */ }
-  }
+function getGitInfo() {
+  const result = {
+    name: 'user', gitBranch: '', modified: 0, untracked: 0,
+    staged: 0, ahead: 0, behind: 0,
+  };
 
-  // 2. ranked-context.json — confidence and access data
-  const rankedPath = path.join(dataDir, 'ranked-context.json');
-  if (fs.existsSync(rankedPath)) {
-    try {
-      const ranked = JSON.parse(fs.readFileSync(rankedPath, 'utf-8'));
-      if (ranked.entries && ranked.entries.length > 0) {
-        patterns = Math.max(patterns, ranked.entries.length);
-        let confSum = 0;
-        let accCount = 0;
-        for (let i = 0; i < ranked.entries.length; i++) {
-          confSum += (ranked.entries[i].confidence || 0);
-          if ((ranked.entries[i].accessCount || 0) > 0) accCount++;
-        }
-        confidenceMean = confSum / ranked.entries.length;
-        accessedCount = accCount;
+  const script = [
+    'git config user.name 2>/dev/null || echo user',
+    'echo "---SEP---"',
+    'git branch --show-current 2>/dev/null',
+    'echo "---SEP---"',
+    'git status --porcelain 2>/dev/null',
+    'echo "---SEP---"',
+    'git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null || echo "0 0"',
+  ].join('; ');
+
+  const raw = safeExec("sh -c '" + script + "'", 3000);
+  if (!raw) return result;
+
+  const parts = raw.split('---SEP---').map(function(s) { return s.trim(); });
+  if (parts.length >= 4) {
+    result.name = parts[0] || 'user';
+    result.gitBranch = parts[1] || '';
+
+    if (parts[2]) {
+      for (const line of parts[2].split('\n')) {
+        if (!line || line.length < 2) continue;
+        const x = line[0], y = line[1];
+        if (x === '?' && y === '?') { result.untracked++; continue; }
+        if (x !== ' ' && x !== '?') result.staged++;
+        if (y !== ' ' && y !== '?') result.modified++;
       }
-    } catch (e) { /* ignore */ }
-  }
+    }
 
-  // 3. intelligence-snapshot.json — trend history
-  const snapshotPath = path.join(dataDir, 'intelligence-snapshot.json');
-  if (fs.existsSync(snapshotPath)) {
-    try {
-      const snapshot = JSON.parse(fs.readFileSync(snapshotPath, 'utf-8'));
-      if (snapshot.history && snapshot.history.length >= 2) {
-        const first = snapshot.history[0];
-        const last = snapshot.history[snapshot.history.length - 1];
-        const confDrift = (last.confidenceMean || 0) - (first.confidenceMean || 0);
-        trend = confDrift > 0.01 ? 'IMPROVING' : confDrift < -0.01 ? 'DECLINING' : 'STABLE';
-        sessions = Math.max(sessions, snapshot.history.length);
-      }
-    } catch (e) { /* ignore */ }
+    const ab = (parts[3] || '0 0').split(/\s+/);
+    result.ahead = parseInt(ab[0]) || 0;
+    result.behind = parseInt(ab[1]) || 0;
   }
 
-  // 4. auto-memory-store.json — fallback entry count
-  if (patterns === 0) {
-    const autoMemPath = path.join(dataDir, 'auto-memory-store.json');
-    if (fs.existsSync(autoMemPath)) {
-      try {
-        const data = JSON.parse(fs.readFileSync(autoMemPath, 'utf-8'));
-        patterns = Array.isArray(data) ? data.length : (data.entries ? data.entries.length : 0);
-      } catch (e) { /* ignore */ }
-    }
-  }
+  return result;
+}
 
-  // FALLBACK: Legacy memory.db file-size estimation
-  if (patterns === 0) {
-    const memoryPaths = [
-      path.join(process.cwd(), '.swarm', 'memory.db'),
-      path.join(process.cwd(), '.claude', 'memory.db'),
-      path.join(process.cwd(), 'data', 'memory.db'),
-    ];
-    for (let j = 0; j < memoryPaths.length; j++) {
-      if (fs.existsSync(memoryPaths[j])) {
-        try {
-          const dbStats = fs.statSync(memoryPaths[j]);
-          patterns = Math.floor(dbStats.size / 1024 / 2);
+// Detect model name from Claude config (pure file reads, no exec)
+function getModelName() {
+  try {
+    const claudeConfig = readJSON(path.join(os.homedir(), '.claude.json'));
+    if (claudeConfig && claudeConfig.projects) {
+      for (const [projectPath, projectConfig] of Object.entries(claudeConfig.projects)) {
+        if (CWD === projectPath || CWD.startsWith(projectPath + '/')) {
+          const usage = projectConfig.lastModelUsage;
+          if (usage) {
+            const ids = Object.keys(usage);
+            if (ids.length > 0) {
+              let modelId = ids[ids.length - 1];
+              let latest = 0;
+              for (const id of ids) {
+                const ts = usage[id] && usage[id].lastUsedAt ? new Date(usage[id].lastUsedAt).getTime() : 0;
+                if (ts > latest) { latest = ts; modelId = id; }
+              }
+              if (modelId.includes('opus')) return 'Opus 4.8';
+              if (modelId.includes('sonnet')) return 'Sonnet 4.6';
+              if (modelId.includes('haiku')) return 'Haiku 4.5';
+              return modelId.split('-').slice(1, 3).join(' ');
+            }
+          }
           break;
-        } catch (e) { /* ignore */ }
+        }
       }
     }
+  } catch { /* ignore */ }
+
+  // Fallback: settings.json model field
+  const settings = getSettings();
+  if (settings && settings.model) {
+    const m = settings.model;
+    if (m.includes('opus')) return 'Opus 4.8';
+    if (m.includes('sonnet')) return 'Sonnet 4.6';
+    if (m.includes('haiku')) return 'Haiku 4.5';
   }
+  return 'Claude Code';
+}
 
-  // Session count from session files
-  const sessionsPath = path.join(process.cwd(), '.claude', 'sessions');
-  if (fs.existsSync(sessionsPath)) {
+// ─── Stdin reader (Claude Code pipes session JSON) ──────────────
+// Claude Code sends session JSON via stdin. Read synchronously so the
+// script works both when invoked by Claude Code (stdin has JSON) and
+// when run manually from terminal (stdin is empty/tty).
+let _stdinData = null;
+function getStdinData() {
+  if (_stdinData !== undefined && _stdinData !== null) return _stdinData;
+  try {
+    if (process.stdin.isTTY) { _stdinData = null; return null; }
+    const chunks = [];
+    const buf = Buffer.alloc(4096);
+    let bytesRead;
     try {
-      const sessionFiles = fs.readdirSync(sessionsPath).filter(f => f.endsWith('.json'));
-      sessions = Math.max(sessions, sessionFiles.length);
-    } catch (e) { /* ignore */ }
+      while ((bytesRead = fs.readSync(0, buf, 0, buf.length, null)) > 0) {
+        chunks.push(buf.slice(0, bytesRead));
+      }
+    } catch { /* EOF or read error */ }
+    const raw = Buffer.concat(chunks).toString('utf-8').trim();
+    _stdinData = (raw && raw.startsWith('{')) ? JSON.parse(raw) : null;
+  } catch {
+    _stdinData = null;
   }
-
-  trajectories = Math.floor(patterns / 5);
-
-  return { patterns, sessions, trajectories, edges, confidenceMean, accessedCount, trend };
+  return _stdinData;
 }
 
-// Get V3 progress from learning state (grows as system learns)
-function getV3Progress() {
-  const learning = getLearningStats();
-
-  // DDD progress based on actual learned patterns
-  // New install: 0 patterns = 0/5 domains, 0% DDD
-  // As patterns grow: 10+ patterns = 1 domain, 50+ = 2, 100+ = 3, 200+ = 4, 500+ = 5
-  let domainsCompleted = 0;
-  if (learning.patterns >= 500) domainsCompleted = 5;
-  else if (learning.patterns >= 200) domainsCompleted = 4;
-  else if (learning.patterns >= 100) domainsCompleted = 3;
-  else if (learning.patterns >= 50) domainsCompleted = 2;
-  else if (learning.patterns >= 10) domainsCompleted = 1;
-
-  const totalDomains = 5;
-  const dddProgress = Math.min(100, Math.floor((domainsCompleted / totalDomains) * 100));
-
-  return {
-    domainsCompleted,
-    totalDomains,
-    dddProgress,
-    patternsLearned: learning.patterns,
-    sessionsCompleted: learning.sessions
-  };
+function getModelFromStdin() {
+  const data = getStdinData();
+  return (data && data.model && data.model.display_name) ? data.model.display_name : null;
 }
 
-// Get security status based on actual scans
-function getSecurityStatus() {
-  // Check for security scan results in memory
-  const scanResultsPath = path.join(process.cwd(), '.claude', 'security-scans');
-  let cvesFixed = 0;
-  const totalCves = 3;
-
-  if (fs.existsSync(scanResultsPath)) {
-    try {
-      const scans = fs.readdirSync(scanResultsPath).filter(f => f.endsWith('.json'));
-      // Each successful scan file = 1 CVE addressed
-      cvesFixed = Math.min(totalCves, scans.length);
-    } catch (e) {
-      // Ignore
-    }
-  }
-
-  // Also check .swarm/security for audit results
-  const auditPath = path.join(process.cwd(), '.swarm', 'security');
-  if (fs.existsSync(auditPath)) {
-    try {
-      const audits = fs.readdirSync(auditPath).filter(f => f.includes('audit'));
-      cvesFixed = Math.min(totalCves, Math.max(cvesFixed, audits.length));
-    } catch (e) {
-      // Ignore
-    }
+function getContextFromStdin() {
+  const data = getStdinData();
+  if (data && data.context_window) {
+    return { usedPct: Math.floor(data.context_window.used_percentage || 0) };
   }
-
-  const status = cvesFixed >= totalCves ? 'CLEAN' : cvesFixed > 0 ? 'IN_PROGRESS' : 'PENDING';
-
-  return {
-    status,
-    cvesFixed,
-    totalCves,
-  };
+  return null;
 }
 
-// Get swarm status
-function getSwarmStatus() {
-  let activeAgents = 0;
-  let coordinationActive = false;
-
-  try {
-    if (isWindows) {
-      // Windows: use tasklist and findstr
-      const ps = execSync('tasklist 2>NUL | findstr /I "agentic-flow" 2>NUL | find /C /V "" 2>NUL || echo 0', { encoding: 'utf-8' });
-      activeAgents = Math.max(0, parseInt(ps.trim()) || 0);
-    } else {
-      const ps = execSync('ps aux 2>/dev/null | grep -c agentic-flow || echo "0"', { encoding: 'utf-8' });
-      activeAgents = Math.max(0, parseInt(ps.trim()) - 1);
-    }
-    coordinationActive = activeAgents > 0;
-  } catch (e) {
-    // Ignore errors - default to 0 agents
+function getCostFromStdin() {
+  const data = getStdinData();
+  if (data && data.cost) {
+    const durationMs = data.cost.total_duration_ms || 0;
+    const mins = Math.floor(durationMs / 60000);
+    const secs = Math.floor((durationMs % 60000) / 1000);
+    return {
+      costUsd: data.cost.total_cost_usd || 0,
+      duration: mins > 0 ? mins + 'm' + secs + 's' : secs + 's',
+    };
   }
-
-  return {
-    activeAgents,
-    maxAgents: CONFIG.maxAgents,
-    coordinationActive,
-  };
+  return null;
 }
 
-// Get system metrics (dynamic based on actual state)
-function getSystemMetrics() {
-  let memoryMB = 0;
-  let subAgents = 0;
-
+// ── Account plan + rate-limit windows (for the plan-aware cost slot) ──────────
+// ~/.claude.json holds only the CURRENTLY active account (overwritten on switch),
+// so we read it live each render — that makes the slot correct across account
+// switches without any stored state. We read a few plan fields, never tokens.
+function readClaudeAccount() {
   try {
-    if (isWindows) {
-      // Windows: use tasklist for memory info, fallback to process.memoryUsage
-      // tasklist memory column is complex to parse, use Node.js API instead
-      memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
-    } else {
-      const mem = execSync('ps aux | grep -E "(node|agentic|claude)" | grep -v grep | awk \'{sum += $6} END {print int(sum/1024)}\'', { encoding: 'utf-8' });
-      memoryMB = parseInt(mem.trim()) || 0;
+    const j = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.claude.json'), 'utf8'));
+    const a = j && j.oauthAccount;
+    if (a && typeof a === 'object') {
+      return { billingType: a.billingType, organizationType: a.organizationType, displayName: a.displayName, organizationName: a.organizationName };
     }
-  } catch (e) {
-    // Fallback
-    memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
-  }
-
-  // Get learning stats for intelligence %
-  const learning = getLearningStats();
-
-  // Intelligence % from REAL intelligence loop data (ADR-050)
-  // Composite: 40% confidence mean + 30% access ratio + 30% pattern density
-  let intelligencePct = 0;
-  if (learning.confidenceMean > 0 || (learning.patterns > 0 && learning.accessedCount > 0)) {
-    const confScore = Math.min(100, Math.floor(learning.confidenceMean * 100));
-    const accessRatio = learning.patterns > 0 ? (learning.accessedCount / learning.patterns) : 0;
-    const accessScore = Math.min(100, Math.floor(accessRatio * 100));
-    const densityScore = Math.min(100, Math.floor(learning.patterns / 5));
-    intelligencePct = Math.floor(confScore * 0.4 + accessScore * 0.3 + densityScore * 0.3);
+  } catch (e) { /* not logged in / unreadable */ }
+  return null;
+}
+function detectPlan(a) {
+  if (!a || typeof a !== 'object') return 'unknown';
+  const b = typeof a.billingType === 'string' ? a.billingType : '';
+  const o = typeof a.organizationType === 'string' ? a.organizationType : '';
+  if (/subscription/i.test(b) || /claude_(max|team|enterprise|pro)/i.test(o)) return 'subscription';
+  if (b) return 'payg';
+  return 'unknown';
+}
+function accountLabel(a) {
+  if (!a) return '';
+  let raw = (typeof a.displayName === 'string' && a.displayName) || (typeof a.organizationName === 'string' && a.organizationName) || '';
+  raw = String(raw).trim();
+  if (!raw) return '';
+  return raw.length > 16 ? raw.slice(0, 15) + '…' : raw;
+}
+function rlToEpochMs(v) {
+  if (typeof v === 'number' && isFinite(v)) return v < 1e12 ? v * 1000 : v;
+  if (typeof v === 'string') { const t = Date.parse(v); return isNaN(t) ? null : t; }
+  return null;
+}
+function rlPickWindow(obj, windowMs, label) {
+  if (!obj || typeof obj !== 'object') return null;
+  const used = (obj.used_percentage != null ? obj.used_percentage : obj.usedPercentage);
+  const resetsAtMs = rlToEpochMs(obj.resets_at != null ? obj.resets_at : obj.resetsAt);
+  if (typeof used !== 'number' || !isFinite(used) || resetsAtMs === null) return null;
+  return { label: label, used: Math.max(0, Math.min(100, used)), windowMs: windowMs, resetsAtMs: resetsAtMs };
+}
+function getRateLimitWindows() {
+  const data = getStdinData();
+  if (!data) return [];
+  const rl = data.rate_limits || data.rateLimits || data;
+  if (!rl || typeof rl !== 'object') return [];
+  const out = [];
+  const w5 = rlPickWindow(rl.five_hour || rl.fiveHour, 5 * 60 * 60 * 1000, '5h');
+  const w7 = rlPickWindow(rl.seven_day || rl.sevenDay, 7 * 24 * 60 * 60 * 1000, '7d');
+  if (w5) out.push(w5);
+  if (w7) out.push(w7);
+  return out;
+}
+function rlWindowStatus(w, nowMs) {
+  if (w.used >= 100) return 'over';
+  const windowStart = w.resetsAtMs - w.windowMs;
+  const elapsed = nowMs - windowStart;
+  let willExhaust = false;
+  if (w.used > 0 && elapsed > 0) {
+    const msTo100 = ((100 - w.used) * elapsed) / w.used;
+    willExhaust = (nowMs + msTo100) <= w.resetsAtMs;
   }
-  // Fallback: legacy pattern count
-  if (intelligencePct === 0 && learning.patterns > 0) {
-    intelligencePct = Math.min(100, Math.floor(learning.patterns / 10));
+  return (willExhaust || w.used >= 80) ? 'warn' : 'ok';
+}
+// { text, color } for the rate-limit cost slot, or null when Claude Code sent
+// no rate_limits payload (older CC / non-subscription session).
+function renderRateLimitSlot() {
+  const wins = getRateLimitWindows();
+  if (wins.length === 0) return null;
+  const now = Date.now();
+  let worst = 'ok';
+  const parts = [];
+  for (const w of wins) {
+    const st = rlWindowStatus(w, now);
+    if (st === 'over') worst = 'over';
+    else if (st === 'warn' && worst !== 'over') worst = 'warn';
+    const mark = st === 'over' ? '!' : st === 'warn' ? '⚠' : '';
+    parts.push(w.label + ' ' + Math.round(w.used) + '%' + mark);
   }
+  const color = worst === 'over' ? c.brightRed : worst === 'warn' ? c.brightYellow : c.brightGreen;
+  return { text: parts.join(' · '), color: color };
+}
 
-  // Context % based on session history
-  const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
-
-  // Count active sub-agents from process list
+// Read package version from the first package.json we find. The fallback
+// (`BAKED_CLI_VERSION`) is the version of @swarmdo/cli that generated THIS
+// statusline.cjs at `swarmdo init` time — so even when every probe below
+// misses, the displayed version is meaningful (matches what the user
+// installed), not a stale hard-coded string.
+function getPkgVersion() {
+  let ver = '1.58.9';
   try {
-    if (isWindows) {
-      // Windows: use tasklist and findstr for agent counting
-      const agents = execSync('tasklist 2>NUL | findstr /I "swarmdo" 2>NUL | find /C /V "" 2>NUL || echo 0', { encoding: 'utf-8' });
-      subAgents = Math.max(0, parseInt(agents.trim()) || 0);
-    } else {
-      const agents = execSync('ps aux 2>/dev/null | grep -c "swarmdo.*agent" || echo "0"', { encoding: 'utf-8' });
-      subAgents = Math.max(0, parseInt(agents.trim()) - 1);
+    const home = os.homedir();
+    const pkgPaths = [
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'swarmdo', 'package.json'),
+      path.join(CWD, 'node_modules', '@swarmdo', 'cli', 'package.json'),
+      path.join(CWD, 'node_modules', 'swarmdo', 'package.json'),
+      path.join(CWD, 'v3', '@swarmdo', 'cli', 'package.json'),
+    ];
+    // #2221: global installs (npm i -g swarmdo) live outside CWD/node_modules, so the
+    // probes above all miss and the version falls back to the hard-coded default.
+    // Derive the global node_modules dir from the running node binary (no npm spawn —
+    // statusline renders often). Covers nvm/mise (bin/../lib/node_modules) and Windows
+    // (bin/node_modules) layouts.
+    try {
+      const binDir = path.dirname(process.execPath);
+      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules'), '/opt/homebrew/lib/node_modules', '/usr/local/lib/node_modules'];
+      // #2221 follow-up: a custom npm prefix (e.g. ~/.npm-global) is decoupled from
+      // the node binary location, so the binDir-derived probes above all miss. Also
+      // probe the npm prefix from the environment and the common ~/.npm-global default.
+      for (const prefix of [process.env.npm_config_prefix, process.env.PREFIX, path.join(home, '.npm-global')]) {
+        if (prefix) globalModuleDirs.push(path.join(prefix, 'lib', 'node_modules'));
+      }
+      for (const gm of globalModuleDirs) {
+        pkgPaths.push(
+          path.join(gm, 'swarmdo', 'package.json'),
+          path.join(gm, '@swarmdo', 'cli', 'package.json'),
+        );
+      }
+    } catch { /* ignore */ }
+    for (const p of pkgPaths) {
+      if (!fs.existsSync(p)) continue;
+      try {
+        const pkg = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (pkg && typeof pkg.version === 'string' && pkg.version.length > 0) { ver = pkg.version; break; }
+      } catch { /* ignore */ }
     }
-  } catch (e) {
-    // Ignore - default to 0
-  }
-
-  return {
-    memoryMB,
-    contextPct,
-    intelligencePct,
-    subAgents,
-  };
+  } catch { /* ignore */ }
+  return ver;
 }
 
-// Generate progress bar
+// ─── Rendering ──────────────────────────────────────────────────
+
 function progressBar(current, total) {
   const width = 5;
   const filled = Math.round((current / total) * width);
-  const empty = width - filled;
-  return '[' + '\u25CF'.repeat(filled) + '\u25CB'.repeat(empty) + ']';
+  return '[' + '●'.repeat(filled) + '○'.repeat(width - filled) + ']';
 }
 
-// Generate full statusline
 function generateStatusline() {
-  const user = getUserInfo();
-  const progress = getV3Progress();
-  const security = getSecurityStatus();
-  const swarm = getSwarmStatus();
-  const system = getSystemMetrics();
+  const d = getStatuslineData();
+  const git = getGitInfo();
+  const modelName = getModelFromStdin() || (d.user && d.user.modelName) || 'Claude Code';
+  const ctxInfo = getContextFromStdin();
+  const costInfo = getCostFromStdin();
+  const pkgVersion = getPkgVersion();
+
+  const progress = d.v3Progress || {};
+  const security = d.security || {};
+  const swarm = d.swarm || {};
+  const system = d.system || {};
+  const adrs = d.adrs || {};
+  const hooks = d.hooks || {};
+  const agentdb = d.agentdb || {};
+  const tests = d.tests || {};
+
+  const domainsCompleted = progress.domainsCompleted || 0;
+  const totalDomains = progress.totalDomains || 5;
+  const dddProgress = progress.dddProgress || 0;
+  const patternsLearned = progress.patternsLearned || 0;
+  const activeSwarms = swarm.activeSwarms || 0;
+  const activeAgents = swarm.activeAgents || 0;
+  const coordinationActive = swarm.coordinationActive || false;
+  const intelligencePct = system.intelligencePct || 0;
+  const memoryMB = system.memoryMB || 0;
+  const secCritHigh = (security.critical || 0) + (security.high || 0);
+  const secStatus = security.status || 'NONE';
+  const secLabel = secStatus === 'VULN' ? 'sec ' + secCritHigh + '!' : secStatus === 'CLEAN' ? 'sec ✓' : secStatus === 'STALE' ? 'sec stale' : 'sec —';
+  const adrCount = adrs.count || 0;
+  const adrImpl = adrs.implemented || 0;
+  const hooksEnabled = hooks.enabled || 0;
+  const hooksTotal = hooks.total || 0;
+  const vectorCount = agentdb.vectorCount || 0;
+  const hasHnsw = agentdb.hasHnsw || false;
+  const dbSizeKB = agentdb.dbSizeKB || 0;
+  const testFiles = tests.testFiles || 0;
+  const testCases = tests.testCases || testFiles * 4;
+
   const lines = [];
 
-  // Header Line
-  let header = `${c.bold}${c.brightPurple}▊ Swarmdo V${SWARMDO_VERSION} ${c.reset}`;
-  header += `${swarm.coordinationActive ? c.brightCyan : c.dim}● ${c.brightCyan}${user.name}${c.reset}`;
-  if (user.gitBranch) {
-    header += `  ${c.dim}│${c.reset}  ${c.brightBlue}⎇ ${user.gitBranch}${c.reset}`;
+  // Header
+  let header = '';
+  if (seg('version')) header += c.bold + c.brightPurple + '▊ Swarmdo V' + pkgVersion + ' ' + c.reset;
+  if (seg('project')) header += (coordinationActive ? c.brightCyan : c.dim) + '● ' + c.brightCyan + git.name + c.reset;
+  if (seg('branch') && git.gitBranch) {
+    header += '  ' + c.dim + '│' + c.reset + '  ' + c.brightBlue + '⏇ ' + git.gitBranch + c.reset;
+    const changes = git.modified + git.staged + git.untracked;
+    if (changes > 0) {
+      let ind = '';
+      if (git.staged > 0) ind += c.brightGreen + '+' + git.staged + c.reset;
+      if (git.modified > 0) ind += c.brightYellow + '~' + git.modified + c.reset;
+      if (git.untracked > 0) ind += c.dim + '?' + git.untracked + c.reset;
+      header += ' ' + ind;
+    }
+    if (git.ahead > 0) header += ' ' + c.brightGreen + '↑' + git.ahead + c.reset;
+    if (git.behind > 0) header += ' ' + c.brightRed + '↓' + git.behind + c.reset;
+  }
+  if (seg('model')) header += '  ' + c.dim + '│' + c.reset + '  ' + c.purple + modelName + c.reset;
+  const duration = costInfo ? costInfo.duration : '';
+  if (seg('duration') && duration) header += '  ' + c.dim + '│' + c.reset + '  ' + c.cyan + '⏱ ' + duration + c.reset;
+  if (seg('context') && ctxInfo && ctxInfo.usedPct > 0) {
+    const ctxColor = ctxInfo.usedPct >= 90 ? c.brightRed : ctxInfo.usedPct >= 70 ? c.brightYellow : c.brightGreen;
+    header += '  ' + c.dim + '│' + c.reset + '  ' + ctxColor + '● ' + ctxInfo.usedPct + '% ctx' + c.reset;
+  }
+  if (seg('cost') && COST_OPTS.mode !== 'off') {
+    const acct = readClaudeAccount();
+    let eff = COST_OPTS.mode;
+    if (eff === 'auto') eff = detectPlan(acct) === 'subscription' ? 'limits' : 'dollars';
+    let slotText = null;
+    let slotColor = c.brightYellow;
+    if (eff === 'limits') {
+      const rl = renderRateLimitSlot();
+      if (rl) { slotText = rl.text; slotColor = rl.color; }
+      else if (costInfo && costInfo.costUsd > 0) { slotText = CONFIG.costSymbol + costInfo.costUsd.toFixed(2); } // no payload → $ fallback
+    } else if (costInfo && costInfo.costUsd > 0) {
+      slotText = CONFIG.costSymbol + costInfo.costUsd.toFixed(2);
+    }
+    if (slotText) {
+      let prefix = '';
+      if (COST_OPTS.showAccount) { const lbl = accountLabel(acct); if (lbl) prefix = c.dim + lbl + ' · ' + c.reset; }
+      header += '  ' + c.dim + '│' + c.reset + '  ' + prefix + slotColor + slotText + c.reset;
+    }
   }
-  header += `  ${c.dim}│${c.reset}  ${c.purple}${user.modelName}${c.reset}`;
-  lines.push(header);
-
-  // Separator
-  lines.push(`${c.dim}─────────────────────────────────────────────────────${c.reset}`);
-
-  // Line 1: DDD Domain Progress
-  const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
-  lines.push(
-    `${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
-    `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ` +
-    `${c.brightYellow}⚡ 1.0x${c.reset} ${c.dim}→${c.reset} ${c.brightYellow}2.49x-7.47x${c.reset}`
+  if (header) lines.push(header);
+
+  // Separator — only when a body section follows a rendered header
+  const anyBody = seg('domains') || seg('swarm') || seg('architecture') || seg('agentdb');
+  if (header && anyBody) lines.push(c.dim + '─'.repeat(53) + c.reset);
+
+  // Line 1: DDD Domains
+  const domainsColor = domainsCompleted >= 3 ? c.brightGreen : domainsCompleted > 0 ? c.yellow : c.red;
+  let perfIndicator;
+  if (hasHnsw && vectorCount > 0) {
+    const speedup = vectorCount > 10000 ? '12500x' : vectorCount > 1000 ? '150x' : '10x';
+    perfIndicator = c.brightGreen + '⚡ HNSW ' + speedup + c.reset;
+  } else if (patternsLearned > 0) {
+    const pk = patternsLearned >= 1000 ? (patternsLearned / 1000).toFixed(1) + 'k' : String(patternsLearned);
+    perfIndicator = c.brightYellow + '📚 ' + pk + ' patterns' + c.reset;
+  } else {
+    perfIndicator = c.dim + '⚡ target: 150x-12500x' + c.reset;
+  }
+  if (seg('domains')) lines.push(
+    c.brightCyan + '🏗️  DDD Domains' + c.reset + '    ' + progressBar(domainsCompleted, totalDomains) + '  ' +
+    domainsColor + domainsCompleted + c.reset + '/' + c.brightWhite + totalDomains + c.reset + '    ' + perfIndicator
+  );
+
+  // Line 2: Swarm + Hooks + CVE + Memory + Intelligence
+  const swarmsColor = activeSwarms > 0 ? c.brightGreen : c.dim;
+  const agentsColor = activeAgents > 0 ? c.brightGreen : c.dim;
+  const secIcon = secStatus === 'CLEAN' ? '🟢' : secStatus === 'STALE' ? '🟡' : (secStatus === 'NONE' ? '⚪' : '🔴');
+  const secColor = secStatus === 'CLEAN' ? c.brightGreen : secStatus === 'STALE' ? c.brightYellow : (secStatus === 'NONE' ? c.dim : c.brightRed);
+  const hooksColor = hooksEnabled > 0 ? c.brightGreen : c.dim;
+  const intellColor = intelligencePct >= 80 ? c.brightGreen : intelligencePct >= 40 ? c.brightYellow : c.dim;
+
+  if (seg('swarm')) lines.push(
+    c.brightYellow + '🐝 Swarms' + c.reset + ' ' + swarmsColor + activeSwarms + c.reset + '    ' +
+    c.brightYellow + '🤖 Agents' + c.reset + ' ' + agentsColor + activeAgents + c.reset + '    ' +
+    c.brightBlue + '🪝 ' + hooksColor + hooksEnabled + c.reset + '/' + c.brightWhite + hooksTotal + c.reset + '    ' +
+    secIcon + ' ' + secColor + secLabel + c.reset + '    ' +
+    c.brightCyan + '💾 ' + memoryMB + 'MB' + c.reset + '    ' +
+    intellColor + '🧠 ' + String(intelligencePct).padStart(3) + '%' + c.reset
   );
 
-  // Line 2: Swarm + CVE + Memory + Context + Intelligence
-  const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
-  const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
-  let securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
-  let securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
-
-  lines.push(
-    `${c.brightYellow}🤖 Swarm${c.reset}  ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
-    `${c.brightPurple}👥 ${system.subAgents}${c.reset}    ` +
-    `${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset}    ` +
-    `${c.brightCyan}💾 ${system.memoryMB}MB${c.reset}    ` +
-    `${c.brightGreen}📂 ${String(system.contextPct).padStart(3)}%${c.reset}    ` +
-    `${c.dim}🧠 ${String(system.intelligencePct).padStart(3)}%${c.reset}`
+  // Line 3: Architecture
+  const dddColor = dddProgress >= 50 ? c.brightGreen : dddProgress > 0 ? c.yellow : c.red;
+  const adrColor = adrCount > 0 ? (adrImpl === adrCount ? c.brightGreen : c.yellow) : c.dim;
+  const adrDisplay = adrColor + '●' + adrImpl + '/' + adrCount + c.reset;
+
+  if (seg('architecture')) lines.push(
+    c.brightPurple + '🔧 Architecture' + c.reset + '    ' +
+    c.cyan + 'ADRs' + c.reset + ' ' + adrDisplay + '  ' + c.dim + '│' + c.reset + '  ' +
+    c.cyan + 'DDD' + c.reset + ' ' + dddColor + '●' + String(dddProgress).padStart(3) + '%' + c.reset + '  ' + c.dim + '│' + c.reset + '  ' +
+    c.cyan + 'Security' + c.reset + ' ' + secColor + '●' + secStatus + c.reset
   );
 
-  // Line 3: Architecture status
-  const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
-  lines.push(
-    `${c.brightPurple}🔧 Architecture${c.reset}    ` +
-    `${c.cyan}DDD${c.reset} ${dddColor}●${String(progress.dddProgress).padStart(3)}%${c.reset}  ${c.dim}│${c.reset}  ` +
-    `${c.cyan}Security${c.reset} ${securityColor}●${security.status}${c.reset}  ${c.dim}│${c.reset}  ` +
-    `${c.cyan}Memory${c.reset} ${c.brightGreen}●AgentDB${c.reset}  ${c.dim}│${c.reset}  ` +
-    `${c.cyan}Integration${c.reset} ${swarm.coordinationActive ? c.brightCyan : c.dim}●${c.reset}`
+  // Line 4: AgentDB, Tests, Integration
+  const hnswInd = hasHnsw ? c.brightGreen + '⚡' + c.reset : '';
+  const sizeDisp = dbSizeKB >= 1024 ? (dbSizeKB / 1024).toFixed(1) + 'MB' : dbSizeKB + 'KB';
+  const vectorColor = vectorCount > 0 ? c.brightGreen : c.dim;
+  const testColor = testFiles > 0 ? c.brightGreen : c.dim;
+
+  // MCP / DB integration from data
+  const integration = d.integration || {};
+  const mcpServers = (integration.mcpServers) || {};
+  let integStr = '';
+  if (mcpServers.total > 0) {
+    const mcpCol = mcpServers.enabled === mcpServers.total ? c.brightGreen : mcpServers.enabled > 0 ? c.brightYellow : c.red;
+    integStr += c.cyan + 'MCP' + c.reset + ' ' + mcpCol + '●' + mcpServers.enabled + '/' + mcpServers.total + c.reset;
+  }
+  if (integration.hasDatabase) integStr += (integStr ? '  ' : '') + c.brightGreen + '◆' + c.reset + 'DB';
+  if (!integStr) integStr = c.dim + '● none' + c.reset;
+
+  if (seg('agentdb')) lines.push(
+    c.brightCyan + '📊 AgentDB' + c.reset + '    ' +
+    c.cyan + 'Vectors' + c.reset + ' ' + vectorColor + '●' + vectorCount + hnswInd + c.reset + '  ' + c.dim + '│' + c.reset + '  ' +
+    c.cyan + 'Size' + c.reset + ' ' + c.brightWhite + sizeDisp + c.reset + '  ' + c.dim + '│' + c.reset + '  ' +
+    c.cyan + 'Tests' + c.reset + ' ' + testColor + '●' + testFiles + c.reset + ' ' + c.dim + '(~' + testCases + ' cases)' + c.reset + '  ' + c.dim + '│' + c.reset + '  ' +
+    integStr
   );
 
   return lines.join('\n');
 }
 
-// Generate JSON data
+// JSON output — delegates to CLI for accuracy; caller can use --json flag
 function generateJSON() {
-  return {
-    user: getUserInfo(),
-    v3Progress: getV3Progress(),
-    security: getSecurityStatus(),
-    swarm: getSwarmStatus(),
-    system: getSystemMetrics(),
-    performance: {
-      flashAttentionTarget: '2.49x-7.47x',
-      searchImprovement: '150x-12,500x',
-      memoryReduction: '50-75%',
-    },
+  const d = getStatuslineData();
+  const git = getGitInfo();
+  return Object.assign({}, d, {
+    user: Object.assign({ name: git.name, gitBranch: git.gitBranch }, d.user || {}),
+    git: { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
     lastUpdated: new Date().toISOString(),
-  };
+  });
 }
 
-/**
- * Generate single-line output for Claude Code compatibility
- * This avoids the collision zone issue entirely by using one line
- * @see the upstream project (see NOTICE)
- */
-function generateSingleLine() {
-  if (!CONFIG.enabled) return '';
-
-  const user = getUserInfo();
-  const progress = getV3Progress();
-  const security = getSecurityStatus();
-  const swarm = getSwarmStatus();
-  const system = getSystemMetrics();
-
-  const swarmIndicator = swarm.coordinationActive ? '●' : '○';
-  const securityStatus = security.status === 'CLEAN' ? '✓' :
-                         security.cvesFixed > 0 ? '~' : '✗';
-
-  return `${c.brightPurple}Swarmdo${c.reset} ${c.dim}|${c.reset} ` +
-    `${c.cyan}D:${progress.domainsCompleted}/${progress.totalDomains}${c.reset} ${c.dim}|${c.reset} ` +
-    `${c.yellow}S:${swarmIndicator}${swarm.activeAgents}/${swarm.maxAgents}${c.reset} ${c.dim}|${c.reset} ` +
-    `${security.status === 'CLEAN' ? c.green : c.red}CVE:${securityStatus}${security.cvesFixed}/${security.totalCves}${c.reset} ${c.dim}|${c.reset} ` +
-    `${c.dim}🧠${system.intelligencePct}%${c.reset}`;
-}
-
-/**
- * Generate safe multi-line statusline that avoids Claude Code collision zone
- * The collision zone is columns 15-25 on the second-to-last line.
- * We pad that line with spaces to push content past column 25.
- * @see the upstream project (see NOTICE)
- */
-function generateSafeStatusline() {
-  if (!CONFIG.enabled) return '';
-
-  const user = getUserInfo();
-  const progress = getV3Progress();
-  const security = getSecurityStatus();
-  const swarm = getSwarmStatus();
-  const system = getSystemMetrics();
-  const lines = [];
-
-  // Header Line
-  let header = `${c.bold}${c.brightPurple}▊ Swarmdo V${SWARMDO_VERSION} ${c.reset}`;
-  header += `${swarm.coordinationActive ? c.brightCyan : c.dim}● ${c.brightCyan}${user.name}${c.reset}`;
-  if (user.gitBranch) {
-    header += `  ${c.dim}│${c.reset}  ${c.brightBlue}⎇ ${user.gitBranch}${c.reset}`;
-  }
-  header += `  ${c.dim}│${c.reset}  ${c.purple}${user.modelName}${c.reset}`;
-  lines.push(header);
-
-  // Separator
-  lines.push(`${c.dim}─────────────────────────────────────────────────────${c.reset}`);
-
-  // Line 1: DDD Domain Progress
-  const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
-  lines.push(
-    `${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
-    `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ` +
-    `${c.brightYellow}⚡ 1.0x${c.reset} ${c.dim}→${c.reset} ${c.brightYellow}2.49x-7.47x${c.reset}`
-  );
-
-  // Line 2 (COLLISION LINE): Swarm status with padding after label
-  // The emoji+label is ~10 columns. Padding pushes content past collision zone (cols 15-25)
-  const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
-  const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
-  let securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
-  let securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
-
-  // Padding after "🤖 Swarm" (emoji 2 cols + " Swarm" 6 cols = 8, pad 18 to reach col 26)
-  lines.push(
-    `${c.brightYellow}🤖 Swarm${c.reset}                  ` +  // 18 spaces padding
-    `${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
-    `${c.brightPurple}👥 ${system.subAgents}${c.reset}  ` +
-    `${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset}  ` +
-    `${c.brightCyan}💾 ${system.memoryMB}MB${c.reset}  ` +
-    `${c.dim}🧠 ${system.intelligencePct}%${c.reset}`
-  );
-
-  // Line 3: Architecture status (this is the last line, not in collision zone)
-  const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
-  lines.push(
-    `${c.brightPurple}🔧 Architecture${c.reset}    ` +
-    `${c.cyan}DDD${c.reset} ${dddColor}●${String(progress.dddProgress).padStart(3)}%${c.reset}  ${c.dim}│${c.reset}  ` +
-    `${c.cyan}Security${c.reset} ${securityColor}●${security.status}${c.reset}  ${c.dim}│${c.reset}  ` +
-    `${c.cyan}Memory${c.reset} ${c.brightGreen}●AgentDB${c.reset}  ${c.dim}│${c.reset}  ` +
-    `${c.cyan}Integration${c.reset} ${swarm.coordinationActive ? c.brightCyan : c.dim}●${c.reset}`
-  );
-
-  return lines.join('\n');
-}
-
-// Main
+// ─── Main ───────────────────────────────────────────────────────
 if (process.argv.includes('--json')) {
   console.log(JSON.stringify(generateJSON(), null, 2));
 } else if (process.argv.includes('--compact')) {
   console.log(JSON.stringify(generateJSON()));
-} else if (process.argv.includes('--single')) {
-  // Single-line mode - completely avoids collision zone
-  console.log(generateSingleLine());
-} else if (process.argv.includes('--unsafe') || process.argv.includes('--legacy')) {
-  // Legacy mode - original multi-line without collision avoidance
-  console.log(generateStatusline());
 } else {
-  // Default: Safe multi-line mode with collision zone avoidance
-  // Use --unsafe or --legacy to get the original behavior
-  console.log(generateSafeStatusline());
+  console.log(generateStatusline());
 }