The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: offer an opt-in local Claude usage display
haelyra3add1816ea21
diff --git a/docs/STATUSLINE.md b/docs/STATUSLINE.mdnew file mode 100644index 000000000..86610904a--- /dev/null+++ b/docs/STATUSLINE.md@@ -0,0 +1,32 @@+# Optional Claude usage display++ECC's existing statusline can show rate-limit windows, prompt-cache usage,+session cost, and installed plugin information when explicitly enabled. It+reads Claude's statusline input and local ECC metrics; it makes no network+requests and does not register hooks or change shell aliases.++To try it on macOS or Linux, adapt the existing statusline example in+`examples/statusline.json` and prefix its command with `ECC_STATUSLINE_USAGE=1`:++```json+{+ "statusLine": {+ "type": "command",+ "command": "ECC_STATUSLINE_USAGE=1 /absolute/path/to/node /absolute/path/to/ecc/scripts/hooks/ecc-statusline.js"+ }+}+```++Use the absolute Node executable that works on your machine, and quote paths+containing spaces. Keep any existing custom statusline unless you choose to+replace it. Windows users can set `ECC_STATUSLINE_USAGE=1` in their provider's+environment and use the same script command with quoted absolute paths.++Removing the environment setting restores the existing compact output. Missing+rate-limit data produces no usage window. `ECC_BAR_GLYPHS=ascii` selects ASCII+symbols, and `ECC_STATUSLINE_COMPACT=1` requests the compact variant inside+the optional display.++The rendering idea comes from PR #2716 and the MIT-licensed+[claude-code-usage-bar](https://github.com/leeguooooo/claude-code-usage-bar).+Automatic installation and a managed Codex terminal bar remain separate work.diff --git a/scripts/hooks/ecc-statusline.js b/scripts/hooks/ecc-statusline.jsindex 413dbda49..11006a354 100644--- a/scripts/hooks/ecc-statusline.js+++ b/scripts/hooks/ecc-statusline.js@@ -85,6 +85,68 @@ function readCurrentTask(sessionId) {}}+function getEccVersion(plugins) {+ const ecc = plugins.find(p => p.name === 'ecc');+ if (ecc?.version) return ecc.version;+ try {+ return fs.readFileSync(path.join(__dirname, '..', '..', 'VERSION'), 'utf8').trim();+ } catch {+ return '';+ }+}++/**+ * Assemble statusline output lines from Claude Code stdin data.+ * @param {object} data - Parsed statusLine stdin JSON+ * @param {object|null} bridge - Session bridge metrics or null+ * @param {string} task - Current in-progress task+ * @returns {string[]} Non-empty output lines+ */+function buildUsageLines(data, bridge, task) {+ const render = require('../lib/statusline-render');+ const remaining = data.context_window?.remaining_percentage;+ const cost = data.cost || {};+ const dirname = path.basename(data.workspace?.current_dir || process.cwd());++ if (process.env.ECC_STATUSLINE_COMPACT === '1') {+ const segments = [`\x1b[2m${data.model?.display_name || 'Claude'}\x1b[0m`];+ if (task) segments.push(`\x1b[1;97m${task}\x1b[0m`);+ segments.push(`\x1b[2m${dirname}\x1b[0m`);+ return [segments.join(render.SEP) + buildContextBar(remaining)];+ }++ const usageLine = render.buildUsageLine(+ data.rate_limits,+ render.computeCacheStats(data.context_window?.current_usage)+ );++ const durationMs = bridge?.first_timestamp+ ? Date.now() - new Date(bridge.first_timestamp).getTime()+ : 0;+ const sessionLine = render.buildSessionLine({+ model: data.model?.display_name,+ effort: data.effort?.level,+ fastMode: data.fast_mode === true,+ ctxBar: buildContextBar(remaining),+ ctxWindowSize: data.context_window?.context_window_size,+ costUsd: cost.total_cost_usd ?? bridge?.total_cost_usd ?? 0,+ linesAdded: cost.total_lines_added || 0,+ linesRemoved: cost.total_lines_removed || 0,+ durationMs,+ task,+ });++ const plugins = render.readInstalledPlugins();+ const eccLine = render.buildEccLine({+ eccVersion: getEccVersion(plugins),+ hooks: render.getHooksSummary(),+ plugins,+ dirname,+ });++ return [usageLine, sessionLine, eccLine].filter(Boolean);+}+function runStatusline() {let input = '';const stdinTimeout = setTimeout(() => process.exit(0), 3000);@@ -119,6 +181,11 @@ function runStatusline() {// Current taskconst task = sessionId ? readCurrentTask(sessionId) : '';+ if (process.env.ECC_STATUSLINE_USAGE === '1') {+ process.stdout.write(buildUsageLines(data, bridge, task).join('\n'));+ return;+ }+// Metrics from bridgelet metricsStr = '';if (bridge) {@@ -163,6 +230,6 @@ function runStatusline() {});}-module.exports = { formatDuration, buildContextBar, readCurrentTask, MAX_STDIN };+module.exports = { formatDuration, buildContextBar, readCurrentTask, buildUsageLines, MAX_STDIN };if (require.main === module) runStatusline();diff --git a/scripts/lib/statusline-render.js b/scripts/lib/statusline-render.jsnew file mode 100644index 000000000..00abcde04--- /dev/null+++ b/scripts/lib/statusline-render.js@@ -0,0 +1,278 @@+#!/usr/bin/env node+/**+ * Shared rendering helpers for the ECC usage bar statusline.+ *+ * Inspired by leeguooooo/claude-code-usage-bar (MIT). ECC re-implementation+ * with brand colors, hooks/plugin awareness, and no external dependencies.+ *+ * Colors use 256-color ANSI so macOS Terminal.app renders them correctly.+ * Brand palette (from assets/ecc-icon.svg): amber #F59E0B ~ 214,+ * terracotta #E07856 ~ 173.+ */++'use strict';++const fs = require('fs');+const os = require('os');+const path = require('path');+const { areHooksEnabled, getHookProfile, getDisabledHookIds } = require('./hook-flags');++const C = {+ amber: '\x1b[38;5;214m',+ terracotta: '\x1b[38;5;173m',+ yellow: '\x1b[38;5;220m',+ orange: '\x1b[38;5;208m',+ red: '\x1b[1;38;5;196m',+ green: '\x1b[38;5;114m',+ dim: '\x1b[2m',+ reset: '\x1b[0m',+};++const UNICODE_GLYPHS = {+ full: '\u2588', empty: '\u2591', sep: '\u2502', bolt: '\u26a1', star: '\u2733', hex: '\u2b22', reset: '\u21bb', dot: '\u00b7',+};+const ASCII_GLYPHS = {+ full: '|', empty: '_', sep: '|', bolt: '*', star: '*', hex: '#', reset: '~', dot: '-',+};++/**+ * Glyphs degrade to ASCII when the environment cannot be trusted to render+ * block/box characters: tmux mangles them to underscores without a UTF-8+ * locale, and fonts such as Terminal.app's default lack \u2b22/\u2733.+ * Force either set with ECC_BAR_GLYPHS=ascii|unicode.+ */+function glyphSet(env = process.env) {+ const forced = String(env.ECC_BAR_GLYPHS || '').trim().toLowerCase();+ if (forced === 'ascii') return ASCII_GLYPHS;+ if (forced === 'unicode') return UNICODE_GLYPHS;+ const locale = `${env.LC_ALL || ''} ${env.LC_CTYPE || ''} ${env.LANG || ''}`.toLowerCase();+ return locale.includes('utf') ? UNICODE_GLYPHS : ASCII_GLYPHS;+}++const G = glyphSet();+const SEP = ` ${C.dim}${G.sep}${C.reset} `;++/**+ * Severity color for a usage percentage: brand color while healthy,+ * warm ramp as the window fills up.+ * @param {number} pct - 0..100 used+ * @param {string} brandColor - color to use below 60%+ */+function pctColor(pct, brandColor = C.amber) {+ if (pct >= 90) return C.red;+ if (pct >= 80) return C.orange;+ if (pct >= 60) return C.yellow;+ return brandColor;+}++/**+ * Block bar for a percentage. Uses the same glyphs as the context bar.+ * @param {number} pct - 0..100 used+ * @param {number} width - bar width in cells+ */+function buildBar(pct, width = 8) {+ const clamped = Math.max(0, Math.min(100, Math.round(pct)));+ const filled = Math.round((clamped / 100) * width);+ return G.full.repeat(filled) + G.empty.repeat(width - filled);+}++/**+ * Countdown until a unix-seconds timestamp: "42m", "1h42m", "3d".+ * @param {number} epochSecs+ * @returns {string} countdown or '' when invalid/past+ */+function formatCountdown(epochSecs) {+ if (!epochSecs || typeof epochSecs !== 'number') return '';+ const secs = Math.floor(epochSecs - Date.now() / 1000);+ if (secs <= 0) return '';+ const mins = Math.ceil(secs / 60);+ if (mins < 60) return `${mins}m`;+ const hours = Math.floor(mins / 60);+ if (hours < 24) {+ const rem = mins % 60;+ return rem > 0 ? `${hours}h${rem}m` : `${hours}h`;+ }+ return `${Math.round(hours / 24)}d`;+}++/**+ * Wall-clock duration from milliseconds: "5s", "12m", "3h11m".+ * @param {number} ms+ */+function formatMs(ms) {+ if (!ms || ms < 0) return '';+ const secs = Math.floor(ms / 1000);+ if (secs < 60) return `${secs}s`;+ const mins = Math.floor(secs / 60);+ if (mins < 60) return `${mins}m`;+ const hours = Math.floor(mins / 60);+ const rem = mins % 60;+ return rem > 0 ? `${hours}h${rem}m` : `${hours}h`;+}++/**+ * Prompt-cache stats from context_window.current_usage.+ * @returns {{hitPct: number}|null} null when there is no usage data yet+ */+function computeCacheStats(currentUsage) {+ if (!currentUsage || typeof currentUsage !== 'object') return null;+ const read = currentUsage.cache_read_input_tokens || 0;+ const write = currentUsage.cache_creation_input_tokens || 0;+ const fresh = currentUsage.input_tokens || 0;+ const total = read + write + fresh;+ if (total <= 0) return null;+ return { hitPct: Math.round((read / total) * 100) };+}++function usageSegment(label, labelColor, window) {+ const pct = Math.round(window?.used_percentage ?? -1);+ if (pct < 0) return '';+ const color = pctColor(pct, labelColor);+ const reset = formatCountdown(window.resets_at);+ const resetStr = reset ? ` ${C.dim}${G.reset}${reset}${C.reset}` : '';+ return `${labelColor}${label}${C.reset} ${color}${buildBar(pct)} ${pct}%${C.reset}${resetStr}`;+}++/**+ * Line 1: rate-limit windows + prompt cache.+ * Returns '' when no rate limit data is available (e.g. API-key billing).+ */+function buildUsageLine(rateLimits, cacheStats) {+ const parts = [];+ const fiveHour = usageSegment('5h', C.amber, rateLimits?.five_hour);+ const sevenDay = usageSegment('7d', C.terracotta, rateLimits?.seven_day);+ if (fiveHour) parts.push(fiveHour);+ if (sevenDay) parts.push(sevenDay);+ if (cacheStats && parts.length > 0) {+ const cacheColor = cacheStats.hitPct >= 50 ? C.green : C.dim;+ parts.push(`${C.dim}cache${C.reset} ${cacheColor}${cacheStats.hitPct}%${C.reset}`);+ }+ if (parts.length === 0) return '';+ return `${C.amber}${G.bolt}${C.reset} ${parts.join(SEP)}`;+}++/**+ * Line 2: model, mode, context bar, cost, diff, duration, current task.+ */+function buildSessionLine(info) {+ const parts = [];+ let model = `${C.amber}${G.star} ${info.model || 'Claude'}${C.reset}`;+ const badges = [];+ if (info.effort && info.effort !== 'high') badges.push(info.effort);+ if (info.fastMode) badges.push('fast');+ if (badges.length > 0) model += ` ${C.dim}${badges.join(' ')}${C.reset}`;+ parts.push(model);++ if (info.ctxBar) {+ const size = info.ctxWindowSize >= 1000000+ ? '1M'+ : info.ctxWindowSize ? `${Math.round(info.ctxWindowSize / 1000)}K` : '';+ const sizeStr = size ? ` ${C.dim}${size}${C.reset}` : '';+ parts.push(`${C.dim}ctx${C.reset}${info.ctxBar}${sizeStr}`);+ }++ const metrics = [];+ if (info.costUsd > 0) metrics.push(`$${info.costUsd.toFixed(2)}`);+ if (info.linesAdded > 0 || info.linesRemoved > 0) {+ metrics.push(`+${info.linesAdded || 0}/-${info.linesRemoved || 0}`);+ }+ const dur = formatMs(info.durationMs);+ if (dur) metrics.push(dur);+ if (metrics.length > 0) parts.push(`\x1b[38;5;117m${metrics.join(' ')}${C.reset}`);++ if (info.task) parts.push(`\x1b[1;97m${info.task}${C.reset}`);+ return parts.join(SEP);+}++/**+ * Line 3: ECC version, hooks status, enabled plugins with versions, directory.+ */+function buildEccLine(info) {+ const parts = [];+ const version = info.eccVersion ? ` ${info.eccVersion}` : '';+ parts.push(`${C.terracotta}${G.hex} ECC${version}${C.reset}`);++ if (info.hooks) {+ const h = info.hooks;+ let hookStr;+ if (!h.enabled) hookStr = `${C.red}hooks off${C.reset}`;+ else {+ const off = h.disabledCount > 0 ? ` ${C.dim}(${h.disabledCount} off)${C.reset}` : '';+ hookStr = `${C.green}hooks ${h.profile}${C.reset}${off}`;+ }+ parts.push(hookStr);+ }++ if (Array.isArray(info.plugins) && info.plugins.length > 0) {+ const shown = info.plugins.slice(0, 4)+ .map(p => `${p.name}${p.version ? ` ${C.dim}${p.version}${C.reset}` : ''}`);+ const more = info.plugins.length > 4 ? ` ${C.dim}+${info.plugins.length - 4}${C.reset}` : '';+ parts.push(`${C.dim}plugins${C.reset} ${shown.join(` ${G.dot} `)}${more}`);+ }++ if (info.dirname) parts.push(`${C.dim}${info.dirname}${C.reset}`);+ return parts.join(SEP);+}++/**+ * Enabled plugins with versions, ecc first.+ * Reads installed_plugins.json (v2) and settings.json enabledPlugins.+ * @param {string} [claudeDir] - defaults to CLAUDE_CONFIG_DIR or ~/.claude+ * @returns {Array<{name: string, version: string}>}+ */+function readInstalledPlugins(claudeDir) {+ try {+ const dir = claudeDir || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');+ const installed = JSON.parse(+ fs.readFileSync(path.join(dir, 'plugins', 'installed_plugins.json'), 'utf8')+ );+ let enabled = null;+ try {+ const settings = JSON.parse(fs.readFileSync(path.join(dir, 'settings.json'), 'utf8'));+ if (settings.enabledPlugins && typeof settings.enabledPlugins === 'object') {+ enabled = settings.enabledPlugins;+ }+ } catch { /* no settings \u2014 show all installed */ }++ const plugins = [];+ for (const [id, entries] of Object.entries(installed?.plugins || {})) {+ if (enabled && enabled[id] === false) continue;+ const entry = Array.isArray(entries) ? entries[0] : entries;+ plugins.push({ name: id.split('@')[0], version: entry?.version || '' });+ }+ plugins.sort((a, b) => (a.name === 'ecc' ? -1 : b.name === 'ecc' ? 1 : a.name.localeCompare(b.name)));+ return plugins;+ } catch {+ return [];+ }+}++/**+ * Hooks status summary from ECC hook flags (env + managed config).+ */+function getHooksSummary(env = process.env) {+ return {+ enabled: areHooksEnabled(env),+ profile: getHookProfile(env),+ disabledCount: getDisabledHookIds(env).size,+ };+}++module.exports = {+ C,+ G,+ SEP,+ UNICODE_GLYPHS,+ ASCII_GLYPHS,+ glyphSet,+ pctColor,+ buildBar,+ formatCountdown,+ formatMs,+ computeCacheStats,+ buildUsageLine,+ buildSessionLine,+ buildEccLine,+ readInstalledPlugins,+ getHooksSummary,+};diff --git a/tests/hooks/ecc-statusline-usage.test.js b/tests/hooks/ecc-statusline-usage.test.jsnew file mode 100644index 000000000..5d045233c--- /dev/null+++ b/tests/hooks/ecc-statusline-usage.test.js@@ -0,0 +1,31 @@+'use strict';++const assert = require('node:assert/strict');+const fs = require('node:fs');+const os = require('node:os');+const path = require('node:path');+const { spawnSync } = require('node:child_process');+const test = require('node:test');++test('actual statusline usage display is opt-in and leaves provider settings alone', () => {+ const home = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-statusline-usage-'));+ try {+ const payload = { model: { display_name: 'Claude fixture' }, context_window: { remaining_percentage: 80 },+ rate_limits: { five_hour: { used_percentage: 20, resets_at: Math.floor(Date.now() / 1000) + 3600 } } };+ const render = value => {+ const child = spawnSync(process.execPath, [path.resolve(__dirname, '../../scripts/hooks/ecc-statusline.js')], {+ input: JSON.stringify(payload), encoding: 'utf8', timeout: 5000,+ env: { ...process.env, HOME: home, USERPROFILE: home, CLAUDE_CONFIG_DIR: home,+ ECC_STATUSLINE_USAGE: value, ECC_BAR_GLYPHS: 'ascii' },+ });+ assert.equal(child.status, 0, child.stderr);+ return child.stdout;+ };+ assert.equal(render('0').split('\n').length, 1);+ assert.ok(render('1').split('\n').length >= 2);+ assert.match(render('1'), /5h/);+ assert.deepEqual(fs.readdirSync(home), []);+ } finally {+ fs.rmSync(home, { recursive: true, force: true });+ }+});diff --git a/tests/lib/statusline-render.test.js b/tests/lib/statusline-render.test.jsnew file mode 100644index 000000000..a46fd96f4--- /dev/null+++ b/tests/lib/statusline-render.test.js@@ -0,0 +1,288 @@+/**+ * Tests for scripts/lib/statusline-render.js+ *+ * Run with: node tests/lib/statusline-render.test.js+ */++const assert = require('assert');+const fs = require('fs');+const os = require('os');+const path = require('path');++const {+ C,+ G,+ pctColor,+ buildBar,+ formatCountdown,+ formatMs,+ computeCacheStats,+ buildUsageLine,+ buildSessionLine,+ buildEccLine,+ readInstalledPlugins,+ getHooksSummary,+} = require('../../scripts/lib/statusline-render');++function test(name, fn) {+ try {+ fn();+ console.log(` \u2713 ${name}`);+ return true;+ } catch (err) {+ console.log(` \u2717 ${name}`);+ console.log(` Error: ${err.message}`);+ return false;+ }+}++function runTests() {+ console.log('\n=== Testing statusline-render.js ===\n');++ let passed = 0;+ let failed = 0;+ const t = (name, fn) => (test(name, fn) ? passed++ : failed++);++ console.log('buildBar:');+ t('0% renders all empty blocks', () => {+ assert.strictEqual(buildBar(0, 8), G.empty.repeat(8));+ });+ t('100% renders all full blocks', () => {+ assert.strictEqual(buildBar(100, 8), G.full.repeat(8));+ });+ t('50% renders half full', () => {+ assert.strictEqual(buildBar(50, 8), G.full.repeat(4) + G.empty.repeat(4));+ });+ t('clamps values beyond 100', () => {+ assert.strictEqual(buildBar(250, 4), G.full.repeat(4));+ });+ t('clamps negative values', () => {+ assert.strictEqual(buildBar(-10, 4), G.empty.repeat(4));+ });++ console.log('\nglyphSet:');+ t('non-UTF-8 locale falls back to ASCII glyphs', () => {+ const { glyphSet, ASCII_GLYPHS } = require('../../scripts/lib/statusline-render');+ assert.strictEqual(glyphSet({ LANG: 'C' }), ASCII_GLYPHS);+ assert.strictEqual(glyphSet({}), ASCII_GLYPHS);+ });+ t('UTF-8 locale uses unicode glyphs', () => {+ const { glyphSet, UNICODE_GLYPHS } = require('../../scripts/lib/statusline-render');+ assert.strictEqual(glyphSet({ LANG: 'en_US.UTF-8' }), UNICODE_GLYPHS);+ assert.strictEqual(glyphSet({ LC_ALL: 'C.utf8' }), UNICODE_GLYPHS);+ });+ t('ECC_BAR_GLYPHS forces either set', () => {+ const { glyphSet, ASCII_GLYPHS, UNICODE_GLYPHS } = require('../../scripts/lib/statusline-render');+ assert.strictEqual(glyphSet({ LANG: 'en_US.UTF-8', ECC_BAR_GLYPHS: 'ascii' }), ASCII_GLYPHS);+ assert.strictEqual(glyphSet({ LANG: 'C', ECC_BAR_GLYPHS: 'unicode' }), UNICODE_GLYPHS);+ });++ console.log('\npctColor:');+ t('below 60 uses brand color', () => {+ assert.strictEqual(pctColor(59, C.amber), C.amber);+ });+ t('60-79 is yellow', () => {+ assert.strictEqual(pctColor(60), C.yellow);+ });+ t('80-89 is orange', () => {+ assert.strictEqual(pctColor(80), C.orange);+ });+ t('90+ is red', () => {+ assert.strictEqual(pctColor(95), C.red);+ });++ console.log('\nformatCountdown:');+ t('past timestamp returns empty', () => {+ assert.strictEqual(formatCountdown(Date.now() / 1000 - 60), '');+ });+ t('invalid input returns empty', () => {+ assert.strictEqual(formatCountdown(null), '');+ assert.strictEqual(formatCountdown('soon'), '');+ });+ t('minutes-scale countdown ends with m', () => {+ const result = formatCountdown(Date.now() / 1000 + 42 * 60);+ assert.ok(/^\d+m$/.test(result), `got: ${result}`);+ });+ t('hours-scale countdown contains h', () => {+ const result = formatCountdown(Date.now() / 1000 + 90 * 60);+ assert.ok(result.includes('h'), `got: ${result}`);+ });+ t('days-scale countdown ends with d', () => {+ const result = formatCountdown(Date.now() / 1000 + 3 * 24 * 3600 + 60);+ assert.ok(/^\d+d$/.test(result), `got: ${result}`);+ });++ console.log('\nformatMs:');+ t('zero returns empty', () => {+ assert.strictEqual(formatMs(0), '');+ });+ t('seconds scale', () => {+ assert.strictEqual(formatMs(30 * 1000), '30s');+ });+ t('minutes scale', () => {+ assert.strictEqual(formatMs(5 * 60 * 1000), '5m');+ });+ t('hours scale with remainder', () => {+ assert.strictEqual(formatMs((3 * 60 + 11) * 60 * 1000), '3h11m');+ });++ console.log('\ncomputeCacheStats:');+ t('null usage returns null', () => {+ assert.strictEqual(computeCacheStats(null), null);+ });+ t('zero tokens returns null', () => {+ assert.strictEqual(computeCacheStats({ input_tokens: 0 }), null);+ });+ t('computes hit percentage from cache reads', () => {+ const stats = computeCacheStats({+ input_tokens: 10,+ cache_creation_input_tokens: 10,+ cache_read_input_tokens: 80,+ });+ assert.strictEqual(stats.hitPct, 80);+ });++ console.log('\nbuildUsageLine:');+ t('no rate limits returns empty string', () => {+ assert.strictEqual(buildUsageLine(undefined, { hitPct: 90 }), '');+ assert.strictEqual(buildUsageLine({}, null), '');+ });+ t('renders both windows with percentages', () => {+ const line = buildUsageLine({+ five_hour: { used_percentage: 71, resets_at: Date.now() / 1000 + 3600 },+ seven_day: { used_percentage: 23, resets_at: Date.now() / 1000 + 86400 * 3 },+ }, null);+ assert.ok(line.includes('5h'), 'expected 5h label');+ assert.ok(line.includes('7d'), 'expected 7d label');+ assert.ok(line.includes('71%'), 'expected 5h percentage');+ assert.ok(line.includes('23%'), 'expected 7d percentage');+ assert.ok(line.includes(G.reset), 'expected reset countdown');+ });+ t('renders a single window when only one exists', () => {+ const line = buildUsageLine({ five_hour: { used_percentage: 5 } }, null);+ assert.ok(line.includes('5h'), 'expected 5h label');+ assert.ok(!line.includes('7d'), 'no 7d label expected');+ });+ t('appends cache hit rate when bars exist', () => {+ const line = buildUsageLine({ five_hour: { used_percentage: 5 } }, { hitPct: 98 });+ assert.ok(line.includes('cache'), 'expected cache segment');+ assert.ok(line.includes('98%'), 'expected cache percentage');+ });++ console.log('\nbuildSessionLine:');+ t('shows model with effort badge', () => {+ const line = buildSessionLine({ model: 'Opus 5', effort: 'xhigh' });+ assert.ok(line.includes('Opus 5'), 'expected model name');+ assert.ok(line.includes('xhigh'), 'expected effort badge');+ });+ t('default effort high shows no badge', () => {+ const line = buildSessionLine({ model: 'Opus 5', effort: 'high' });+ assert.ok(!line.includes('high'), 'no badge expected for default effort');+ });+ t('shows cost, diff, and task', () => {+ const line = buildSessionLine({+ model: 'Opus 5',+ costUsd: 1.234,+ linesAdded: 11,+ linesRemoved: 4,+ durationMs: 60 * 1000,+ task: 'Fixing auth bug',+ });+ assert.ok(line.includes('$1.23'), 'expected cost');+ assert.ok(line.includes('+11/-4'), 'expected diff stats');+ assert.ok(line.includes('1m'), 'expected duration');+ assert.ok(line.includes('Fixing auth bug'), 'expected task');+ });+ t('shows 1M context window size', () => {+ const line = buildSessionLine({ model: 'Opus 5', ctxBar: ' bar 10%', ctxWindowSize: 1000000 });+ assert.ok(line.includes('1M'), 'expected 1M badge');+ });++ console.log('\nbuildEccLine:');+ t('shows version, hooks profile, plugins, dirname', () => {+ const line = buildEccLine({+ eccVersion: '2.2.0',+ hooks: { enabled: true, profile: 'standard', disabledCount: 0 },+ plugins: [{ name: 'ecc', version: '2.2.0' }, { name: 'swift-lsp', version: '1.0.0' }],+ dirname: 'myproject',+ });+ assert.ok(line.includes('ECC 2.2.0'), 'expected ECC version');+ assert.ok(line.includes('hooks standard'), 'expected hooks profile');+ assert.ok(line.includes('swift-lsp'), 'expected plugin name');+ assert.ok(line.includes('1.0.0'), 'expected plugin version');+ assert.ok(line.includes('myproject'), 'expected dirname');+ });+ t('disabled hooks render hooks off', () => {+ const line = buildEccLine({ hooks: { enabled: false, profile: 'standard', disabledCount: 0 } });+ assert.ok(line.includes('hooks off'), 'expected hooks off');+ });+ t('disabled hook count is shown', () => {+ const line = buildEccLine({ hooks: { enabled: true, profile: 'minimal', disabledCount: 2 } });+ assert.ok(line.includes('(2 off)'), 'expected disabled count');+ });+ t('caps plugin list at 4 with overflow count', () => {+ const plugins = ['a', 'b', 'c', 'd', 'e', 'f'].map(name => ({ name, version: '1.0.0' }));+ const line = buildEccLine({ plugins });+ assert.ok(line.includes('+2'), 'expected +2 overflow');+ });++ console.log('\nreadInstalledPlugins:');+ t('reads v2 plugin file and filters disabled plugins, ecc first', () => {+ const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-render-test-'));+ try {+ fs.mkdirSync(path.join(tmpDir, 'plugins'), { recursive: true });+ fs.writeFileSync(path.join(tmpDir, 'plugins', 'installed_plugins.json'), JSON.stringify({+ version: 2,+ plugins: {+ 'zeta@market': [{ version: '0.5.0', scope: 'user' }],+ 'ecc@ecc': [{ version: '2.2.0', scope: 'user' }],+ 'off-plugin@market': [{ version: '9.9.9', scope: 'user' }],+ },+ }));+ fs.writeFileSync(path.join(tmpDir, 'settings.json'), JSON.stringify({+ enabledPlugins: { 'zeta@market': true, 'ecc@ecc': true, 'off-plugin@market': false },+ }));++ const plugins = readInstalledPlugins(tmpDir);+ assert.strictEqual(plugins.length, 2);+ assert.strictEqual(plugins[0].name, 'ecc');+ assert.strictEqual(plugins[0].version, '2.2.0');+ assert.strictEqual(plugins[1].name, 'zeta');+ } finally {+ fs.rmSync(tmpDir, { recursive: true, force: true });+ }+ });+ t('missing plugin file returns empty array', () => {+ const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-render-test-'));+ try {+ assert.deepStrictEqual(readInstalledPlugins(tmpDir), []);+ } finally {+ fs.rmSync(tmpDir, { recursive: true, force: true });+ }+ });++ console.log('\ngetHooksSummary:');+ t('defaults to enabled standard profile', () => {+ const summary = getHooksSummary({});+ assert.strictEqual(summary.enabled, true);+ assert.strictEqual(summary.profile, 'standard');+ assert.strictEqual(summary.disabledCount, 0);+ });+ t('respects ECC_HOOKS_ENABLED=false', () => {+ assert.strictEqual(getHooksSummary({ ECC_HOOKS_ENABLED: 'false' }).enabled, false);+ });+ t('reports profile and disabled hook count', () => {+ const summary = getHooksSummary({+ ECC_HOOK_PROFILE: 'minimal',+ ECC_DISABLED_HOOKS: 'a,b',+ });+ assert.strictEqual(summary.profile, 'minimal');+ assert.strictEqual(summary.disabledCount, 2);+ });++ console.log(`\nResults: ${passed} passed, ${failed} failed\n`);+ return { passed, failed };+}++const { failed } = runTests();+process.exit(failed > 0 ? 1 : 0);