@claude-flow/cli 3.10.3 → 3.10.5

package/dist/src/init/statusline-generator.js

@@ -23,17 +23,23 @@ export function generateStatuslineScript(options) {
     const maxAgents = options.runtime.maxAgents;
     return `#!/usr/bin/env node
 /**
- * RuFlo V3 Statusline Generator (Optimized)
- * Displays real-time V3 implementation progress and system status
+ * RuFlo V3 Statusline — delegation build (#2195)
  *
- * Usage: node statusline.cjs [--json] [--compact]
+ * Fix for ruvnet/ruflo#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.
  *
- * Performance notes:
- * - Single git execSync call (combines branch + status + upstream)
- * - No recursive file reading (only stat/readdir, never read test contents)
- * - No ps aux calls (uses process.memoryUsage() + file-based metrics)
- * - Strict 2s timeout on all execSync calls
- * - Shared settings cache across functions
+ * This version delegates to 'npx @claude-flow/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.
+ *
+ * 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/).
+ *
+ * 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 */
@@ -49,6 +55,120 @@ const CONFIG = {
 
 const CWD = process.cwd();
 
+// ─── Delegation cache ───────────────────────────────────────────
+// Cache the CLI JSON result for 10s so rapid prompt re-renders
+// (e.g. every keypress in some shells) don't re-invoke npx each time.
+const CACHE_FILE = path.join(os.tmpdir(), 'ruflo-statusline-cache-' + require('crypto').createHash('md5').update(CWD).digest('hex').slice(0, 8) + '.json');
+const CACHE_TTL_MS = 10000;
+
+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 ruflo#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() {
+  const cached = readCache();
+  if (cached) return cached;
+
+  try {
+    const raw = execSync(
+      'npx --yes @claude-flow/cli@latest hooks statusline --json 2>/dev/null',
+      { 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 real ADR count from both local directories (fast, no network).
+    data.adrs = getLocalADRCount();
+    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 ruflo#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, '.claude-flow', '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 };
+}
+
+// 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);
+  const adrs = getLocalADRCount();
+
+  // Test file count (pure directory walk, no file reads)
+  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 {
+    user: { name: 'user', gitBranch: '', modelName: 'Claude Code' },
+    v3Progress: { domainsCompleted: 0, totalDomains: 5, dddProgress: 0, patternsLearned: 0, sessionsCompleted: 0 },
+    security: { status: 'NONE', cvesFixed: 0, totalCves: 0 },
+    swarm: { activeAgents: 0, maxAgents: CONFIG.maxAgents, coordinationActive: false },
+    system: { memoryMB: memMB, contextPct: 0, intelligencePct: 0, subAgents: 0 },
+    adrs,
+    hooks: { enabled: 0, total: 0 },
+    agentdb: { vectorCount: 0, dbSizeKB: 0, hasHnsw: false },
+    tests: { testFiles, testCases: testFiles * 4 },
+    lastUpdated: new Date().toISOString(),
+  };
+}
+
 // ANSI colors
 const c = {
   reset: '\\x1b[0m',
@@ -70,11 +190,11 @@ const c = {
 };
 
 // Safe execSync with strict timeout (returns empty string on failure)
-function safeExec(cmd, timeoutMs = 2000) {
+function safeExec(cmd, timeoutMs) {
   try {
     return execSync(cmd, {
       encoding: 'utf-8',
-      timeout: timeoutMs,
+      timeout: timeoutMs || 2000,
       stdio: ['pipe', 'pipe', 'pipe'],
     }).trim();
   } catch {
@@ -92,34 +212,14 @@ function readJSON(filePath) {
   return null;
 }
 
-// Safe file stat (returns null on failure)
-function safeStat(filePath) {
-  try {
-    return fs.statSync(filePath);
-  } catch { /* ignore */ }
-  return null;
-}
+// ─── Git info (pure-Node / single exec — needed for branch display) ──────────
 
-// Shared settings cache — read once, used by multiple functions
-let _settingsCache = undefined;
-function getSettings() {
-  if (_settingsCache !== undefined) return _settingsCache;
-  _settingsCache = readJSON(path.join(CWD, '.claude', 'settings.json'))
-                || readJSON(path.join(CWD, '.claude', 'settings.local.json'))
-                || null;
-  return _settingsCache;
-}
-
-// ─── Data Collection (all pure-Node.js or single-exec) ──────────
-
-// Get all git info in ONE shell call
 function getGitInfo() {
   const result = {
     name: 'user', gitBranch: '', modified: 0, untracked: 0,
     staged: 0, ahead: 0, behind: 0,
   };
 
-  // Single shell: get user.name, branch, porcelain status, and upstream diff
   const script = [
     'git config user.name 2>/dev/null || echo user',
     'echo "---SEP---"',
@@ -133,12 +233,11 @@ function getGitInfo() {
   const raw = safeExec("sh -c '" + script + "'", 3000);
   if (!raw) return result;
 
-  const parts = raw.split('---SEP---').map(s => s.trim());
+  const parts = raw.split('---SEP---').map(function(s) { return s.trim(); });
   if (parts.length >= 4) {
     result.name = parts[0] || 'user';
     result.gitBranch = parts[1] || '';
 
-    // Parse porcelain status
     if (parts[2]) {
       for (const line of parts[2].split('\\n')) {
         if (!line || line.length < 2) continue;
@@ -149,7 +248,6 @@ function getGitInfo() {
       }
     }
 
-    // Parse ahead/behind
     const ab = (parts[3] || '0 0').split(/\\s+/);
     result.ahead = parseInt(ab[0]) || 0;
     result.behind = parseInt(ab[1]) || 0;
@@ -198,450 +296,78 @@ function getModelName() {
   return 'Claude Code';
 }
 
-// Get learning stats from real data sources (no heuristics)
-function getLearningStats() {
-  let patterns = 0;
-  let sessions = 0;
-
-  // 1. Count real patterns from intelligence pattern store
-  const patternStorePath = path.join(CWD, '.claude-flow', 'data', 'patterns.json');
-  try {
-    if (fs.existsSync(patternStorePath)) {
-      const data = JSON.parse(fs.readFileSync(patternStorePath, 'utf-8'));
-      if (Array.isArray(data)) patterns = data.length;
-      else if (data && data.patterns) patterns = Array.isArray(data.patterns) ? data.patterns.length : Object.keys(data.patterns).length;
-    }
-  } catch { /* ignore */ }
-
-  // 2. Count patterns from auto-memory-store (real entries, not file size)
-  if (patterns === 0) {
-    const autoStorePath = path.join(CWD, '.claude-flow', 'data', 'auto-memory-store.json');
-    try {
-      if (fs.existsSync(autoStorePath)) {
-        const data = JSON.parse(fs.readFileSync(autoStorePath, 'utf-8'));
-        if (Array.isArray(data)) patterns = data.length;
-        else if (data && data.entries) patterns = data.entries.length;
-      }
-    } catch { /* ignore */ }
-  }
-
-  // 3. Count patterns from memory.db using row count (sqlite header bytes 28-31).
-  //
-  // ruflo#1989: when encryption at rest is enabled, memory.db is no
-  // longer a SQLite database -- it is an RFE1-magicked ciphertext blob.
-  // The original code blindly read bytes 28-31 as a page count and
-  // rendered 3.3B patterns (uint32 of random ciphertext). That
-  // cascaded into fake DDD 5/5 / 100% indicators downstream.
-  //
-  // Guard with the SQLite magic ("SQLite format 3\\0", 16 bytes at
-  // offset 0). Also clamp implausible page counts (>1M pages ~= 4GB)
-  // to avoid reporting nonsense even on plaintext SQLite.
-  if (patterns === 0) {
-    const SQLITE_MAGIC = Buffer.from('SQLite format 3\\0', 'binary');
-    const memoryPaths = [
-      path.join(CWD, '.claude-flow', 'memory.db'),
-      path.join(CWD, 'data', 'memory.db'),
-      path.join(CWD, '.swarm', 'memory.db'),
-    ];
-    for (const dbPath of memoryPaths) {
-      try {
-        if (!fs.existsSync(dbPath)) continue;
-        const fd = fs.openSync(dbPath, 'r');
-        const head = Buffer.alloc(16);
-        fs.readSync(fd, head, 0, 16, 0);
-        if (!head.equals(SQLITE_MAGIC)) {
-          // Not plaintext SQLite (likely RFE1 encrypted, an empty
-          // file, or some other format). Skip — let the daemon or
-          // patterns.json fallback report the real number.
-          fs.closeSync(fd);
-          continue;
-        }
-        const buf = Buffer.alloc(4);
-        fs.readSync(fd, buf, 0, 4, 28);
-        fs.closeSync(fd);
-        const pageCount = buf.readUInt32BE(0);
-        // Sanity: reject implausible counts (> 1M pages ≈ 4 GB DB).
-        if (pageCount > 1_000_000) continue;
-        // Each page typically holds ~10-50 rows; use page count as
-        // conservative estimate. Report 0 if only schema pages (< 3).
-        patterns = pageCount > 2 ? pageCount - 2 : 0;
-        break;
-      } catch { /* ignore */ }
-    }
-  }
-
-  // 4. Count real session files
+// ─── 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 {
-    const sessDir = path.join(CWD, '.claude', 'sessions');
-    if (fs.existsSync(sessDir)) {
-      sessions = fs.readdirSync(sessDir).filter(f => f.endsWith('.json')).length;
-    }
-  } catch { /* ignore */ }
-
-  // 5. Count session files from claude-flow
-  if (sessions === 0) {
+    if (process.stdin.isTTY) { _stdinData = null; return null; }
+    const chunks = [];
+    const buf = Buffer.alloc(4096);
+    let bytesRead;
     try {
-      const cfSessDir = path.join(CWD, '.claude-flow', 'sessions');
-      if (fs.existsSync(cfSessDir)) {
-        sessions = fs.readdirSync(cfSessDir).filter(f => f.endsWith('.json')).length;
+      while ((bytesRead = fs.readSync(0, buf, 0, buf.length, null)) > 0) {
+        chunks.push(buf.slice(0, bytesRead));
       }
-    } catch { /* ignore */ }
+    } 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;
   }
+  return _stdinData;
+}
 
-  return { patterns, sessions };
+function getModelFromStdin() {
+  const data = getStdinData();
+  return (data && data.model && data.model.display_name) ? data.model.display_name : null;
 }
 
-// V3 progress from metrics files (pure file reads)
-function getV3Progress() {
-  const learning = getLearningStats();
-  const totalDomains = 5;
-
-  const dddData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'ddd-progress.json'));
-  let dddProgress = dddData ? (dddData.progress || 0) : 0;
-  let domainsCompleted = Math.min(5, Math.floor(dddProgress / 20));
-
-  // Only derive DDD progress from real ddd-progress.json or real pattern data
-  // Don't inflate domains from pattern count — 0 means no DDD work tracked.
-  // ruflo#1989: defensively clamp learning.patterns even though
-  // getLearningStats already guards against the RFE1-encrypted case --
-  // if any future regression in the upstream reader returns a wild
-  // value, we do not want to silently inflate DDD to 5/5 / 100%.
-  const realPatterns = Number.isFinite(learning.patterns) && learning.patterns >= 0 && learning.patterns < 1_000_000
-    ? learning.patterns
-    : 0;
-  if (dddProgress === 0 && realPatterns > 0) {
-    // Conservative: only count domains if we have substantial real pattern data
-    // Each domain requires ~100 real stored patterns to claim completion
-    domainsCompleted = Math.min(5, Math.floor(realPatterns / 100));
-    dddProgress = Math.floor((domainsCompleted / totalDomains) * 100);
+function getContextFromStdin() {
+  const data = getStdinData();
+  if (data && data.context_window) {
+    return { usedPct: Math.floor(data.context_window.used_percentage || 0) };
   }
-
-  return {
-    domainsCompleted, totalDomains, dddProgress,
-    patternsLearned: realPatterns,
-    sessionsCompleted: learning.sessions,
-  };
+  return null;
 }
 
-// Security status (pure file reads)
-function getSecurityStatus() {
-  const auditData = readJSON(path.join(CWD, '.claude-flow', 'security', 'audit-status.json'));
-  if (auditData) {
-    const auditDate = auditData.lastAudit || auditData.lastScan;
-    if (!auditDate) {
-      return { status: 'PENDING', cvesFixed: 0, totalCves: 0 };
-    }
-    const auditAge = Date.now() - new Date(auditDate).getTime();
-    const isStale = auditAge > 7 * 24 * 60 * 60 * 1000;
+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 {
-      status: isStale ? 'STALE' : (auditData.status || 'PENDING'),
-      cvesFixed: auditData.cvesFixed || 0,
-      totalCves: auditData.totalCves || 0,
+      costUsd: data.cost.total_cost_usd || 0,
+      duration: mins > 0 ? mins + 'm' + secs + 's' : secs + 's',
     };
   }
-
-  let scanCount = 0;
-  try {
-    const scanDir = path.join(CWD, '.claude', 'security-scans');
-    if (fs.existsSync(scanDir)) {
-      scanCount = fs.readdirSync(scanDir).filter(f => f.endsWith('.json')).length;
-    }
-  } catch { /* ignore */ }
-
-  return {
-    status: scanCount > 0 ? 'SCANNED' : 'NONE',
-    cvesFixed: 0,
-    totalCves: 0,
-  };
-}
-
-// Swarm status (pure file reads, NO ps aux)
-function getSwarmStatus() {
-  const staleThresholdMs = 5 * 60 * 1000;
-  const now = Date.now();
-
-  const swarmStatePath = path.join(CWD, '.claude-flow', 'swarm', 'swarm-state.json');
-  const swarmState = readJSON(swarmStatePath);
-  if (swarmState) {
-    const updatedAt = swarmState.updatedAt || swarmState.startedAt;
-    const age = updatedAt ? now - new Date(updatedAt).getTime() : Infinity;
-    if (age < staleThresholdMs) {
-      return {
-        activeAgents: (swarmState.agents && swarmState.agents.length) || swarmState.agentCount || 0,
-        maxAgents: swarmState.maxAgents || CONFIG.maxAgents,
-        coordinationActive: true,
-      };
-    }
-  }
-
-  const activityData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'swarm-activity.json'));
-  if (activityData && activityData.swarm) {
-    const updatedAt = activityData.timestamp || (activityData.swarm && activityData.swarm.timestamp);
-    const age = updatedAt ? now - new Date(updatedAt).getTime() : Infinity;
-    if (age < staleThresholdMs) {
-      return {
-        activeAgents: activityData.swarm.agent_count || 0,
-        maxAgents: CONFIG.maxAgents,
-        coordinationActive: activityData.swarm.coordination_active || activityData.swarm.active || false,
-      };
-    }
-  }
-
-  return { activeAgents: 0, maxAgents: CONFIG.maxAgents, coordinationActive: false };
-}
-
-// System metrics (uses process.memoryUsage() — no shell spawn)
-function getSystemMetrics() {
-  const memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
-  const learning = getLearningStats();
-  const agentdb = getAgentDBStats();
-
-  // Intelligence from learning.json
-  const learningData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'learning.json'));
-  let intelligencePct = 0;
-  let contextPct = 0;
-
-  if (learningData && learningData.intelligence && learningData.intelligence.score !== undefined) {
-    intelligencePct = Math.min(100, Math.floor(learningData.intelligence.score));
-  } else {
-    // Use real data only — patterns from actual store, vectors from actual DB.
-    // ruflo#1989: clamp patterns to a sane upper bound. A multi-billion
-    // pattern count from a buggy reader would saturate intelligencePct
-    // to 100% and silently lie about progress.
-    const realPatterns = Number.isFinite(learning.patterns) && learning.patterns >= 0 && learning.patterns < 1_000_000
-      ? learning.patterns
-      : 0;
-    const fromPatterns = realPatterns > 0 ? Math.min(100, Math.floor(realPatterns / 20)) : 0;
-    const fromVectors = agentdb.vectorCount > 0 ? Math.min(100, Math.floor(agentdb.vectorCount / 20)) : 0;
-    intelligencePct = Math.max(fromPatterns, fromVectors);
-  }
-  // No fake fallback — 0% means no real learning data exists
-
-  if (learningData && learningData.sessions && learningData.sessions.total !== undefined) {
-    contextPct = Math.min(100, learningData.sessions.total * 5);
-  } else {
-    // Real session count only — no heuristic derivation from patterns
-    contextPct = learning.sessions > 0 ? Math.min(100, learning.sessions * 5) : 0;
-  }
-
-  // Sub-agents from file metrics (no ps aux)
-  let subAgents = 0;
-  const activityData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'swarm-activity.json'));
-  if (activityData && activityData.processes && activityData.processes.estimated_agents) {
-    subAgents = activityData.processes.estimated_agents;
-  }
-
-  return { memoryMB, contextPct, intelligencePct, subAgents };
-}
-
-// ADR status (count files only — don't read contents)
-function getADRStatus() {
-  // Count actual ADR files first — compliance JSON may be stale
-  const adrPaths = [
-    path.join(CWD, 'v3', 'implementation', 'adrs'),
-    path.join(CWD, 'docs', 'adrs'),
-    path.join(CWD, '.claude-flow', 'adrs'),
-  ];
-
-  for (const adrPath of adrPaths) {
-    try {
-      if (fs.existsSync(adrPath)) {
-        const files = fs.readdirSync(adrPath).filter(f =>
-          f.endsWith('.md') && (f.startsWith('ADR-') || f.startsWith('adr-') || /^\\d{4}-/.test(f))
-        );
-        return { count: files.length, implemented: files.length, compliance: 0 };
-      }
-    } catch { /* ignore */ }
-  }
-
-  return { count: 0, implemented: 0, compliance: 0 };
-}
-
-// Hooks status (shared settings cache)
-function getHooksStatus() {
-  let enabled = 0;
-  let total = 0;
-  const settings = getSettings();
-
-  if (settings && settings.hooks) {
-    for (const category of Object.keys(settings.hooks)) {
-      const matchers = settings.hooks[category];
-      if (!Array.isArray(matchers)) continue;
-      for (const matcher of matchers) {
-        const hooks = matcher && matcher.hooks;
-        if (Array.isArray(hooks)) {
-          total += hooks.length;
-          enabled += hooks.length;
-        }
-      }
-    }
-  }
-
-  try {
-    const hooksDir = path.join(CWD, '.claude', 'hooks');
-    if (fs.existsSync(hooksDir)) {
-      const hookFiles = fs.readdirSync(hooksDir).filter(f => f.endsWith('.js') || f.endsWith('.sh')).length;
-      total = Math.max(total, hookFiles);
-      enabled = Math.max(enabled, hookFiles);
-    }
-  } catch { /* ignore */ }
-
-  return { enabled, total };
+  return null;
 }
 
-// AgentDB stats — count real entries from all data stores
-function getAgentDBStats() {
-  let vectorCount = 0;
-  let dbSizeKB = 0;
-  let namespaces = 0;
-  let hasHnsw = false;
-
-  // 1. Count real entries from auto-memory-store.json
-  const storePath = path.join(CWD, '.claude-flow', 'data', 'auto-memory-store.json');
-  const storeStat = safeStat(storePath);
-  if (storeStat) {
-    dbSizeKB += storeStat.size / 1024;
-    try {
-      const store = JSON.parse(fs.readFileSync(storePath, 'utf-8'));
-      if (Array.isArray(store)) vectorCount += store.length;
-      else if (store && store.entries) vectorCount += store.entries.length;
-    } catch { /* fall back */ }
-  }
-
-  // 2. Count entries from hooks memory store (.claude-flow/memory/store.json)
-  const hooksStorePath = path.join(CWD, '.claude-flow', 'memory', 'store.json');
-  const hooksStoreStat = safeStat(hooksStorePath);
-  if (hooksStoreStat) {
-    dbSizeKB += hooksStoreStat.size / 1024;
-    try {
-      const store = JSON.parse(fs.readFileSync(hooksStorePath, 'utf-8'));
-      if (store && store.entries) {
-        const entryCount = Object.keys(store.entries).length;
-        vectorCount = Math.max(vectorCount, entryCount);
-        if (entryCount > 0) namespaces++;
-      }
-    } catch { /* fall back */ }
-  }
-
-  // 3. Count entries from ranked-context.json
+// Read package version from the first package.json we find.
+function getPkgVersion() {
+  let ver = '3.6';
   try {
-    const ranked = readJSON(path.join(CWD, '.claude-flow', 'data', 'ranked-context.json'));
-    if (ranked && ranked.entries && ranked.entries.length > vectorCount) vectorCount = ranked.entries.length;
-  } catch { /* ignore */ }
-
-  // 3. Add DB file sizes
-  const dbFiles = [
-    path.join(CWD, 'data', 'memory.db'),
-    path.join(CWD, '.claude-flow', 'memory.db'),
-    path.join(CWD, '.swarm', 'memory.db'),
-  ];
-  for (const f of dbFiles) {
-    const stat = safeStat(f);
-    if (stat) {
-      dbSizeKB += stat.size / 1024;
-      namespaces++;
-    }
-  }
-
-  // 4. Graph data size
-  const graphStat = safeStat(path.join(CWD, 'data', 'memory.graph'));
-  if (graphStat) dbSizeKB += graphStat.size / 1024;
-
-  // 5. HNSW index or memory package
-  const hnswPaths = [
-    path.join(CWD, '.swarm', 'hnsw.index'),
-    path.join(CWD, '.claude-flow', 'hnsw.index'),
-  ];
-  for (const p of hnswPaths) {
-    if (safeStat(p)) { hasHnsw = true; break; }
-  }
-  if (!hasHnsw) {
-    const memPkgPaths = [
-      path.join(CWD, 'v3', '@claude-flow', 'memory', 'dist'),
-      path.join(CWD, 'node_modules', '@claude-flow', 'memory'),
+    const home = os.homedir();
+    const pkgPaths = [
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'ruflo', 'package.json'),
+      path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'package.json'),
+      path.join(CWD, 'node_modules', 'ruflo', 'package.json'),
+      path.join(CWD, 'v3', '@claude-flow', 'cli', 'package.json'),
     ];
-    for (const p of memPkgPaths) {
-      if (fs.existsSync(p)) { hasHnsw = true; break; }
-    }
-  }
-
-  return { vectorCount, dbSizeKB: Math.floor(dbSizeKB), namespaces, hasHnsw };
-}
-
-// Test stats (count files only — NO reading file contents)
-function getTestStats() {
-  let testFiles = 0;
-
-  function countTestFiles(dir, depth) {
-    if (depth === undefined) depth = 0;
-    if (depth > 6) return;
-    try {
-      if (!fs.existsSync(dir)) return;
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-          countTestFiles(path.join(dir, entry.name), depth + 1);
-        } else if (entry.isFile()) {
-          const n = entry.name;
-          if (n.includes('.test.') || n.includes('.spec.') || n.includes('_test.') || n.includes('_spec.')) {
-            testFiles++;
-          }
-        }
-      }
-    } catch { /* ignore */ }
-  }
-
-  var testDirNames = ['tests', 'test', '__tests__', 'src', 'v3'];
-  for (var i = 0; i < testDirNames.length; i++) {
-    countTestFiles(path.join(CWD, testDirNames[i]));
-  }
-
-  return { testFiles, testCases: testFiles * 4 };
-}
-
-// Integration status (shared settings + file checks)
-function getIntegrationStatus() {
-  const mcpServers = { total: 0, enabled: 0 };
-  const settings = getSettings();
-
-  if (settings && settings.mcpServers && typeof settings.mcpServers === 'object') {
-    const servers = Object.keys(settings.mcpServers);
-    mcpServers.total = servers.length;
-    mcpServers.enabled = settings.enabledMcpjsonServers
-      ? settings.enabledMcpjsonServers.filter(s => servers.includes(s)).length
-      : servers.length;
-  }
-
-  if (mcpServers.total === 0) {
-    const mcpConfig = readJSON(path.join(CWD, '.mcp.json'))
-                   || readJSON(path.join(os.homedir(), '.claude', 'mcp.json'));
-    if (mcpConfig && mcpConfig.mcpServers) {
-      const s = Object.keys(mcpConfig.mcpServers);
-      mcpServers.total = s.length;
-      mcpServers.enabled = s.length;
-    }
-  }
-
-  const hasDatabase = ['.swarm/memory.db', '.claude-flow/memory.db', 'data/memory.db']
-    .some(p => fs.existsSync(path.join(CWD, p)));
-  const hasApi = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY);
-
-  return { mcpServers, hasDatabase, hasApi };
-}
-
-// Session stats (pure file reads)
-function getSessionStats() {
-  var sessionPaths = ['.claude-flow/session.json', '.claude/session.json'];
-  for (var i = 0; i < sessionPaths.length; i++) {
-    const data = readJSON(path.join(CWD, sessionPaths[i]));
-    if (data && data.startTime) {
-      const diffMs = Date.now() - new Date(data.startTime).getTime();
-      const mins = Math.floor(diffMs / 60000);
-      const duration = mins < 60 ? mins + 'm' : Math.floor(mins / 60) + 'h' + (mins % 60) + 'm';
-      return { duration: duration };
+    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 */ }
     }
-  }
-  return { duration: '' };
+  } catch { /* ignore */ }
+  return ver;
 }
 
 // ─── Rendering ──────────────────────────────────────────────────
@@ -649,59 +375,56 @@ function getSessionStats() {
 function progressBar(current, total) {
   const width = 5;
   const filled = Math.round((current / total) * width);
-  return '[' + '\\u25CF'.repeat(filled) + '\\u25CB'.repeat(width - filled) + ']';
+  return '[' + '●'.repeat(filled) + '○'.repeat(width - filled) + ']';
 }
 
 function generateStatusline() {
+  const d = getStatuslineData();
   const git = getGitInfo();
-  // Prefer model name from Claude Code stdin data, fallback to file-based detection
-  const modelName = getModelFromStdin() || getModelName();
+  const modelName = getModelFromStdin() || (d.user && d.user.modelName) || 'Claude Code';
   const ctxInfo = getContextFromStdin();
   const costInfo = getCostFromStdin();
-  const progress = getV3Progress();
-  const security = getSecurityStatus();
-  const swarm = getSwarmStatus();
-  const system = getSystemMetrics();
-  const adrs = getADRStatus();
-  const hooks = getHooksStatus();
-  const agentdb = getAgentDBStats();
-  const tests = getTestStats();
-  const session = getSessionStats();
-  const integration = getIntegrationStatus();
+  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 activeAgents = swarm.activeAgents || 0;
+  const maxAgents = swarm.maxAgents || CONFIG.maxAgents;
+  const coordinationActive = swarm.coordinationActive || false;
+  const intelligencePct = system.intelligencePct || 0;
+  const memoryMB = system.memoryMB || 0;
+  const subAgents = system.subAgents || 0;
+  const cvesFixed = security.cvesFixed || 0;
+  const totalCves = security.totalCves || 0;
+  const secStatus = security.status || 'NONE';
+  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 — read version from the FIRST package.json we find, preferring
-  // the plugin install at ~/.claude/plugins/marketplaces/ruflo/package.json.
-  // The previous list only checked project-local node_modules, so plugin
-  // users saw the hard-coded fallback (V3.5) even on newer alphas (#1951).
-  let pkgVersion = '3.6';
-  try {
-    const home = require('os').homedir();
-    const pkgPaths = [
-      // 1. The plugin's own root (installed via /plugin install).
-      path.join(home, '.claude', 'plugins', 'marketplaces', 'ruflo', 'package.json'),
-      // 2. Project-local @claude-flow/cli — npm-style install.
-      path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'package.json'),
-      // 3. Project-local ruflo umbrella.
-      path.join(CWD, 'node_modules', 'ruflo', 'package.json'),
-      // 4. Source-checkout location (when developing in this repo).
-      path.join(CWD, 'v3', '@claude-flow', '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) {
-          pkgVersion = pkg.version;
-          break;
-        }
-      } catch { /* malformed package.json — try next */ }
-    }
-  } catch { /* fall through to the hardcoded default */ }
-  let header = c.bold + c.brightPurple + '\\u258A RuFlo V' + pkgVersion + ' ' + c.reset;
-  header += (swarm.coordinationActive ? c.brightCyan : c.dim) + '\\u25CF ' + c.brightCyan + git.name + c.reset;
+  // Header
+  let header = c.bold + c.brightPurple + '▊ RuFlo V' + pkgVersion + ' ' + c.reset;
+  header += (coordinationActive ? c.brightCyan : c.dim) + '● ' + c.brightCyan + git.name + c.reset;
   if (git.gitBranch) {
-    header += '  ' + c.dim + '\\u2502' + c.reset + '  ' + c.brightBlue + '\\u23C7 ' + git.gitBranch + c.reset;
+    header += '  ' + c.dim + '│' + c.reset + '  ' + c.brightBlue + '⏇ ' + git.gitBranch + c.reset;
     const changes = git.modified + git.staged + git.untracked;
     if (changes > 0) {
       let ind = '';
@@ -710,185 +433,107 @@ function generateStatusline() {
       if (git.untracked > 0) ind += c.dim + '?' + git.untracked + c.reset;
       header += ' ' + ind;
     }
-    if (git.ahead > 0) header += ' ' + c.brightGreen + '\\u2191' + git.ahead + c.reset;
-    if (git.behind > 0) header += ' ' + c.brightRed + '\\u2193' + git.behind + c.reset;
+    if (git.ahead > 0) header += ' ' + c.brightGreen + '↑' + git.ahead + c.reset;
+    if (git.behind > 0) header += ' ' + c.brightRed + '↓' + git.behind + c.reset;
   }
-  header += '  ' + c.dim + '\\u2502' + c.reset + '  ' + c.purple + modelName + c.reset;
-  // Show session duration from Claude Code stdin if available, else from local files
-  const duration = costInfo ? costInfo.duration : session.duration;
-  if (duration) header += '  ' + c.dim + '\\u2502' + c.reset + '  ' + c.cyan + '\\u23F1 ' + duration + c.reset;
-  // Show context usage from Claude Code stdin if available
+  header += '  ' + c.dim + '│' + c.reset + '  ' + c.purple + modelName + c.reset;
+  const duration = costInfo ? costInfo.duration : '';
+  if (duration) header += '  ' + c.dim + '│' + c.reset + '  ' + c.cyan + '⏱ ' + duration + c.reset;
   if (ctxInfo && ctxInfo.usedPct > 0) {
     const ctxColor = ctxInfo.usedPct >= 90 ? c.brightRed : ctxInfo.usedPct >= 70 ? c.brightYellow : c.brightGreen;
-    header += '  ' + c.dim + '\\u2502' + c.reset + '  ' + ctxColor + '\\u25CF ' + ctxInfo.usedPct + '% ctx' + c.reset;
+    header += '  ' + c.dim + '│' + c.reset + '  ' + ctxColor + '● ' + ctxInfo.usedPct + '% ctx' + c.reset;
   }
-  // Show cost from Claude Code stdin if available
   if (costInfo && costInfo.costUsd > 0) {
-    header += '  ' + c.dim + '\\u2502' + c.reset + '  ' + c.brightYellow + '$' + costInfo.costUsd.toFixed(2) + c.reset;
+    header += '  ' + c.dim + '│' + c.reset + '  ' + c.brightYellow + '$' + costInfo.costUsd.toFixed(2) + c.reset;
   }
   lines.push(header);
 
   // Separator
-  lines.push(c.dim + '\\u2500'.repeat(53) + c.reset);
+  lines.push(c.dim + '─'.repeat(53) + c.reset);
 
   // Line 1: DDD Domains
-  const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
+  const domainsColor = domainsCompleted >= 3 ? c.brightGreen : domainsCompleted > 0 ? c.yellow : c.red;
   let perfIndicator;
-  if (agentdb.hasHnsw && agentdb.vectorCount > 0) {
-    const speedup = agentdb.vectorCount > 10000 ? '12500x' : agentdb.vectorCount > 1000 ? '150x' : '10x';
-    perfIndicator = c.brightGreen + '\\u26A1 HNSW ' + speedup + c.reset;
-  } else if (progress.patternsLearned > 0) {
-    const pk = progress.patternsLearned >= 1000 ? (progress.patternsLearned / 1000).toFixed(1) + 'k' : String(progress.patternsLearned);
-    perfIndicator = c.brightYellow + '\\uD83D\\uDCDA ' + pk + ' patterns' + c.reset;
+  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 + '\\u26A1 target: 150x-12500x' + c.reset;
+    perfIndicator = c.dim + '⚡ target: 150x-12500x' + c.reset;
   }
   lines.push(
-    c.brightCyan + '\\uD83C\\uDFD7\\uFE0F  DDD Domains' + c.reset + '    ' + progressBar(progress.domainsCompleted, progress.totalDomains) + '  ' +
-    domainsColor + progress.domainsCompleted + c.reset + '/' + c.brightWhite + progress.totalDomains + c.reset + '    ' + perfIndicator
+    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 swarmInd = swarm.coordinationActive ? c.brightGreen + '\\u25C9' + c.reset : c.dim + '\\u25CB' + c.reset;
-  const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
-  const secIcon = security.status === 'CLEAN' ? '\\uD83D\\uDFE2' : (security.status === 'IN_PROGRESS' || security.status === 'STALE') ? '\\uD83D\\uDFE1' : (security.status === 'NONE' ? '\\u26AA' : '\\uD83D\\uDD34');
-  const secColor = security.status === 'CLEAN' ? c.brightGreen : (security.status === 'IN_PROGRESS' || security.status === 'STALE') ? c.brightYellow : (security.status === 'NONE' ? c.dim : c.brightRed);
-  const hooksColor = hooks.enabled > 0 ? c.brightGreen : c.dim;
-  const intellColor = system.intelligencePct >= 80 ? c.brightGreen : system.intelligencePct >= 40 ? c.brightYellow : c.dim;
+  const swarmInd = coordinationActive ? c.brightGreen + '◉' + c.reset : c.dim + '○' + c.reset;
+  const agentsColor = activeAgents > 0 ? c.brightGreen : c.red;
+  const secIcon = secStatus === 'CLEAN' ? '🟢' : (secStatus === 'IN_PROGRESS' || secStatus === 'STALE') ? '🟡' : (secStatus === 'NONE' ? '⚪' : '🔴');
+  const secColor = secStatus === 'CLEAN' ? c.brightGreen : (secStatus === 'IN_PROGRESS' || 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;
 
   lines.push(
-    c.brightYellow + '\\uD83E\\uDD16 Swarm' + c.reset + '  ' + swarmInd + ' [' + agentsColor + String(swarm.activeAgents).padStart(2) + c.reset + '/' + c.brightWhite + swarm.maxAgents + c.reset + ']  ' +
-    c.brightPurple + '\\uD83D\\uDC65 ' + system.subAgents + c.reset + '    ' +
-    c.brightBlue + '\\uD83E\\uDE9D ' + hooksColor + hooks.enabled + c.reset + '/' + c.brightWhite + hooks.total + c.reset + '    ' +
-    secIcon + ' ' + secColor + 'CVE ' + security.cvesFixed + c.reset + '/' + c.brightWhite + security.totalCves + c.reset + '    ' +
-    c.brightCyan + '\\uD83D\\uDCBE ' + system.memoryMB + 'MB' + c.reset + '    ' +
-    intellColor + '\\uD83E\\uDDE0 ' + String(system.intelligencePct).padStart(3) + '%' + c.reset
+    c.brightYellow + '🤖 Swarm' + c.reset + '  ' + swarmInd + ' [' + agentsColor + String(activeAgents).padStart(2) + c.reset + '/' + c.brightWhite + maxAgents + c.reset + ']  ' +
+    c.brightPurple + '👥 ' + subAgents + c.reset + '    ' +
+    c.brightBlue + '🪝 ' + hooksColor + hooksEnabled + c.reset + '/' + c.brightWhite + hooksTotal + c.reset + '    ' +
+    secIcon + ' ' + secColor + 'CVE ' + cvesFixed + c.reset + '/' + c.brightWhite + totalCves + c.reset + '    ' +
+    c.brightCyan + '💾 ' + memoryMB + 'MB' + c.reset + '    ' +
+    intellColor + '🧠 ' + String(intelligencePct).padStart(3) + '%' + c.reset
   );
 
   // Line 3: Architecture
-  const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
-  const adrColor = adrs.count > 0 ? (adrs.implemented === adrs.count ? c.brightGreen : c.yellow) : c.dim;
-  const adrDisplay = adrs.compliance > 0 ? adrColor + '\\u25CF' + adrs.compliance + '%' + c.reset : adrColor + '\\u25CF' + adrs.implemented + '/' + adrs.count + c.reset;
+  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;
 
   lines.push(
-    c.brightPurple + '\\uD83D\\uDD27 Architecture' + c.reset + '    ' +
-    c.cyan + 'ADRs' + c.reset + ' ' + adrDisplay + '  ' + c.dim + '\\u2502' + c.reset + '  ' +
-    c.cyan + 'DDD' + c.reset + ' ' + dddColor + '\\u25CF' + String(progress.dddProgress).padStart(3) + '%' + c.reset + '  ' + c.dim + '\\u2502' + c.reset + '  ' +
-    c.cyan + 'Security' + c.reset + ' ' + secColor + '\\u25CF' + security.status + c.reset
+    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 4: AgentDB, Tests, Integration
-  const hnswInd = agentdb.hasHnsw ? c.brightGreen + '\\u26A1' + c.reset : '';
-  const sizeDisp = agentdb.dbSizeKB >= 1024 ? (agentdb.dbSizeKB / 1024).toFixed(1) + 'MB' : agentdb.dbSizeKB + 'KB';
-  const vectorColor = agentdb.vectorCount > 0 ? c.brightGreen : c.dim;
-  const testColor = tests.testFiles > 0 ? c.brightGreen : c.dim;
-
+  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 (integration.mcpServers.total > 0) {
-    const mcpCol = integration.mcpServers.enabled === integration.mcpServers.total ? c.brightGreen :
-                   integration.mcpServers.enabled > 0 ? c.brightYellow : c.red;
-    integStr += c.cyan + 'MCP' + c.reset + ' ' + mcpCol + '\\u25CF' + integration.mcpServers.enabled + '/' + integration.mcpServers.total + c.reset;
+  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 + '\\u25C6' + c.reset + 'DB';
-  if (integration.hasApi) integStr += (integStr ? '  ' : '') + c.brightGreen + '\\u25C6' + c.reset + 'API';
-  if (!integStr) integStr = c.dim + '\\u25CF none' + c.reset;
+  if (integration.hasDatabase) integStr += (integStr ? '  ' : '') + c.brightGreen + '◆' + c.reset + 'DB';
+  if (!integStr) integStr = c.dim + '● none' + c.reset;
 
   lines.push(
-    c.brightCyan + '\\uD83D\\uDCCA AgentDB' + c.reset + '    ' +
-    c.cyan + 'Vectors' + c.reset + ' ' + vectorColor + '\\u25CF' + agentdb.vectorCount + hnswInd + c.reset + '  ' + c.dim + '\\u2502' + c.reset + '  ' +
-    c.cyan + 'Size' + c.reset + ' ' + c.brightWhite + sizeDisp + c.reset + '  ' + c.dim + '\\u2502' + c.reset + '  ' +
-    c.cyan + 'Tests' + c.reset + ' ' + testColor + '\\u25CF' + tests.testFiles + c.reset + ' ' + c.dim + '(~' + tests.testCases + ' cases)' + c.reset + '  ' + c.dim + '\\u2502' + c.reset + '  ' +
+    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');
 }
 
-// JSON output
+// JSON output — delegates to CLI for accuracy; caller can use --json flag
 function generateJSON() {
+  const d = getStatuslineData();
   const git = getGitInfo();
-  return {
-    user: { name: git.name, gitBranch: git.gitBranch, modelName: getModelName() },
-    v3Progress: getV3Progress(),
-    security: getSecurityStatus(),
-    swarm: getSwarmStatus(),
-    system: getSystemMetrics(),
-    adrs: getADRStatus(),
-    hooks: getHooksStatus(),
-    agentdb: getAgentDBStats(),
-    tests: getTestStats(),
+  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(),
-  };
-}
-
-// ─── Stdin reader (Claude Code pipes session JSON) ──────────────
-
-// Claude Code sends session JSON via stdin (model, context, cost, etc.)
-// Read it synchronously so the script works both:
-//   1. When invoked by Claude Code (stdin has JSON)
-//   2. When invoked manually from terminal (stdin is empty/tty)
-let _stdinData = null;
-function getStdinData() {
-  if (_stdinData !== undefined && _stdinData !== null) return _stdinData;
-  try {
-    // Check if stdin is a TTY (manual run) — skip reading
-    if (process.stdin.isTTY) { _stdinData = null; return null; }
-    // Read stdin synchronously via fd 0
-    const chunks = [];
-    const buf = Buffer.alloc(4096);
-    let bytesRead;
-    try {
-      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();
-    if (raw && raw.startsWith('{')) {
-      _stdinData = JSON.parse(raw);
-    } else {
-      _stdinData = null;
-    }
-  } catch {
-    _stdinData = null;
-  }
-  return _stdinData;
-}
-
-// Override model detection to prefer stdin data from Claude Code
-function getModelFromStdin() {
-  const data = getStdinData();
-  if (data && data.model && data.model.display_name) return data.model.display_name;
-  return null;
-}
-
-// Get context window info from Claude Code session
-function getContextFromStdin() {
-  const data = getStdinData();
-  if (data && data.context_window) {
-    return {
-      usedPct: Math.floor(data.context_window.used_percentage || 0),
-      remainingPct: Math.floor(data.context_window.remaining_percentage || 100),
-    };
-  }
-  return null;
-}
-
-// Get cost info from Claude Code session
-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',
-      linesAdded: data.cost.total_lines_added || 0,
-      linesRemoved: data.cost.total_lines_removed || 0,
-    };
-  }
-  return null;
+  });
 }
 
 // ─── Main ───────────────────────────────────────────────────────