lumira 1.9.0 → 1.10.0

package/.claude-plugin/marketplace.json

@@ -5,15 +5,14 @@
   },
   "metadata": {
     "description": "Real-time statusline HUD for Claude Code and Qwen Code — analytics, quota projection, themes, powerline",
-    "version": "1.9.0",
-    "homepage": "https://github.com/cativo23/lumira"
+    "version": "1.10.0"
   },
   "plugins": [
     {
       "name": "lumira",
       "source": "./",
       "description": "Real-time statusline HUD for Claude Code and Qwen Code. Session analytics, API latency widget, 7-day quota projection, auto-compact warnings, 7 themes, powerline support. Zero runtime dependencies. Run /lumira:setup after install to activate.",
-      "version": "1.9.0",
+      "version": "1.10.0",
       "author": {
         "name": "Carlos Cativo"
       },
@@ -33,5 +32,5 @@
       ]
     }
   ],
-  "version": "1.9.0"
+  "version": "1.10.0"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Real-time statusline HUD for Claude Code and Qwen Code — session analytics, API latency, 7-day quota projection, auto-compact warnings, 7 themes, powerline. Zero runtime deps.",
   "author": {
     "name": "Carlos Cativo"

package/README.md

@@ -8,6 +8,17 @@ Real-time statusline plugin for [Claude Code](https://code.claude.com) and Qwen
 
 ## Quick start
 
+**Via Claude Code plugin (recommended):**
+
+```
+/plugin marketplace add cativo23/lumira
+/lumira:setup
+```
+
+No npm required. The `/lumira:setup` skill writes `statusLine.command` automatically. Restart Claude Code when done.
+
+**Via npm:**
+
 ```bash
 npx lumira install
 ```
@@ -24,13 +35,12 @@ Interactive wizard — preset, theme, icons — previewed live before write.
 ![Claude Code](https://img.shields.io/badge/Claude_Code-compatible-2d3748?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMjggMTI4IiB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCI+PHBhdGggZD0iTTY0IDEyOEMzNS44IDEyOCAxMyAxMDUuMiAxMyA3N0MxMyA0OC44IDM1LjggMjYgNjQgMjZjMjguMiAwIDUxIDIyLjggNTEgNTFzLTIyLjggNTEtNTEgNTF6IiBmaWxsPSIjMjQyNTJGIi8+PC9zdmc+)
 ![Qwen Code](https://img.shields.io/badge/Qwen_Code-compatible-6156FF)
 
-> 3,400+ monthly downloads, zero marketing. Try it for one session — `npx lumira install`.
-
-> **What's new in v1.8.2:** the installer now writes a fast per-render command — it runs the compiled `lumira` binary directly (~10× faster than `npx lumira@latest`, which hit the npm registry on every render) and migrates existing setups automatically. v1.8.1 brought the GSD widget to parity with 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 (on by default, self-gating). 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).
+> **What's new in v1.9.0:** lumira is now a **Claude Code plugin** — install with `/plugin marketplace add cativo23/lumira`, no npm required. Run `/lumira:setup` to activate. v1.8.2 made the installer write a fast per-render command (~10× faster). v1.8.1 brought the GSD widget to parity with GSD 1.42.3. Earlier: 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).
 
 ## Table of contents
 
 - [Why lumira?](#why-lumira)
+- [How lumira compares](#how-lumira-compares)
 - [Requirements](#requirements)
 - [Features](#features)
 - [Install](#install)
@@ -54,7 +64,25 @@ Claude Code's default statusline shows the model name and current directory. Tha
 - **Active tools, agents, and todo progress** — parsed from the live transcript, updated every render.
 - **Cross-platform** — same config drives Claude Code and Qwen Code; Qwen sessions auto-collapse to single-line.
 
-Inspired by [claude-hud](https://github.com/jarrodwatts/claude-hud); takes a different stance on opt-in powerline rendering, theme contrast guarantees, and Qwen Code compatibility.
+Inspired by [GSD's](https://github.com/open-gsd/gsd-core) statusline; takes its own stance on opt-in powerline rendering, theme contrast guarantees, and Qwen Code compatibility.
+
+## How lumira compares
+
+The Claude Code statusline space has several good tools. Here's an honest head-to-head on **features** against the other true statuslines (feature claims checked against each tool's current README, 2026-06-14):
+
+| Tool | Runtime / deps | Distribution | Platforms | Config UX | Powerline + themes | Session-intel widgets |
+|---|---|---|---|---|---|---|
+| **lumira** | TS / **0 runtime deps** | npm + npx + plugin (+ Qwen skill) | **Claude Code + Qwen Code** | Wizard + JSON + CLI flags | Yes (7 styles) + 7 themes, **WCAG-AA guard** | **Quota projection, pace delta, API-latency, auto-compact glyph + counter, cache, agents, MCP, todos, tools** + `stats` CLI |
+| ccstatusline | TS / bundled | npm + npx | Claude Code | **Ink TUI** (live preview) | Yes + themes | Context, cost, usage %, block timer, compaction count, git; no quota/pace/latency |
+| claude-hud | JS / Node 18+ | Plugin marketplace | Claude Code (v1.0.80+) | Guided `/configure` + JSON | No / no themes | Context, 5h/7d usage, cost, git, tools, agents, todos, cache TTL; no quota ETA/pace/latency |
+| CCometixLine | Rust binary | npm + binary + source | Claude Code | TUI (TOML) | Yes + themes | Model, dir, git, context %, usage, cost, time, output-style |
+| claude-pace | Bash + jq | curl + plugin + npx | Claude Code 2.1.80+ | JSON block | No / no | 5h+7d %, pace delta, reset countdown, git diff; ~10ms (lightest) |
+| cship | Rust binary | binary / script / cargo | Claude Code | TOML (Starship-style) | Yes (Starship) + themes | Cost, context bar, usage limits, model, effort, agent, session, peak-time |
+| starship-claude | Shell / needs Starship | Plugin + manual | Claude Code (no tmux) | Wizard + TOML | Via Starship + palettes | Context bar, model, session |
+
+**Where lumira leads:** breadth of session-intelligence widgets — sole owner of an API-latency widget, a 7-day quota *projection ETA*, an MCP-server count, and a bundled `stats` analytics CLI, on top of the full pace / agents / todos / cache set. Plus zero runtime deps, dual-platform (Claude Code **and** Qwen Code), and WCAG-AA contrast enforced in CI on every theme. **Where it doesn't:** no Ink-style interactive widget builder — config is a wizard + JSON, not a live drag-and-drop TUI.
+
+See [`docs/competitive-comparison.md`](docs/competitive-comparison.md) for the full per-widget matrix, config-UX detail, and distribution breakdown across every tool.
 
 ## Requirements
 
@@ -95,15 +123,26 @@ Inspired by [claude-hud](https://github.com/jarrodwatts/claude-hud); takes a dif
 
 ## Install
 
-The wizard at the top is the fastest path. For the long form:
+### Option 1 — Claude Code plugin (recommended)
+
+No npm required. Works with the Claude Code plugin marketplace:
+
+```
+/plugin marketplace add cativo23/lumira
+/lumira:setup
+```
+
+`/lumira:setup` finds the cached binary, writes `statusLine.command` to `~/.claude/settings.json`, and creates a default config. Restart Claude Code when done. To customize afterward: `/lumira:lumira`.
+
+### Option 2 — npm
 
 ```bash
 npx lumira install
 ```
 
-The installer walks you through three choices — **preset** (`full` / `balanced` / `minimal`), **theme**, and **icons** — showing a live preview at each step. Press `Esc` to abort without writing anything. In non-interactive shells (piped stdin, CI), the installer skips the wizard and writes sensible defaults (`preset: balanced`, `icons: nerd`). If Qwen Code is detected (`~/.qwen/` exists), the `/lumira` skill is installed for both CLIs.
+The installer walks you through **preset** (`full` / `balanced` / `minimal`), **theme**, and **icons** — showing a live preview at each step. Press `Esc` to abort without writing anything. In non-interactive shells (piped stdin, CI), the installer skips the wizard and writes sensible defaults (`preset: balanced`, `icons: nerd`). If Qwen Code is detected (`~/.qwen/` exists), the `/lumira` skill is installed for both CLIs.
 
-For the fastest statusline (the command runs on **every** render), the installer offers to install lumira globally so it can invoke the compiled binary directly (`lumira`, ~60ms) instead of `npx` (which is ~10× slower). It also migrates older `npx lumira@latest` setups to the faster form automatically.
+For the fastest statusline (the command runs on **every** render), the installer offers to install lumira globally so it can invoke the compiled binary directly (`lumira`, ~60ms) instead of `npx` (~10× slower). It also migrates older `npx lumira@latest` setups to the faster form automatically.
 
 Or install globally:
 

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { fileURLToPath } from 'node:url';
-import { realpathSync } from 'node:fs';
+import { realpathSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { readStdin as defaultReadStdin, StdinParseError } from './stdin.js';
 import { parseGitStatus } from './parsers/git.js';
 import { parseTranscript } from './parsers/transcript.js';
@@ -98,9 +98,49 @@ function isDirectRun() {
         return false;
     }
 }
+function getVersion() {
+    try {
+        // Assumes this file lives at dist/index.js — one level below package.json.
+        const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), '../package.json');
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function printHelp() {
+    const version = getVersion();
+    const usage = `lumira v${version}
+
+Usage: lumira [command]
+
+Commands:
+  install       Interactive setup wizard
+  uninstall     Remove statusline configuration
+  stats [path]  Show session statistics
+  themes        Browse and preview themes
+  custom        Manage custom commands
+
+Options:
+  --help, -h    Show this help
+  --version, -v Print version
+
+Run lumira with no arguments to render the statusline (requires Claude Code stdin).
+`;
+    process.stdout.write(usage);
+}
 if (isDirectRun()) {
     const cmd = process.argv[2];
-    if (cmd === 'install') {
+    if (cmd === '--help' || cmd === '-h') {
+        printHelp();
+        process.exit(0);
+    }
+    else if (cmd === '--version' || cmd === '-v') {
+        process.stdout.write(`${getVersion()}\n`);
+        process.exit(0);
+    }
+    else if (cmd === 'install') {
         const configPath = join(homedir(), '.config', 'lumira', 'config.json');
         install({ configPath }).then(o => process.stdout.write(o)).catch(e => process.stderr.write(`Install error: ${e.message}\n`));
     }
@@ -147,6 +187,10 @@ if (isDirectRun()) {
         // event loop refed. Reads the spec JSON from its own stdin.
         runCustomRefreshFromStdin().then(() => process.exit(0)).catch(() => process.exit(0));
     }
+    else if (cmd !== undefined) {
+        process.stderr.write(`Unknown command: ${cmd}. Run with --help for usage.\n`);
+        process.exit(1);
+    }
     else {
         main().then(o => process.stdout.write(o)).catch(e => { if (!(e instanceof StdinParseError))
             process.stderr.write(`Statusline error: ${e.message}\n`); });

package/dist/normalize.js

@@ -29,8 +29,12 @@ export function sanitizeTermString(s) {
 /** Allowed values for the reasoning effort level field (CC ≥ 2.1.x). */
 const VALID_EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 /**
- * Sum all four token categories from `context_window.current_usage` to compute
- * a real context usage total (input + output + cache_read + cache_creation).
+ * Sum input token categories from `context_window.current_usage` to compute
+ * a real context usage total (input + cache_read + cache_creation).
+ * Excludes output_tokens: they are per-turn and reset each call, which would
+ * cause the context bar to jitter (jump down at the start of every new turn).
+ * Context window fill is determined by what was READ from the context, not
+ * by how many tokens were output.
  * Returns undefined when `cu` is absent or not an object shape.
  */
 function getRealUsageTotal(cu) {
@@ -38,7 +42,6 @@ function getRealUsageTotal(cu) {
         return undefined;
     const obj = cu;
     const total = (obj.input_tokens ?? 0)
-        + (obj.output_tokens ?? 0)
         + (obj.cache_read_input_tokens ?? 0)
         + (obj.cache_creation_input_tokens ?? 0);
     return total;
@@ -100,9 +103,9 @@ export function normalize(input) {
     if (claude) {
         ({ denominator: cacheTurnDenominator } = getCacheFields(claude.context_window?.current_usage));
     }
-    // Real context usage percentage (Claude only): includes output tokens in the numerator,
-    // unlike the hook-provided `used_percentage` which excludes them. This gives an accurate
-    // picture of actual context consumption, especially near auto-compact thresholds.
+    // Real context usage percentage (Claude only): sums input + cache_read + cache_creation
+    // (output_tokens excluded — per-turn, resets each call, causes bar jitter). More stable
+    // than the hook-provided `used_percentage` near auto-compact thresholds.
     let realUsedPercentage;
     if (claude) {
         const total = getRealUsageTotal(claude.context_window?.current_usage);
@@ -113,10 +116,25 @@ export function normalize(input) {
     }
     // Auto-compact proximity warning: fires when context fill is in the
     // [threshold-gap, threshold) window. Uses realUsedPercentage when available
-    // (more accurate; includes output+cache), falls back to usedPercentage for
+    // (more accurate; excludes output tokens), falls back to usedPercentage for
     // legacy payloads. Gated by platform (different thresholds Claude vs Qwen).
+    // For claude-code, honors CLAUDE_CODE_AUTO_COMPACT_WINDOW env var — a fill-%
+    // threshold (1-100) that mirrors Claude Code's own auto-compact trigger point.
+    // Users who changed this setting in Claude Code should set the same value here.
+    // Falls back to the hardcoded 80% default when absent or invalid.
     const effectivePct = realUsedPercentage ?? contextWindow.used_percentage ?? 0;
-    const platformAutoCompactThreshold = AUTO_COMPACT_THRESHOLD[platform];
+    let platformAutoCompactThreshold = AUTO_COMPACT_THRESHOLD[platform];
+    if (platform === 'claude-code') {
+        const envVal = process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW;
+        if (envVal !== undefined) {
+            // Use Number() + Number.isInteger() so floats ("75.5") and trailing-junk
+            // strings ("80abc") are rejected rather than silently truncated by parseInt.
+            const parsed = Number(envVal);
+            if (Number.isInteger(parsed) && parsed >= 1 && parsed <= 100) {
+                platformAutoCompactThreshold = parsed;
+            }
+        }
+    }
     const nearAutoCompact = effectivePct >= (platformAutoCompactThreshold - AUTO_COMPACT_WARNING_GAP)
         && effectivePct < platformAutoCompactThreshold;
     // Performance (Qwen only)

package/dist/parsers/gsd.js

@@ -83,6 +83,22 @@ export function parseStateMd(content) {
         state.phaseTotal = phaseMatch[2];
         state.phaseName = phaseMatch[3];
     }
+    // Plan progress within the current phase (gsd-core ≥ 1.4.x). Accepts both the
+    // compound "X of Y in current phase" and the bare "X of Y" forms. A "Plan: —"
+    // (not started) line has no digits and is correctly skipped.
+    const planMatch = content.match(/^Plan:\s*(\d+)\s+of\s+(\d+)/m);
+    if (planMatch) {
+        state.planNum = planMatch[1];
+        state.planTotal = planMatch[2];
+    }
+    // Resume point (gsd-core ≥ 1.4.x). "Resume file: None" means no active resume
+    // point and is treated as absent.
+    const resumeMatch = content.match(/^Resume file:\s*(.+)/m);
+    if (resumeMatch) {
+        const path = resumeMatch[1].trim();
+        if (path && path.toLowerCase() !== 'none')
+            state.resumeFile = path;
+    }
     if (!state.status) {
         // Fallback: parse body Status line when frontmatter status is missing
         const bodyStatus = content.match(/^Status:\s*(.+)/m);
@@ -145,9 +161,13 @@ function formatState(s) {
     }
     // Scene selection: activePhase → nextAction → milestone-complete → default
     const phasesStr = s.nextPhases?.length ? s.nextPhases.join('/') : null;
+    // Plan progress within the phase (gsd-core ≥ 1.4.x), appended to the phase
+    // descriptor in the active/default scenes — e.g. "auth (3/5) p2/9".
+    const planSuffix = s.planNum && s.planTotal ? ` p${s.planNum}/${s.planTotal}` : '';
     if (s.activePhase) {
         // Scene 1: activePhase (with optional status)
-        parts.push(s.status ? `Phase ${s.activePhase} ${s.status}` : `Phase ${s.activePhase}`);
+        const phase = s.status ? `Phase ${s.activePhase} ${s.status}` : `Phase ${s.activePhase}`;
+        parts.push(`${phase}${planSuffix}`);
     }
     else if (s.nextAction && phasesStr) {
         // Scene 2: nextAction + phases when idle
@@ -163,7 +183,7 @@ function formatState(s) {
             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);
+            parts.push(`${phase}${planSuffix}`);
         }
     }
     return parts.join(' · ');
@@ -185,14 +205,16 @@ function semverCompare(a, b) {
     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.
+ * Read GSD update-check cache. Checks candidates in order — first match wins:
+ * 1. open-gsd per-package cache (`gsd-update-check-opengsd-gsd-core.json`, gsd-core ≥ 1.4.x)
+ * 2. Legacy shared tool-agnostic cache (`gsd-update-check.json`, get-shit-done-cc ≥ 1.x)
+ * 3. Legacy per-runtime location (`~/.claude/cache/`) for older installs
  * Returns update status, stale hooks flag, and dev install flag.
  */
-function readUpdateCache(sharedCacheFile, legacyCacheFile) {
+function readUpdateCache(openGsdCacheFile, sharedCacheFile, legacyCacheFile) {
     const result = { updateAvailable: false, staleHooks: false, devInstall: false };
     const candidates = [
+        ['open-gsd', openGsdCacheFile],
         ['shared', sharedCacheFile],
         ['legacy', legacyCacheFile],
     ];
@@ -226,15 +248,19 @@ function readUpdateCache(sharedCacheFile, legacyCacheFile) {
 }
 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 gsdCacheDir = join(homedir(), '.cache', 'gsd');
+    const openGsdCacheFile = opts.openGsdCacheFile ?? join(gsdCacheDir, 'gsd-update-check-opengsd-gsd-core.json');
+    const sharedCacheFile = opts.sharedCacheFile ?? join(gsdCacheDir, 'gsd-update-check.json');
     const legacyCacheFile = join(claudeDir, 'cache', 'gsd-update-check.json');
-    const cacheData = readUpdateCache(sharedCacheFile, legacyCacheFile);
+    const cacheData = readUpdateCache(openGsdCacheFile, sharedCacheFile, legacyCacheFile);
     let currentTask;
+    let hasResume = false;
     const stateFile = findStateMd(cwd || process.cwd());
     if (stateFile) {
         log('STATE.md found:', stateFile);
         try {
             const state = parseStateMd(readFileSync(stateFile, 'utf8'));
+            hasResume = state.resumeFile !== undefined;
             const formatted = formatState(state);
             if (formatted) {
                 currentTask = sanitizeTermString(formatted);
@@ -257,6 +283,7 @@ export function getGsdInfo(cwd, opts = {}) {
         staleHooks: cacheData.staleHooks || undefined,
         devInstall: cacheData.devInstall || undefined,
         currentTask,
+        hasResume: hasResume || undefined,
     };
 }
 //# sourceMappingURL=gsd.js.map

package/dist/parsers/transcript-stats.js

@@ -53,6 +53,14 @@ export async function aggregateStats(transcriptPath) {
         throw new Error(`Transcript file not found: ${transcriptPath}`);
     }
     const stats = emptyStats();
+    // Dedup guard: Claude Code streams one JSONL entry per content block for
+    // the same logical message (thinking → text → tool_use all share one
+    // message.id). Each entry carries the full usage block for that turn, so
+    // naively accumulating every entry inflates tokens/cost by the number of
+    // content blocks. Track seen message IDs and skip usage+cost on repeats.
+    // Content extraction (tool_use, tool_result) is NOT gated — each block
+    // appears exactly once in its own entry and must still be counted.
+    const seenMessageIds = new Set();
     let fileStream = null;
     try {
         fileStream = createReadStream(resolved);
@@ -81,10 +89,20 @@ export async function aggregateStats(transcriptPath) {
                 }
             }
             const message = (entry.message ?? null);
+            // Determine whether this is the first time we're seeing this message.id.
+            // Entries without a message.id (e.g. user turns, summary lines) are
+            // always treated as first-occurrence so they're never suppressed.
+            const messageId = message !== null && typeof message.id === 'string' ? message.id : null;
+            const isFirstOccurrence = messageId === null || !seenMessageIds.has(messageId);
+            if (messageId !== null)
+                seenMessageIds.add(messageId);
             // Usage block (assistant turns only). The mere presence of a usage
             // payload flips hasCostData=true even if all counts are zero — see
             // the "zero-cost-with-usage" test for why this matters.
-            if (entry.type === 'assistant' && message && typeof message === 'object') {
+            //
+            // Gated on isFirstOccurrence: duplicate entries for the same message.id
+            // carry identical usage blocks; accumulating them inflates counts 2-3×.
+            if (isFirstOccurrence && entry.type === 'assistant' && message && typeof message === 'object') {
                 const usage = message.usage;
                 if (usage && typeof usage === 'object') {
                     stats.hasCostData = true;
@@ -104,10 +122,14 @@ export async function aggregateStats(transcriptPath) {
             // undefined`), not truthiness — Anthropic emits `total_cost_usd: 0` for
             // fully-cached turns, and a `topCost || msgCost` short-circuit would
             // incorrectly fall through to the message field in that case.
-            const topCost = safeNumber(entry.total_cost_usd);
-            const msgCost = message ? safeNumber(message.total_cost_usd) : 0;
-            const costContribution = entry.total_cost_usd !== undefined ? topCost : msgCost;
-            stats.costUsd += costContribution;
+            //
+            // Also gated on isFirstOccurrence for the same dedup reason as usage above.
+            if (isFirstOccurrence) {
+                const topCost = safeNumber(entry.total_cost_usd);
+                const msgCost = message ? safeNumber(message.total_cost_usd) : 0;
+                const costContribution = entry.total_cost_usd !== undefined ? topCost : msgCost;
+                stats.costUsd += costContribution;
+            }
             // Tool / agent / error extraction from the message.content array.
             const content = message?.content;
             if (!Array.isArray(content))

package/dist/render/line4.js

@@ -13,6 +13,12 @@ export function renderLine4(ctx, c) {
         if (gsd.currentTask) {
             parts.push(c.bold(`${icons.hammer} ${truncField(gsd.currentTask, 60)}`));
         }
+        // Resume-point indicator (gsd-core ≥ 1.4.x). A ↩ glyph signals STATE.md has
+        // an active `.continue-here`/spec resume file — a cue that work can be picked
+        // up where it left off. Cyan: informational, distinct from update/stale warns.
+        if (gsd.hasResume) {
+            parts.push(c.cyan('↩'));
+        }
         if (gsd.updateAvailable) {
             parts.push(c.yellow('⬆ /gsd:update'));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumira",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "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",

package/skills/setup/SKILL.md

@@ -16,7 +16,17 @@ You activate the **lumira** statusline for Claude Code after plugin installation
 3. **Read settings** — Read `~/.claude/settings.json`. If the file is **missing**, start from `{}`. If it is **present but invalid JSON**, stop and report the parse error — do not overwrite.
 4. **Check existing** — If `statusLine.command` is already set to any non-empty value, tell the user what's currently set and ask if they want to replace it. Do not proceed until they confirm. If it is empty or absent, skip this step.
 5. **Write command** — Set `statusLine.command` to `node "<installPath>/dist/index.js"`.
-6. **Init config** — If `~/.config/lumira/config.json` does not exist, create it with `{"preset": "balanced"}`. Never overwrite an existing config.
+6. **Init config** — Only create `~/.config/lumira/config.json` if it does not already exist. Run the following Bash — the `test -f` guard is mandatory, do not skip it:
+   ```bash
+   if [ ! -f ~/.config/lumira/config.json ]; then
+     mkdir -p ~/.config/lumira
+     printf '{"preset": "balanced"}\n' > ~/.config/lumira/config.json
+     echo "Created default config at ~/.config/lumira/config.json"
+   else
+     echo "Config already exists at ~/.config/lumira/config.json — not modified"
+   fi
+   ```
+   Never overwrite an existing config under any circumstances.
 7. **Confirm and instruct** — Tell the user what was written and that they must restart Claude Code.
 
 ## Finding the install path