lumira 1.7.0 → 1.8.1

package/README.md

@@ -26,7 +26,7 @@ Interactive wizard — preset, theme, icons — previewed live before write.
 
 > 3,400+ monthly downloads, zero marketing. Try it for one session — `npx lumira install`.
 
-> **What's new in v1.7.0:** added-dirs badge (`+N dirs`, orange at ≥5) and worktree origin-branch breadcrumb (`↳ <branch>`) — both togglable via `display.addedDirs` / `display.worktreeBreadcrumb`, on by default in `full`/`balanced`. Combined with the [`lumira stats` CLI](#stats-cli) (v1.5), `API N%` latency widget (v1.4.0), 7-day quota projection warning (v1.3.0), and auto-compact proximity glyph ⚠ (v1.4.1), recent releases add several diagnostic signals to the session.
+> **What's new in v1.8.1:** the GSD widget now mirrors get-shit-done (GSD)'s own statusline — phase/milestone lifecycle, a milestone progress bar, and `⬆ /gsd:update` / `⚠ stale hooks` indicators that show in any project. GSD support is on by default and self-gates (no GSD project → nothing renders). Earlier releases added the compaction counter `⊙ N` (v1.8.0), added-dirs badge + worktree breadcrumb (v1.7.0), [`lumira stats` CLI](#stats-cli) (v1.5), `API N%` latency widget (v1.4.0), 7-day quota projection (v1.3.0), and the auto-compact proximity glyph ⚠ (v1.4.1).
 
 ## Table of contents
 
@@ -288,6 +288,7 @@ Create `~/.config/lumira/config.json`:
     "linesChanged": true,
     "memory": true,
     "agents": true,
+    "compactionCount": true,
     "health": false,
     "contextWarningThreshold": 70,
     "contextCriticalThreshold": 85

package/dist/config.js

@@ -293,6 +293,7 @@ const PRESET_DEFS = {
             apiLatency: false,
             addedDirs: false,
             worktreeBreadcrumb: false,
+            compactionCount: false,
         },
     },
 };

package/dist/parsers/gsd.js

@@ -14,13 +14,15 @@ export function parseStateMd(content) {
     const state = {};
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
-        for (const line of fmMatch[1].split('\n')) {
+        const fmText = fmMatch[1];
+        // Parse simple scalar fields
+        for (const line of fmText.split('\n')) {
             const m = line.match(/^(\w+):\s*(.+)/);
             if (!m)
                 continue;
             const [, key, val] = m;
             const v = val.trim().replace(/^(["'])(.*)\1$/, '$2');
-            if (v === 'null')
+            if (v === 'null' || v === '')
                 continue;
             if (key === 'status')
                 state.status = v;
@@ -28,6 +30,51 @@ export function parseStateMd(content) {
                 state.milestone = v;
             else if (key === 'milestone_name')
                 state.milestoneName = v;
+            else if (key === 'active_phase')
+                state.activePhase = v;
+            else if (key === 'next_action')
+                state.nextAction = v;
+        }
+        // Parse next_phases: flow form [a, b]
+        const flowMatch = fmText.match(/^next_phases:\s*\[([^\]]*)\]/m);
+        if (flowMatch && flowMatch[1]) {
+            const items = flowMatch[1].split(',').map(s => {
+                const trimmed = s.trim().replace(/^(["'])(.*)\1$/, '$2');
+                return trimmed;
+            }).filter(s => s.length > 0);
+            if (items.length > 0)
+                state.nextPhases = items;
+        }
+        // Parse next_phases: block-list form
+        if (!state.nextPhases) {
+            const blockMatch = fmText.match(/^next_phases:\s*\n((?:[ \t]*-[ \t]*[^\n]+\n?)*)/m);
+            if (blockMatch && blockMatch[1]) {
+                const items = [];
+                for (const itemLine of blockMatch[1].split('\n')) {
+                    const itemM = itemLine.match(/^[ \t]*-[ \t]*(.+)/);
+                    if (itemM) {
+                        const itemVal = itemM[1].trim().replace(/^(["'])(.*)\1$/, '$2');
+                        if (itemVal)
+                            items.push(itemVal);
+                    }
+                }
+                if (items.length > 0)
+                    state.nextPhases = items;
+            }
+        }
+        // Parse progress block
+        const progressMatch = fmText.match(/^progress:\s*\n((?:[ \t]+\w+:.+\n?)+)/m);
+        if (progressMatch && progressMatch[1]) {
+            const progressText = progressMatch[1];
+            const completedM = progressText.match(/completed_phases:\s*(\d+)/);
+            if (completedM)
+                state.completedPhases = completedM[1];
+            const totalM = progressText.match(/total_phases:\s*(\d+)/);
+            if (totalM)
+                state.totalPhases = totalM[1];
+            const percentM = progressText.match(/percent:\s*(\d+)/);
+            if (percentM)
+                state.percent = percentM[1];
         }
     }
     const phaseMatch = content.match(/^Phase:\s*(\d+)\s+of\s+(\d+)(?:\s+\(([^)]+)\))?/m);
@@ -51,6 +98,24 @@ export function parseStateMd(content) {
     }
     return state;
 }
+/**
+ * Render a 10-segment progress bar: `█████░░░░░ 50%`.
+ *
+ * INTENTIONAL deviation from GSD's own statusline (gsd-statusline.js wraps the
+ * bar in brackets — `[█████░░░░░] 50%`). lumira drops the brackets so the
+ * milestone bar reads as distinct from the line-2 context bar. Do NOT re-add
+ * brackets when re-syncing GSD's format — this is a deliberate design choice.
+ */
+function renderProgressBar(percent) {
+    if (percent === undefined || percent === null)
+        return '';
+    const pct = Math.max(0, Math.min(100, parseInt(String(percent), 10)));
+    if (isNaN(pct))
+        return '';
+    const filled = Math.floor(pct / 10);
+    const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+    return `${bar} ${pct}%`;
+}
 /** Walk up from `cwd` looking for `.planning/STATE.md`; stop at home or filesystem root. */
 export function findStateMd(cwd) {
     const home = homedir();
@@ -69,27 +134,64 @@ export function findStateMd(cwd) {
 /** Format a GSD state into a compact status string: `milestone · status · phase`. */
 function formatState(s) {
     const parts = [];
+    // Milestone segment with optional progress bar
     if (s.milestone || s.milestoneName) {
         const ver = s.milestone ?? '';
         const name = s.milestoneName && s.milestoneName !== 'milestone' ? s.milestoneName : '';
-        const ms = [ver, name].filter(Boolean).join(' ');
-        if (ms)
-            parts.push(ms);
+        const bar = renderProgressBar(s.percent);
+        const msParts = [ver, name, bar].filter(Boolean);
+        if (msParts.length > 0)
+            parts.push(msParts.join(' '));
+    }
+    // Scene selection: activePhase → nextAction → milestone-complete → default
+    const phasesStr = s.nextPhases?.length ? s.nextPhases.join('/') : null;
+    if (s.activePhase) {
+        // Scene 1: activePhase (with optional status)
+        parts.push(s.status ? `Phase ${s.activePhase} ${s.status}` : `Phase ${s.activePhase}`);
     }
-    if (s.status)
-        parts.push(s.status);
-    if (s.phaseNum && s.phaseTotal) {
-        const phase = s.phaseName ? `${s.phaseName} (${s.phaseNum}/${s.phaseTotal})` : `ph ${s.phaseNum}/${s.phaseTotal}`;
-        parts.push(phase);
+    else if (s.nextAction && phasesStr) {
+        // Scene 2: nextAction + phases when idle
+        parts.push(`next ${s.nextAction} ${phasesStr}`);
+    }
+    else if (Number(s.percent) === 100 || (s.completedPhases && s.totalPhases && s.completedPhases === s.totalPhases)) {
+        // Scene 3: milestone complete
+        parts.push('milestone complete');
+    }
+    else {
+        // Scene 4 (default): preserve existing behavior
+        if (s.status)
+            parts.push(s.status);
+        if (s.phaseNum && s.phaseTotal) {
+            const phase = s.phaseName ? `${s.phaseName} (${s.phaseNum}/${s.phaseTotal})` : `ph ${s.phaseNum}/${s.phaseTotal}`;
+            parts.push(phase);
+        }
     }
     return parts.join(' · ');
 }
+/** Compare two semver versions. Returns 1 if a > b, -1 if a < b, 0 if equal. */
+function semverCompare(a, b) {
+    const parseVer = (v) => {
+        const parts = v.replace(/^v/, '').split('.').map(p => parseInt(p, 10));
+        return { major: parts[0] ?? 0, minor: parts[1] ?? 0, patch: parts[2] ?? 0 };
+    };
+    const av = parseVer(a);
+    const bv = parseVer(b);
+    if (av.major !== bv.major)
+        return av.major > bv.major ? 1 : -1;
+    if (av.minor !== bv.minor)
+        return av.minor > bv.minor ? 1 : -1;
+    if (av.patch !== bv.patch)
+        return av.patch > bv.patch ? 1 : -1;
+    return 0;
+}
 /**
  * Read GSD update-check cache. Checks the shared tool-agnostic cache first
  * (`~/.cache/gsd/`, introduced by GSD #1421), then falls back to the legacy
  * per-runtime location (`~/.claude/cache/`) for older GSD installs.
+ * Returns update status, stale hooks flag, and dev install flag.
  */
 function readUpdateCache(sharedCacheFile, legacyCacheFile) {
+    const result = { updateAvailable: false, staleHooks: false, devInstall: false };
     const candidates = [
         ['shared', sharedCacheFile],
         ['legacy', legacyCacheFile],
@@ -100,19 +202,33 @@ function readUpdateCache(sharedCacheFile, legacyCacheFile) {
         try {
             const parsed = JSON.parse(readFileSync(file, 'utf8'));
             if (parsed.update_available) {
+                result.updateAvailable = true;
                 log('update cache:', source, file);
-                return true;
             }
+            if (Array.isArray(parsed.stale_hooks) && parsed.stale_hooks.length > 0) {
+                result.staleHooks = true;
+            }
+            // DevInstall: stale_hooks present AND installed is ahead of latest.
+            // Guard against an unknown/missing latest explicitly (mirrors GSD's own
+            // check) rather than relying on NaN comparison semantics in semverCompare.
+            if (result.staleHooks &&
+                parsed.installed &&
+                parsed.latest &&
+                parsed.latest !== 'unknown' &&
+                semverCompare(parsed.installed, parsed.latest) > 0) {
+                result.devInstall = true;
+            }
+            return result;
         }
         catch { /* ignore malformed */ }
     }
-    return false;
+    return result;
 }
 export function getGsdInfo(cwd, opts = {}) {
     const claudeDir = opts.claudeDir ?? process.env['CLAUDE_CONFIG_DIR'] ?? join(homedir(), '.claude');
     const sharedCacheFile = opts.sharedCacheFile ?? join(homedir(), '.cache', 'gsd', 'gsd-update-check.json');
     const legacyCacheFile = join(claudeDir, 'cache', 'gsd-update-check.json');
-    const updateAvailable = readUpdateCache(sharedCacheFile, legacyCacheFile);
+    const cacheData = readUpdateCache(sharedCacheFile, legacyCacheFile);
     let currentTask;
     const stateFile = findStateMd(cwd || process.cwd());
     if (stateFile) {
@@ -132,10 +248,15 @@ export function getGsdInfo(cwd, opts = {}) {
     else {
         log('no STATE.md found walking up from:', cwd || process.cwd());
     }
-    if (!updateAvailable && !currentTask) {
-        log('no gsd signal — update=false, task=none (line4 will be empty)');
+    if (!cacheData.updateAvailable && !cacheData.staleHooks && !currentTask) {
+        log('no gsd signal — update=false, staleHooks=false, task=none (line4 will be empty)');
         return null;
     }
-    return { updateAvailable, currentTask };
+    return {
+        updateAvailable: cacheData.updateAvailable || undefined,
+        staleHooks: cacheData.staleHooks || undefined,
+        devInstall: cacheData.devInstall || undefined,
+        currentTask,
+    };
 }
 //# sourceMappingURL=gsd.js.map

package/dist/parsers/transcript.js

@@ -124,7 +124,7 @@ export function extractToolTarget(toolName, input) {
 // same canonicalisation and allow-list semantics. See `path.ts` for caveats
 // about the string-level (non-symlink-following) nature of the check.
 export async function parseTranscript(transcriptPath) {
-    const result = { ...EMPTY_TRANSCRIPT, tools: [], agents: [], todos: [] };
+    const result = { ...EMPTY_TRANSCRIPT, tools: [], agents: [], todos: [], compactionCount: 0 };
     if (!transcriptPath || !existsSync(transcriptPath)) {
         if (log.enabled)
             log('skip — transcript path missing or nonexistent:', transcriptPath || '(empty)');
@@ -185,6 +185,8 @@ export async function parseTranscript(transcriptPath) {
                 const entry = JSON.parse(line);
                 if (!result.sessionStart && entry.timestamp)
                     result.sessionStart = new Date(entry.timestamp);
+                if (entry.type === 'system' && entry.subtype === 'compact_boundary')
+                    result.compactionCount++;
                 const effortMatch = Array.isArray(entry.message?.content)
                     ? entry.message.content
                         .filter((b) => b.type === 'text')

package/dist/render/line2.js

@@ -25,7 +25,7 @@ export function formatCountdown(resetsAt) {
     return `${s}s`;
 }
 export function renderLine2(ctx, c) {
-    const { input, tokenSpeed, transcript: { thinkingEffort }, config: { display }, cols, memory, mcp, icons } = ctx;
+    const { input, tokenSpeed, transcript: { thinkingEffort, compactionCount }, config: { display }, cols, memory, mcp, icons } = ctx;
     const leftParts = [];
     const rightParts = [];
     // Track context slots pushed so critical rate-limit segments anchor after
@@ -56,6 +56,11 @@ export function renderLine2(ctx, c) {
             contextSlotCount++;
         }
     }
+    // Compaction counter — how many times this session has been compacted.
+    // Self-gating: renders nothing at count 0. Paired with the context bar.
+    if (display.compactionCount && compactionCount > 0) {
+        leftParts.push(c.dim(`⊙ ${compactionCount}`));
+    }
     // Tokens
     if (display.tokens) {
         const inTokens = input.tokens.input;

package/dist/render/line4.js

@@ -3,14 +3,23 @@ import { getCustomCommandsForLine, renderCustomCommand } from './shared.js';
 export function renderLine4(ctx, c) {
     const { gsd, icons } = ctx;
     const parts = [];
-    // GSD widget — only emit when GSD has something to display.
-    if (gsd && (gsd.currentTask || gsd.updateAvailable)) {
+    // GSD widget — only emit when GSD has something to display. Text and glyphs
+    // mirror GSD's own statusline (gsd-statusline.js) so the integration reads
+    // identically. The update/stale-hooks indicators render even without a
+    // current task, so a GSD update is visible in any project (gated only on the
+    // update-check cache, not on being inside a GSD project).
+    if (gsd && (gsd.currentTask || gsd.updateAvailable || gsd.staleHooks)) {
         parts.push(c.dim('GSD'));
         if (gsd.currentTask) {
-            parts.push(c.bold(`${icons.hammer} ${truncField(gsd.currentTask, 40)}`));
+            parts.push(c.bold(`${icons.hammer} ${truncField(gsd.currentTask, 60)}`));
         }
         if (gsd.updateAvailable) {
-            parts.push(c.yellow(`${icons.warning} GSD update available`));
+            parts.push(c.yellow('⬆ /gsd:update'));
+        }
+        if (gsd.staleHooks) {
+            parts.push(gsd.devInstall
+                ? c.yellow('⚠ dev install — re-run installer to sync hooks')
+                : c.red('⚠ stale hooks — run /gsd:update'));
         }
     }
     // Custom commands (issue #143 phase 3) — line 4 is the lowest-priority line

package/dist/render/powerline-line2.js

@@ -44,7 +44,7 @@ function getApiLatencyBg(pct, palette) {
 // urgency channels the user actually needs at a glance. Decision rationale
 // recorded against PR #47.
 function buildSegments(ctx, palette, c) {
-    const { input, config: { display }, icons, mcp, transcript: { thinkingEffort } } = ctx;
+    const { input, config: { display }, icons, mcp, transcript: { thinkingEffort, compactionCount } } = ctx;
     const segments = [];
     // Context bar — always highest priority. plain=true so the bar cells inherit
     // the powerline segment bg; only %/icon/hint emit color escapes.
@@ -72,6 +72,11 @@ function buildSegments(ctx, palette, c) {
             segments.push({ text: `${formatTokens(used)}/${formatTokens(capacity)}`, bg: palette.dirBg, fg: palette.fg, priority: 90 });
         }
     }
+    // Compaction counter — self-gating at 0; priority 88 keeps it adjacent to
+    // the context family (contextBar=100, contextTokens=90).
+    if (display.compactionCount && compactionCount > 0) {
+        segments.push({ text: `⊙ ${compactionCount}`, bg: palette.dirBg, fg: palette.fg, priority: 88 });
+    }
     // 7d projection — computed once, surfaced inside the 7d segment when the
     // badge is visible (≥50%), or as a standalone segment when it isn't. Mirrors
     // classic line2: badge filter hides noise, projection surfaces signal.

package/dist/types.js

@@ -11,6 +11,7 @@ export const EMPTY_TRANSCRIPT = Object.freeze({
     todos: Object.freeze([]),
     thinkingEffort: '',
     sessionStart: null,
+    compactionCount: 0,
 });
 /** Hard cap on per-command wall time (ms). */
 export const CUSTOM_COMMAND_MAX_TIMEOUT_MS = 2000;
@@ -106,12 +107,17 @@ export const DEFAULT_DISPLAY = {
     apiLatency: true,
     addedDirs: true,
     worktreeBreadcrumb: true,
+    compactionCount: true,
     contextWarningThreshold: DEFAULT_CONTEXT_WARNING_THRESHOLD,
     contextCriticalThreshold: DEFAULT_CONTEXT_CRITICAL_THRESHOLD,
 };
 export const DEFAULT_CONFIG = {
     layout: 'auto',
-    gsd: false,
+    // GSD on by default, mirroring GSD's own always-on statusline. Self-gates to
+    // nothing when there's no .planning/STATE.md and no update-check cache, so
+    // non-GSD users see no extra line and pay only a few cheap existsSync checks.
+    // Minimal/singleline returns early (renderMinimal) and never reaches line 4.
+    gsd: true,
     display: { ...DEFAULT_DISPLAY },
     colors: { mode: 'auto' },
     customCommands: { enabled: false, commands: [] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Real-time statusline HUD for Claude Code and Qwen Code. Includes session analytics CLI, API latency overhead widget, 7d quota projection, auto-compact proximity warnings, themes, and powerline. Zero deps.",
   "type": "module",
   "main": "dist/index.js",