@sienklogic/plan-build-run 2.12.0 → 2.12.1

package/plugins/pbr/scripts/status-line.js

@@ -15,6 +15,8 @@ const path = require('path');
 const cp = require('child_process');
 const { logHook } = require('./hook-logger');
 const { configLoad } = require('./pbr-tools');
+const { resolveSessionPath } = require('./lib/core');
+const llmMetricsModule = require('./local-llm/metrics');
 
 // ANSI color codes
 const c = {
@@ -36,8 +38,8 @@ const c = {
 
 // Default status_line config — works out of the box with zero config
 const DEFAULTS = {
-  sections: ['phase', 'plan', 'status', 'git', 'context'],
-  brand_text: '\u25C6 Plan-Build-Run',
+  sections: ['phase', 'plan', 'status', 'agent', 'git', 'hooks', 'context', 'llm'],
+  brand_text: '\u25C6 PBR',
   max_status_length: 50,
   context_bar: {
     width: 10,
@@ -133,6 +135,7 @@ function statusColor(statusText) {
   if (lower.includes('complete') || lower.includes('verified')) return c.green;
   if (lower.includes('needs_fixes') || lower.includes('partial')) return c.yellow;
   if (lower.includes('progress') || lower.includes('building') || lower.includes('executing') || lower.includes('planning')) return c.yellow;
+  if (lower.includes('discussing') || lower.includes('researching')) return c.magenta;
   if (lower.includes('verifying')) return c.blue;
   if (lower.includes('planned') || lower.includes('ready')) return c.cyan;
   if (lower.includes('blocked') || lower.includes('failed')) return c.red;
@@ -170,6 +173,265 @@ function formatDuration(ms) {
   return `${minutes}m`;
 }
 
+/**
+ * Format a token count with K/M suffixes for compact display.
+ * @param {number} tokens
+ * @returns {string}
+ */
+function formatTokens(tokens) {
+  if (tokens >= 1_000_000) return (tokens / 1_000_000).toFixed(1) + 'M';
+  if (tokens >= 1_000) return (tokens / 1_000).toFixed(1) + 'K';
+  return String(tokens);
+}
+
+/**
+ * Count phase directories in .planning/phases/ as a fallback for total phases.
+ * Returns the count as a string, or null if the directory doesn't exist.
+ */
+function countPhaseDirs(planningDir) {
+  try {
+    const phasesDir = path.join(planningDir, 'phases');
+    if (!fs.existsSync(phasesDir)) return null;
+    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+    const count = entries.filter(e => e.isDirectory() && /^\d+/.test(e.name)).length;
+    return count > 0 ? String(count) : null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Read the current milestone name from ROADMAP.md.
+ * Looks for `## Milestone: {name}` headers, returns the first non-completed one.
+ * Returns null if no ROADMAP.md or no milestone header found.
+ */
+function getMilestone(planningDir) {
+  try {
+    const roadmapPath = path.join(planningDir, 'ROADMAP.md');
+    if (!fs.existsSync(roadmapPath)) return null;
+    const content = fs.readFileSync(roadmapPath, 'utf8');
+    // Match "## Milestone: Name (version)" or "## Milestone: Name"
+    // Skip completed milestones (ending with "-- COMPLETED")
+    const matches = content.matchAll(/^##\s*Milestone:\s*(.+?)(?:\s*--\s*COMPLETED)?$/gm);
+    let lastActive = null;
+    for (const m of matches) {
+      const line = m[0];
+      if (!line.includes('COMPLETED')) {
+        lastActive = m[1].trim();
+        break;
+      }
+    }
+    return lastActive;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Synchronous TCP probe — checks if hook server port is open.
+ * Uses cp.execSync with a tiny node script to avoid async in status line.
+ * Returns true if port is accepting connections, false otherwise.
+ */
+function isHookServerRunning(port) {
+  try {
+    const result = cp.execSync(
+      `node -e "var s=require('net').createConnection(${port || 19836},'127.0.0.1');s.setTimeout(100);s.on('connect',()=>{process.stdout.write('1');s.destroy()});s.on('error',()=>process.stdout.write('0'));s.on('timeout',()=>{process.stdout.write('0');s.destroy()})"`,
+      { timeout: 300, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+    return result === '1';
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Get hook server status with circuit breaker awareness.
+ * Returns one of: 'running', 'failed', 'stopped'.
+ *
+ * - 'running': TCP probe succeeds (server is responsive)
+ * - 'failed': Circuit breaker is open (5+ consecutive failures, cooldown active)
+ * - 'stopped': Server not running, no circuit breaker issues (normal idle)
+ *
+ * @param {number} [port=19836] - Hook server port
+ * @param {string} [planningDir] - Path to .planning/ directory
+ * @returns {'running'|'failed'|'stopped'}
+ */
+// ---------------------------------------------------------------------------
+// Dev line helpers — PBR development stats from local files
+// ---------------------------------------------------------------------------
+
+/**
+ * Read project version from package.json in cwd.
+ * @returns {string|null}
+ */
+function getVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+    return pkg.version || null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Count pending todos in .planning/todos/pending/.
+ * @param {string} planningDir
+ * @returns {number}
+ */
+function countTodos(planningDir) {
+  try {
+    const dir = path.join(planningDir, 'todos', 'pending');
+    if (!fs.existsSync(dir)) return 0;
+    return fs.readdirSync(dir).filter(f => f.endsWith('.md')).length;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+/**
+ * Count quick tasks in .planning/quick/.
+ * Returns { total, open } where open = dirs without SUMMARY.md.
+ * @param {string} planningDir
+ * @returns {{ total: number, open: number }}
+ */
+function countQuickTasks(planningDir) {
+  try {
+    const dir = path.join(planningDir, 'quick');
+    if (!fs.existsSync(dir)) return { total: 0, open: 0 };
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && /^\d+/.test(e.name));
+    let open = 0;
+    for (const e of entries) {
+      if (!fs.existsSync(path.join(dir, e.name, 'SUMMARY.md'))) open++;
+    }
+    return { total: entries.length, open };
+  } catch (_e) {
+    return { total: 0, open: 0 };
+  }
+}
+
+/**
+ * Count skill directories in plugins/pbr/skills/.
+ * @returns {number}
+ */
+function countSkills() {
+  try {
+    const dir = path.join(process.cwd(), 'plugins', 'pbr', 'skills');
+    if (!fs.existsSync(dir)) return 0;
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && e.name !== 'shared').length;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+/**
+ * Count hook entries in hooks/hooks.json.
+ * @returns {number}
+ */
+function countHookEntries() {
+  try {
+    const hooksFile = path.join(process.cwd(), 'hooks', 'hooks.json');
+    const data = JSON.parse(fs.readFileSync(hooksFile, 'utf8'));
+    let count = 0;
+    if (data.hooks) {
+      for (const groups of Object.values(data.hooks)) {
+        for (const group of groups) {
+          if (group.hooks) count += group.hooks.length;
+        }
+      }
+    }
+    return count;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+/**
+ * Read test coverage percentage.
+ * Priority: .last-test.json cache > bin/lib aggregate from coverage-summary > global total.
+ * The bin/lib slice (~75%) is the enforced threshold; global (~25%) includes untested hooks.
+ * @param {string} [planningDir] - Path to .planning/ for .last-test.json
+ * @returns {number|null}
+ */
+function getCoverage(planningDir) {
+  // Prefer .last-test.json — written by posttest with fresh aggregated data
+  if (planningDir) {
+    try {
+      const testFile = path.join(planningDir, '.last-test.json');
+      const data = JSON.parse(fs.readFileSync(testFile, 'utf8'));
+      if (data.coverage != null) return Math.round(data.coverage);
+    } catch (_e) { /* fall through */ }
+  }
+  // Fallback: read coverage-final.json (always fresh after jest --coverage).
+  // coverage-summary.json is stale — Jest doesn't regenerate without json-summary reporter.
+  try {
+    const covFile = path.join(process.cwd(), 'coverage', 'coverage-final.json');
+    const data = JSON.parse(fs.readFileSync(covFile, 'utf8'));
+    let totalStmts = 0;
+    let coveredStmts = 0;
+    for (const file of Object.keys(data)) {
+      const stmtMap = data[file].s;
+      for (const key of Object.keys(stmtMap)) {
+        totalStmts++;
+        if (stmtMap[key] > 0) coveredStmts++;
+      }
+    }
+    return totalStmts > 0 ? Math.round((coveredStmts / totalStmts) * 100) : null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Read last test result from .planning/.last-test.json.
+ * Written by scripts/posttest.js after each npm test run.
+ * Format: { passed, failed, total, coverage, suites, timestamp }
+ * @param {string} planningDir
+ * @returns {{ passed: number, failed: number, total: number, coverage?: number }|null}
+ */
+function getLastTestResult(planningDir) {
+  try {
+    const testFile = path.join(planningDir, '.last-test.json');
+    return JSON.parse(fs.readFileSync(testFile, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Read CI status from .planning/.ci-status.json.
+ * Expected format: { status: "pass"|"fail"|"pending", branch: string, timestamp: string }
+ * @param {string} planningDir
+ * @returns {{ status: string }|null}
+ */
+function getCiStatus(planningDir) {
+  try {
+    const ciFile = path.join(planningDir, '.ci-status.json');
+    return JSON.parse(fs.readFileSync(ciFile, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+}
+
+function getHookServerStatus(port, planningDir) {
+  if (isHookServerRunning(port)) return 'running';
+
+  // Check circuit breaker state for failure detection
+  if (planningDir) {
+    try {
+      const circuitPath = path.join(planningDir, '.hook-server-circuit.json');
+      const data = JSON.parse(fs.readFileSync(circuitPath, 'utf8'));
+      if (data.failures >= 5) {
+        const elapsed = Date.now() - (data.openedAt || 0);
+        if (elapsed < 30000) return 'failed';
+      }
+    } catch (_e) { /* no circuit file — server is simply stopped */ }
+  }
+
+  return 'stopped';
+}
+
 function main() {
   const stdinData = readStdin();
   const cwd = process.cwd();
@@ -184,7 +446,36 @@ function main() {
     const slConfig = loadStatusLineConfig(planningDir);
     const content = fs.readFileSync(stateFile, 'utf8');
     const ctxPercent = getContextPercent(stdinData);
-    const status = buildStatusLine(content, ctxPercent, slConfig, stdinData);
+
+    // Bridge real context data to .context-budget.json for TMUX status bar
+    if (ctxPercent != null) {
+      try {
+        const { saveBridge } = require('./context-bridge');
+        const bridgePath = path.join(planningDir, '.context-budget.json');
+        const bridge = {
+          timestamp: new Date().toISOString(),
+          estimated_percent: ctxPercent,
+          source: 'claude-code',
+          tool_calls: 0,
+          chars_read: 0
+        };
+        // Preserve existing bridge fields (warnings, tier, etc.)
+        try {
+          const existing = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+          bridge.tool_calls = existing.tool_calls || 0;
+          bridge.chars_read = existing.chars_read || 0;
+          bridge.warnings_issued = existing.warnings_issued || [];
+          bridge.last_warned_tier = existing.last_warned_tier || 'PEAK';
+          bridge.calls_since_warn = existing.calls_since_warn || 0;
+          bridge.thresholds = existing.thresholds;
+        } catch (_e) { /* no existing bridge */ }
+        saveBridge(bridgePath, bridge);
+      } catch (_e) {
+        // Best-effort — never fail the status line
+      }
+    }
+
+    const status = buildStatusLine(content, ctxPercent, slConfig, stdinData, planningDir);
 
     if (status) {
       process.stdout.write(status);
@@ -192,12 +483,36 @@ function main() {
     }
   } catch (_e) {
     logHook('status-line', 'StatusLine', 'error', { error: _e.message });
+    process.stdout.write(JSON.stringify({ additionalContext: '⚠ [PBR] status-line failed: ' + _e.message }));
   }
 
   process.exit(0);
 }
 
-function buildStatusLine(content, ctxPercent, cfg, stdinData) {
+/**
+ * Parse YAML frontmatter from STATE.md content.
+ * Returns an object with frontmatter fields, or null if no frontmatter.
+ */
+function parseFrontmatter(content) {
+  if (!content.startsWith('---')) return null;
+  const endIdx = content.indexOf('---', 3);
+  if (endIdx === -1) return null;
+  const fm = content.substring(3, endIdx);
+  const result = {};
+  for (const line of fm.split(/\r?\n/)) {
+    const m = line.match(/^(\w[\w_]*):\s*"?([^"]*)"?\s*$/);
+    if (m) {
+      const val = m[2].trim();
+      // Skip YAML nulls and empty values — they'd render as literal "null"
+      if (val && val !== 'null' && val !== 'undefined') {
+        result[m[1]] = val;
+      }
+    }
+  }
+  return result;
+}
+
+function buildStatusLine(content, ctxPercent, cfg, stdinData, planningDir) {
   const config = cfg || DEFAULTS;
   const sections = config.sections || DEFAULTS.sections;
   const brandText = config.brand_text || DEFAULTS.brand_text;
@@ -205,39 +520,100 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
   const barCfg = config.context_bar || DEFAULTS.context_bar;
   const sd = stdinData || {};
 
-  const parts = [];
+  // Prefer frontmatter (always up-to-date) over body text (may be stale)
+  const fm = parseFrontmatter(content);
+
+  // Line 1: project state (milestone, phase, plan, status)
+  // Line 2: environment info (git, hooks, model, cost, duration, context)
+  const line1 = [];
+  const line2 = [];
+
+  // Milestone section — show active milestone from ROADMAP.md
+  if (sections.includes('milestone') && planningDir) {
+    const milestone = getMilestone(planningDir);
+    if (milestone) {
+      line1.push(`${c.boldCyan}${brandText}${c.reset} ${c.magenta}${milestone}${c.reset}`);
+    } else {
+      line1.push(`${c.boldCyan}${brandText}${c.reset}`);
+    }
+  }
 
   // Phase section (always includes brand text)
   if (sections.includes('phase')) {
+    const fmPhase = fm && fm.current_phase;
+    // phase_slug is the canonical field; phase_name is a legacy alias
+    const fmSlug = fm && fm.phase_slug;
+    const fmName = fm && fm.phase_name;
     const phaseMatch = content.match(/Phase:\s*(\d+)\s*of\s*(\d+)\s*(?:\(([^)]+)\))?/);
-    if (phaseMatch) {
-      parts.push(`${c.boldCyan}${brandText}${c.reset} ${c.bold}Phase ${phaseMatch[1]}/${phaseMatch[2]}${c.reset}`);
-      if (phaseMatch[3]) {
-        parts.push(`${c.magenta}${phaseMatch[3]}${c.reset}`);
+
+    const phaseNum = fmPhase || (phaseMatch && phaseMatch[1]);
+    const fmPhasesTotal = fm && fm.phases_total;
+    const phaseTotal = fmPhasesTotal || (phaseMatch && phaseMatch[2]) || countPhaseDirs(planningDir);
+    // Format phase_slug from "foo-bar" to "Foo Bar" for display
+    const formattedSlug = fmSlug ? String(fmSlug).replace(/-/g, ' ').replace(/\b\w/g, ch => ch.toUpperCase()) : null;
+    const phaseName = fmName || formattedSlug || (phaseMatch && phaseMatch[3]);
+
+    if (phaseNum && phaseTotal) {
+      line1.push(`${c.boldCyan}${brandText}${c.reset} ${c.bold}Phase ${phaseNum}/${phaseTotal}${c.reset}`);
+      if (phaseName) {
+        line1.push(`${c.magenta}${phaseName}${c.reset}`);
       }
     } else {
-      parts.push(`${c.boldCyan}${brandText}${c.reset}`);
+      line1.push(`${c.boldCyan}${brandText}${c.reset}`);
     }
   }
 
-  // Plan section
+  // Plan section — shows current plan progress within the phase
   if (sections.includes('plan')) {
+    const fmComplete = fm && fm.plans_complete;
+    const fmPlansTotal = fm && fm.plans_total;
     const planMatch = content.match(/Plan:\s*(\d+)\s*of\s*(\d+)/);
-    if (planMatch) {
-      const done = parseInt(planMatch[1], 10);
-      const total = parseInt(planMatch[2], 10);
+
+    const done = fmComplete != null ? parseInt(fmComplete, 10) : (planMatch ? parseInt(planMatch[1], 10) : null);
+    const total = fmPlansTotal != null ? parseInt(fmPlansTotal, 10) : (planMatch ? parseInt(planMatch[2], 10) : null);
+
+    if (done != null && total != null && total > 0) {
       const planColor = done === total ? c.green : c.white;
-      parts.push(`${planColor}Plan ${done}/${total}${c.reset}`);
+      line1.push(`${planColor}Plan ${done}/${total}${c.reset}`);
     }
   }
 
   // Status section
   if (sections.includes('status')) {
-    const statusMatch = content.match(/Status:\s*(.+)/);
-    if (statusMatch) {
-      const text = statusMatch[1].trim();
+    const fmStatus = fm && fm.status;
+    const statusMatch = content.match(/^Status:\s*(.+)/m);
+    const text = fmStatus || (statusMatch && statusMatch[1].trim());
+    if (text) {
       const short = text.length > maxLen ? text.slice(0, maxLen - 3) + '...' : text;
-      parts.push(`${statusColor(text)}${short}${c.reset}`);
+      line1.push(`${statusColor(text)}${short}${c.reset}`);
+    }
+  }
+
+  // Agent section — active subagent name from .active-agent signal file
+  // Try session-scoped path first, fall back to global
+  if (sections.includes('agent') && planningDir) {
+    try {
+      const agentSessionId = sd.session_id || null;
+      let agentName = null;
+      if (agentSessionId) {
+        const sessionAgentFile = resolveSessionPath(planningDir, '.active-agent', agentSessionId);
+        if (fs.existsSync(sessionAgentFile)) {
+          agentName = fs.readFileSync(sessionAgentFile, 'utf8').trim();
+        }
+      }
+      if (!agentName) {
+        const globalAgentFile = path.join(planningDir, '.active-agent');
+        if (fs.existsSync(globalAgentFile)) {
+          agentName = fs.readFileSync(globalAgentFile, 'utf8').trim();
+        }
+      }
+      if (agentName) {
+        // Strip pbr- prefix for brevity
+        agentName = agentName.replace(/^pbr-/, '');
+        line1.push(`${c.magenta}\u25C6 ${agentName}${c.reset}`);
+      }
+    } catch (_e) {
+      // Graceful fallback — skip if unreadable
     }
   }
 
@@ -246,13 +622,25 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
     const gitInfo = getGitInfo();
     if (gitInfo) {
       const dirtyMark = gitInfo.dirty ? `${c.yellow}*${c.reset}` : '';
-      parts.push(`${c.cyan}${gitInfo.branch}${c.reset}${dirtyMark}`);
+      line2.push(`${c.cyan}${gitInfo.branch}${c.reset}${dirtyMark}`);
+    }
+  }
+
+  // Hooks section — hook server status indicator (3 states)
+  if (sections.includes('hooks')) {
+    const hsStatus = getHookServerStatus(19836, planningDir);
+    if (hsStatus === 'running') {
+      line2.push(`${c.green}\u25CF hooks${c.reset}`);
+    } else if (hsStatus === 'failed') {
+      line2.push(`${c.red}\u25CF hooks${c.reset}`);
+    } else {
+      line2.push(`${c.dim}\u25CB hooks${c.reset}`);
     }
   }
 
   // Model section — current model display name from stdin
   if (sections.includes('model') && sd.model && sd.model.display_name) {
-    parts.push(`${c.dim}${sd.model.display_name}${c.reset}`);
+    line2.push(`${c.dim}${sd.model.display_name}${c.reset}`);
   }
 
   // Cost section — session cost from stdin
@@ -262,12 +650,12 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
     let costColor = c.dim;
     if (cost > 5) costColor = c.red;
     else if (cost > 1) costColor = c.yellow;
-    parts.push(`${costColor}${costStr}${c.reset}`);
+    line2.push(`${costColor}${costStr}${c.reset}`);
   }
 
   // Duration section — session wall-clock time from stdin
   if (sections.includes('duration') && sd.cost && sd.cost.total_duration_ms != null) {
-    parts.push(`${c.dim}${formatDuration(sd.cost.total_duration_ms)}${c.reset}`);
+    line2.push(`${c.dim}${formatDuration(sd.cost.total_duration_ms)}${c.reset}`);
   }
 
   // Context bar section
@@ -276,13 +664,138 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
       thresholds: barCfg.thresholds || DEFAULTS.context_bar.thresholds,
       chars: barCfg.chars || DEFAULTS.context_bar.chars
     });
-    parts.push(`${bar} ${c.dim}${ctxPercent}%${c.reset}`);
+    let ctxSuffix = '';
+    // Append tier label only when current context % warrants it
+    // (budget file may have stale last_warned_tier from a previous session)
+    try {
+      const budgetPath = path.join(planningDir, '.context-budget.json');
+      if (fs.existsSync(budgetPath)) {
+        const budget = JSON.parse(fs.readFileSync(budgetPath, 'utf8'));
+        const thresholds = budget.thresholds || { degrading: 50, poor: 70, critical: 85 };
+        if (ctxPercent >= thresholds.critical) ctxSuffix = ` ${c.boldRed}CRITICAL${c.reset}`;
+        else if (ctxPercent >= thresholds.poor) ctxSuffix = ` ${c.red}POOR${c.reset}`;
+        else if (ctxPercent >= thresholds.degrading) ctxSuffix = ` ${c.yellow}DEGRADING${c.reset}`;
+      }
+    } catch (_e) {
+      // Skip silently if file missing or malformed
+    }
+    line2.push(`${bar} ${c.dim}${ctxPercent}%${c.reset}${ctxSuffix}`);
+  }
+
+  if (line1.length === 0 && line2.length === 0) return null;
+
+  const sep = ` ${c.dim}\u2502${c.reset} `;
+  let output = line1.join(sep);
+  if (line2.length > 0) {
+    output += '\n' + line2.join(sep);
+  }
+
+  // LLM offload section — renders on a third line below the main status
+  // Shows session stats + lifetime total when both are available
+  if (sections.includes('llm') && planningDir) {
+    try {
+      const lifetime = llmMetricsModule.computeLifetimeMetrics(planningDir);
+      if (lifetime && lifetime.total_calls > 0) {
+        // Try to get session-scoped metrics using duration from stdin
+        let sessionPart = '';
+        const durationMs = sd.cost && sd.cost.total_duration_ms;
+        if (durationMs != null && durationMs > 0) {
+          const sessionStart = new Date(Date.now() - durationMs);
+          const sessionEntries = llmMetricsModule.readSessionMetrics(planningDir, sessionStart);
+          const session = llmMetricsModule.summarizeMetrics(sessionEntries);
+          if (session.total_calls > 0) {
+            sessionPart = `${c.dim}${session.total_calls} calls${c.reset} ${c.dim}\u00B7${c.reset} ${c.green}${formatTokens(session.tokens_saved)} saved${c.reset}`;
+          }
+        }
+
+        const lifetimePart = `${c.dim}${formatTokens(lifetime.tokens_saved)} lifetime${c.reset}`;
+
+        if (sessionPart) {
+          output += `\n${c.green}Local LLM${c.reset} ${sessionPart} ${c.dim}\u2502${c.reset} ${lifetimePart}`;
+        } else {
+          output += `\n${c.green}Local LLM${c.reset} ${c.dim}${lifetime.total_calls} calls${c.reset} ${c.dim}\u00B7${c.reset} ${c.green}${formatTokens(lifetime.tokens_saved)} saved${c.reset}`;
+        }
+      }
+    } catch (_e) {
+      // No metrics available — skip silently
+    }
   }
 
-  if (parts.length === 0) return null;
+  // Dev line — PBR development stats (version, skills, hooks, coverage, todos, quick, tests, ci)
+  // Only renders when at least one dev section is enabled
+  if (sections.includes('dev') && planningDir) {
+    const devParts = [];
+
+    // Version from package.json
+    const ver = getVersion();
+    if (ver) {
+      devParts.push(`${c.boldCyan}\u25C6 dev${c.reset} ${c.dim}v${ver}${c.reset}`);
+    }
+
+    // Skill count
+    const skillCount = countSkills();
+    if (skillCount > 0) {
+      devParts.push(`${c.dim}${skillCount} skills${c.reset}`);
+    }
+
+    // Hook entry count
+    const hookCount = countHookEntries();
+    if (hookCount > 0) {
+      devParts.push(`${c.dim}${hookCount} hooks${c.reset}`);
+    }
+
+    // Test coverage — prefers .last-test.json, falls back to coverage-summary.json
+    const cov = getCoverage(planningDir);
+    if (cov != null) {
+      const covColor = cov >= 70 ? c.green : cov >= 50 ? c.yellow : c.red;
+      devParts.push(`${covColor}${cov}% cov${c.reset}`);
+    }
+
+    // Last test result from .planning/.last-test.json
+    const testResult = getLastTestResult(planningDir);
+    if (testResult) {
+      if (testResult.failed > 0) {
+        devParts.push(`${c.red}\u2717 ${testResult.failed} fail${c.reset}`);
+      } else {
+        devParts.push(`${c.green}\u2713 ${testResult.total} pass${c.reset}`);
+      }
+    }
+
+    // CI status from .planning/.ci-status.json
+    const ciResult = getCiStatus(planningDir);
+    if (ciResult) {
+      if (ciResult.status === 'pass') {
+        devParts.push(`${c.green}\u2713 CI${c.reset}`);
+      } else if (ciResult.status === 'fail') {
+        devParts.push(`${c.red}\u2717 CI${c.reset}`);
+      } else if (ciResult.status === 'pending') {
+        devParts.push(`${c.yellow}\u25CB CI${c.reset}`);
+      }
+    }
+
+    // Pending todos
+    const todoCount = countTodos(planningDir);
+    if (todoCount > 0) {
+      devParts.push(`${c.yellow}${todoCount} todo${todoCount !== 1 ? 's' : ''}${c.reset}`);
+    }
+
+    // Quick tasks
+    const quick = countQuickTasks(planningDir);
+    if (quick.total > 0) {
+      if (quick.open > 0) {
+        devParts.push(`${c.yellow}Q:${quick.total} (${quick.open} open)${c.reset}`);
+      } else {
+        devParts.push(`${c.dim}Q:${quick.total}${c.reset}`);
+      }
+    }
+
+    if (devParts.length > 0) {
+      output += '\n' + devParts.join(sep);
+    }
+  }
 
-  return parts.join(` ${c.dim}\u2502${c.reset} `);
+  return output;
 }
 
 if (require.main === module || process.argv[1] === __filename) { main(); }
-module.exports = { buildStatusLine, buildContextBar, getContextPercent, getGitInfo, formatDuration, loadStatusLineConfig, DEFAULTS };
+module.exports = { buildStatusLine, buildContextBar, getContextPercent, getGitInfo, getMilestone, countPhaseDirs, isHookServerRunning, getHookServerStatus, getVersion, countTodos, countQuickTasks, countSkills, countHookEntries, getCoverage, getLastTestResult, getCiStatus, formatDuration, formatTokens, loadStatusLineConfig, parseFrontmatter, DEFAULTS };