devflow-kit 1.6.1 → 1.8.0

package/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to DevFlow will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.8.0] - 2026-03-22
+
+### Added
+- **Configurable HUD** replacing bash statusline — 14 components, on/off model (#155)
+- **HUD components**: directory, git branch, ahead/behind, diff stats, release info, worktree count, model, context usage, version badge, session duration, session cost, usage quota, todo progress, config counts
+- **`--hud-only` flag** for standalone HUD install
+- **`--no-hud` flag** to skip HUD during init
+- **`devflow hud` command** (--status, --enable, --disable, --detail, --no-detail)
+- **Version upgrade notification**: `✦ Devflow vX.Y.Z · update: npx devflow-kit init` (yellow, always visible even when HUD disabled)
+- **Skill shadowing docs** and HUD options added to README (#156)
+- **Simplifier agent** — 8 structured slop detection categories (#120)
+- **Scrutinizer agent** — stub detection patterns with reference file (#121)
+- **Shepherd agent** — goal-backward verification, artifact depth checking, stub type, re-verification (#124)
+
+### Changed
+- Init flow: HUD preset picker (5 options) → simple yes/no confirm
+- `--disable` keeps statusLine registered (version badge still renders)
+- Manifest `features.hud` field: `string|false` → `boolean`
+
+### Fixed
+- HUD base branch detection matching raw commit hashes from reflog (#156)
+- HUD comparing main vs main (0/0 always) — now compares against origin/main
+
+### Removed
+- HUD preset system (minimal/classic/standard/full)
+- `--configure`, `--preset`, `--hud <preset>` flags
+- `speed`, `tool-activity`, `agent-activity` components
+
+---
+
+## [1.7.0] - 2026-03-20
+
+### Added
+- **Version update notification** — statusline shows magenta `⬆ X.Y.Z` badge when newer devflow-kit is available (24h cached npm check, fully async)
+
+### Fixed
+- **Skimmer agent** — enforce rskim usage via `tools: ["Bash", "Read"]` platform restriction and strict sequential workflow; prevents fallback to Grep/Glob
+- **Init multiselect** — remove redundant "(optional)" suffix from plugin hints
+- **Init multiselect** — hide `audit-claude` plugin (not production-ready; still installable via `--plugin=audit-claude`)
+- **Statusline portability** — replace macOS-only `stat -f %m` with portable `get_mtime()` helper (macOS + Linux)
+
+---
+
 ## [1.6.1] - 2026-03-20
 
 ### Added
@@ -915,6 +958,8 @@ devflow init
 ---
 
 [Unreleased]: https://github.com/dean0x/devflow/compare/v1.4.0...HEAD
+[1.8.0]: https://github.com/dean0x/devflow/compare/v1.7.0...v1.8.0
+[1.7.0]: https://github.com/dean0x/devflow/compare/v1.6.1...v1.7.0
 [1.6.1]: https://github.com/dean0x/devflow/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/dean0x/devflow/compare/v1.5.0...v1.6.0
 [1.5.0]: https://github.com/dean0x/devflow/compare/v1.4.0...v1.5.0

package/README.md

@@ -24,6 +24,7 @@ DevFlow adds structured commands that handle the full lifecycle: specify feature
 - **Full-lifecycle implementation** — spec, explore, plan, code, validate, refine in one command
 - **Automatic session memory** — survives restarts, `/clear`, and context compaction
 - **Parallel debugging** — competing hypotheses investigated simultaneously
+- **Version notifications** — HUD shows `✦ Devflow vX.Y.Z · update: npx devflow-kit init` when a newer version is available
 - **35 quality skills** — 9 auto-activating core, 8 optional language/ecosystem, plus specialized review, agent, and orchestration skills
 
 ## Quick Start
@@ -247,8 +248,38 @@ Session context is saved and restored automatically via Working Memory hooks —
 | `--teams` / `--no-teams` | Enable/disable Agent Teams (experimental, default: off) |
 | `--ambient` / `--no-ambient` | Enable/disable ambient mode (default: on) |
 | `--memory` / `--no-memory` | Enable/disable working memory (default: on) |
+| `--hud-only` | Install only the HUD (no plugins, hooks, or extras) |
+| `--no-hud` | Disable HUD status line |
 | `--verbose` | Show detailed output |
 
+### HUD Options
+
+| Command | Description |
+|---------|-------------|
+| `npx devflow-kit hud --status` | Show current HUD config |
+| `npx devflow-kit hud --enable` | Enable HUD |
+| `npx devflow-kit hud --disable` | Disable HUD (version notifications still appear) |
+| `npx devflow-kit hud --detail` | Show tool/agent descriptions |
+| `npx devflow-kit hud --no-detail` | Hide tool/agent descriptions |
+
+### Skill Shadowing
+
+Override any DevFlow skill with your own version. Shadowed skills survive `devflow init` — they won't be overwritten on reinstall or upgrade.
+
+```bash
+# Create a personal override (copies current version as reference)
+npx devflow-kit skills shadow core-patterns
+
+# Edit your override
+vim ~/.claude/skills/core-patterns/SKILL.md
+
+# List all overrides
+npx devflow-kit skills list-shadowed
+
+# Remove override (next init restores DevFlow's version)
+npx devflow-kit skills unshadow core-patterns
+```
+
 ### Uninstall Options
 
 | Option | Description |

package/dist/cli.js

@@ -9,6 +9,7 @@ import { listCommand } from './commands/list.js';
 import { ambientCommand } from './commands/ambient.js';
 import { memoryCommand } from './commands/memory.js';
 import { skillsCommand } from './commands/skills.js';
+import { hudCommand } from './commands/hud.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Read version from package.json
@@ -19,7 +20,7 @@ program
     .description('Agentic Development Toolkit for Claude Code\n\nEnhance your AI-assisted development with intelligent commands and workflows.')
     .version(packageJson.version, '-v, --version', 'Display version number')
     .helpOption('-h, --help', 'Display help information')
-    .addHelpText('after', '\nExamples:\n  $ devflow init                       Install all DevFlow plugins\n  $ devflow init --plugin=implement    Install specific plugin\n  $ devflow init --plugin=implement,review  Install multiple plugins\n  $ devflow list                       List available plugins\n  $ devflow ambient --enable           Enable always-on ambient mode\n  $ devflow memory --status            Check working memory state\n  $ devflow uninstall                  Remove DevFlow from Claude Code\n  $ devflow --version                  Show version\n  $ devflow --help                     Show help\n\nDocumentation:\n  https://github.com/dean0x/devflow#readme');
+    .addHelpText('after', '\nExamples:\n  $ devflow init                       Install all DevFlow plugins\n  $ devflow init --plugin=implement    Install specific plugin\n  $ devflow init --plugin=implement,review  Install multiple plugins\n  $ devflow list                       List available plugins\n  $ devflow ambient --enable           Enable always-on ambient mode\n  $ devflow memory --status            Check working memory state\n  $ devflow hud --configure            Configure HUD preset\n  $ devflow uninstall                  Remove DevFlow from Claude Code\n  $ devflow --version                  Show version\n  $ devflow --help                     Show help\n\nDocumentation:\n  https://github.com/dean0x/devflow#readme');
 // Register commands
 program.addCommand(initCommand);
 program.addCommand(uninstallCommand);
@@ -27,6 +28,7 @@ program.addCommand(listCommand);
 program.addCommand(ambientCommand);
 program.addCommand(memoryCommand);
 program.addCommand(skillsCommand);
+program.addCommand(hudCommand);
 // Handle no command
 program.action(() => {
     program.help();

package/dist/commands/hud.d.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+/**
+ * Add the HUD statusLine to settings JSON.
+ * Idempotent — returns unchanged JSON if HUD already set.
+ * Upgrades legacy statusline.sh to hud.sh automatically.
+ */
+export declare function addHudStatusLine(settingsJson: string, devflowDir: string): string;
+/**
+ * Remove the HUD statusLine from settings JSON.
+ * Idempotent — returns unchanged JSON if statusLine not present or not DevFlow.
+ */
+export declare function removeHudStatusLine(settingsJson: string): string;
+/**
+ * Check if the statusLine in settings JSON points to the DevFlow HUD.
+ */
+export declare function hasHudStatusLine(settingsJson: string): boolean;
+/**
+ * Check if an existing statusLine belongs to a non-DevFlow tool.
+ */
+export declare function hasNonDevFlowStatusLine(settingsJson: string): boolean;
+export declare const hudCommand: Command;
+//# sourceMappingURL=hud.d.ts.map

package/dist/commands/hud.js

@@ -0,0 +1,180 @@
+import { Command } from 'commander';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import { getClaudeDirectory, getDevFlowDirectory } from '../utils/paths.js';
+import { HUD_COMPONENTS, loadConfig, saveConfig, } from '../hud/config.js';
+/**
+ * Add the HUD statusLine to settings JSON.
+ * Idempotent — returns unchanged JSON if HUD already set.
+ * Upgrades legacy statusline.sh to hud.sh automatically.
+ */
+export function addHudStatusLine(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    const hudCommand = path.join(devflowDir, 'scripts', 'hud.sh');
+    // Already pointing to this exact HUD — nothing to do
+    if (settings.statusLine?.command === hudCommand) {
+        return settingsJson;
+    }
+    // If there's a non-DevFlow statusLine, don't overwrite (caller should check first)
+    if (settings.statusLine && !isDevFlowStatusLine(settings.statusLine)) {
+        return settingsJson;
+    }
+    settings.statusLine = {
+        type: 'command',
+        command: hudCommand,
+    };
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove the HUD statusLine from settings JSON.
+ * Idempotent — returns unchanged JSON if statusLine not present or not DevFlow.
+ */
+export function removeHudStatusLine(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.statusLine) {
+        return settingsJson;
+    }
+    // Only remove if it's a DevFlow HUD/statusline
+    if (!isDevFlowStatusLine(settings.statusLine)) {
+        return settingsJson;
+    }
+    delete settings.statusLine;
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if the statusLine in settings JSON points to the DevFlow HUD.
+ */
+export function hasHudStatusLine(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.statusLine)
+        return false;
+    return isDevFlowStatusLine(settings.statusLine);
+}
+/**
+ * Check if an existing statusLine belongs to DevFlow (HUD or legacy statusline).
+ * Matches paths containing 'hud.sh', 'statusline.sh', or a '/devflow/' directory segment.
+ */
+function isDevFlowStatusLine(statusLine) {
+    const cmd = statusLine.command ?? '';
+    return (cmd.includes('hud.sh') ||
+        cmd.includes('statusline.sh') ||
+        cmd.includes('/devflow/') ||
+        cmd.includes('\\devflow\\'));
+}
+/**
+ * Check if an existing statusLine belongs to a non-DevFlow tool.
+ */
+export function hasNonDevFlowStatusLine(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.statusLine?.command)
+        return false;
+    return !isDevFlowStatusLine(settings.statusLine);
+}
+export const hudCommand = new Command('hud')
+    .description('Configure the HUD (status line)')
+    .option('--status', 'Show current HUD config')
+    .option('--detail', 'Show tool/agent descriptions in HUD')
+    .option('--no-detail', 'Hide tool/agent descriptions')
+    .option('--enable', 'Enable HUD in settings')
+    .option('--disable', 'Disable HUD (remove statusLine)')
+    .action(async (options) => {
+    const hasFlag = options.status ||
+        options.enable ||
+        options.disable ||
+        options.detail !== undefined;
+    if (!hasFlag) {
+        p.intro(color.bgCyan(color.white(' HUD ')));
+        p.note(`${color.cyan('devflow hud --detail')}      Show tool/agent descriptions\n` +
+            `${color.cyan('devflow hud --no-detail')}   Hide tool/agent descriptions\n` +
+            `${color.cyan('devflow hud --status')}      Show current config\n` +
+            `${color.cyan('devflow hud --enable')}      Enable HUD in settings\n` +
+            `${color.cyan('devflow hud --disable')}     Remove HUD from settings`, 'Usage');
+        p.note(`${HUD_COMPONENTS.length} components: ${HUD_COMPONENTS.join(', ')}`, 'Components');
+        p.outro(color.dim('Toggle with --enable / --disable'));
+        return;
+    }
+    if (options.status) {
+        const config = loadConfig();
+        p.intro(color.bgCyan(color.white(' HUD Status ')));
+        p.note(`${color.dim('Enabled:')}    ${config.enabled ? color.green('yes') : color.dim('no')}\n` +
+            `${color.dim('Detail:')}     ${config.detail ? color.green('on') : color.dim('off')}\n` +
+            `${color.dim('Components:')} ${HUD_COMPONENTS.length}`, 'Current config');
+        // Check settings.json
+        const claudeDir = getClaudeDirectory();
+        const settingsPath = path.join(claudeDir, 'settings.json');
+        try {
+            const content = await fs.readFile(settingsPath, 'utf-8');
+            const enabled = hasHudStatusLine(content);
+            p.log.info(`Status line: ${enabled ? color.green('enabled') : color.dim('disabled')}`);
+        }
+        catch {
+            p.log.info(`Status line: ${color.dim('no settings.json found')}`);
+        }
+        return;
+    }
+    if (options.detail !== undefined) {
+        const config = loadConfig();
+        config.detail = options.detail;
+        saveConfig(config);
+        p.log.success(`HUD detail ${config.detail ? 'enabled' : 'disabled'}`);
+        return;
+    }
+    if (options.enable) {
+        const claudeDir = getClaudeDirectory();
+        const settingsPath = path.join(claudeDir, 'settings.json');
+        let settingsContent;
+        try {
+            settingsContent = await fs.readFile(settingsPath, 'utf-8');
+        }
+        catch {
+            settingsContent = '{}';
+        }
+        // Ensure statusLine is registered
+        if (!hasHudStatusLine(settingsContent)) {
+            // Check for non-DevFlow statusLine
+            if (hasNonDevFlowStatusLine(settingsContent)) {
+                const settings = JSON.parse(settingsContent);
+                p.log.warn(`Existing statusLine found: ${color.dim(settings.statusLine?.command ?? 'unknown')}`);
+                if (process.stdin.isTTY) {
+                    const overwrite = await p.confirm({
+                        message: 'Replace existing statusLine with DevFlow HUD?',
+                        initialValue: false,
+                    });
+                    if (p.isCancel(overwrite) || !overwrite) {
+                        p.log.info('HUD not enabled — existing statusLine preserved');
+                        return;
+                    }
+                }
+                else {
+                    p.log.info('Non-interactive mode — skipping (existing statusLine would be overwritten)');
+                    return;
+                }
+            }
+            const devflowDir = getDevFlowDirectory();
+            const updated = addHudStatusLine(settingsContent, devflowDir);
+            await fs.writeFile(settingsPath, updated, 'utf-8');
+        }
+        // Update config
+        const config = loadConfig();
+        if (config.enabled) {
+            p.log.info('HUD already enabled');
+            return;
+        }
+        saveConfig({ ...config, enabled: true });
+        p.log.success('HUD enabled');
+        p.log.info(color.dim('Restart Claude Code to see the HUD'));
+    }
+    if (options.disable) {
+        const config = loadConfig();
+        if (!config.enabled) {
+            p.log.info('HUD already disabled');
+            return;
+        }
+        saveConfig({ ...config, enabled: false });
+        p.log.success('HUD disabled');
+        p.log.info(color.dim('Version upgrade notifications will still appear'));
+    }
+});
+//# sourceMappingURL=hud.js.map

package/dist/commands/init.d.ts

@@ -3,6 +3,7 @@ import { type PluginDefinition } from '../plugins.js';
 export { substituteSettingsTemplate, computeGitignoreAppend, applyTeamsConfig, stripTeamsConfig, mergeDenyList } from '../utils/post-install.js';
 export { addAmbientHook, removeAmbientHook, hasAmbientHook } from './ambient.js';
 export { addMemoryHooks, removeMemoryHooks, hasMemoryHooks } from './memory.js';
+export { addHudStatusLine, removeHudStatusLine, hasHudStatusLine } from './hud.js';
 /**
  * Parse a comma-separated plugin selection string into normalized plugin names.
  * Validates against known plugins; returns invalid names as errors.

package/dist/commands/init.js

@@ -8,18 +8,21 @@ import color from 'picocolors';
 import { getInstallationPaths } from '../utils/paths.js';
 import { getGitRoot } from '../utils/git.js';
 import { isClaudeCliAvailable } from '../utils/cli.js';
-import { installViaCli, installViaFileCopy } from '../utils/installer.js';
+import { installViaCli, installViaFileCopy, copyDirectory } from '../utils/installer.js';
 import { installSettings, installManagedSettings, installClaudeignore, updateGitignore, createDocsStructure, createMemoryDir, migrateMemoryFiles, } from '../utils/post-install.js';
 import { DEVFLOW_PLUGINS, LEGACY_SKILL_NAMES, LEGACY_COMMAND_NAMES, buildAssetMaps } from '../plugins.js';
 import { detectPlatform, detectShell, getProfilePath, getSafeDeleteInfo, hasSafeDelete } from '../utils/safe-delete.js';
 import { generateSafeDeleteBlock, installToProfile, removeFromProfile, getInstalledVersion, SAFE_DELETE_BLOCK_VERSION } from '../utils/safe-delete-install.js';
 import { addAmbientHook } from './ambient.js';
 import { addMemoryHooks, removeMemoryHooks } from './memory.js';
+import { addHudStatusLine, removeHudStatusLine } from './hud.js';
+import { loadConfig as loadHudConfig, saveConfig as saveHudConfig } from '../hud/config.js';
 import { readManifest, writeManifest, resolvePluginList, detectUpgrade } from '../utils/manifest.js';
 // Re-export pure functions for tests (canonical source is post-install.ts)
 export { substituteSettingsTemplate, computeGitignoreAppend, applyTeamsConfig, stripTeamsConfig, mergeDenyList } from '../utils/post-install.js';
 export { addAmbientHook, removeAmbientHook, hasAmbientHook } from './ambient.js';
 export { addMemoryHooks, removeMemoryHooks, hasMemoryHooks } from './memory.js';
+export { addHudStatusLine, removeHudStatusLine, hasHudStatusLine } from './hud.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -66,6 +69,8 @@ export const initCommand = new Command('init')
     .option('--no-ambient', 'Disable ambient mode')
     .option('--memory', 'Enable working memory (session context preservation)')
     .option('--no-memory', 'Disable working memory hooks')
+    .option('--no-hud', 'Disable HUD status line')
+    .option('--hud-only', 'Install only the HUD (no plugins, hooks, or extras)')
     .action(async (options) => {
     // Get package version
     const packageJsonPath = path.resolve(__dirname, '../../package.json');
@@ -82,7 +87,11 @@ export const initCommand = new Command('init')
     p.intro(color.bgCyan(color.black(` DevFlow v${version} `)));
     // Determine installation scope
     let scope = 'user';
-    if (options.scope) {
+    if (options.hudOnly) {
+        // --hud-only: skip scope prompt, always user scope
+        scope = 'user';
+    }
+    else if (options.scope) {
         const normalizedScope = options.scope.toLowerCase();
         if (normalizedScope !== 'user' && normalizedScope !== 'local') {
             p.log.error('Invalid scope. Use "user" or "local"');
@@ -108,6 +117,70 @@ export const initCommand = new Command('init')
         }
         scope = selected;
     }
+    // --hud-only: install only HUD (skip plugins, hooks, extras)
+    if (options.hudOnly) {
+        // Resolve paths
+        const paths = await getInstallationPaths(scope);
+        const claudeDir = paths.claudeDir;
+        const devflowDir = paths.devflowDir;
+        // Save HUD config
+        const existingHud = loadHudConfig();
+        saveHudConfig({ enabled: true, detail: existingHud.detail });
+        // Update statusLine in settings.json
+        const settingsPath = path.join(claudeDir, 'settings.json');
+        try {
+            let content;
+            try {
+                content = await fs.readFile(settingsPath, 'utf-8');
+            }
+            catch {
+                content = '{}';
+            }
+            const updated = addHudStatusLine(content, devflowDir);
+            await fs.writeFile(settingsPath, updated, 'utf-8');
+        }
+        catch (error) {
+            p.log.error(`Failed to update settings: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        }
+        // Copy HUD scripts to devflow dir
+        const rootDir = path.resolve(__dirname, '..', '..');
+        const scriptsSource = path.join(rootDir, 'scripts');
+        const scriptsTarget = path.join(devflowDir, 'scripts');
+        try {
+            await fs.mkdir(scriptsTarget, { recursive: true });
+            // Copy hud.sh
+            await fs.copyFile(path.join(scriptsSource, 'hud.sh'), path.join(scriptsTarget, 'hud.sh'));
+            // Copy hud/ directory
+            const hudSource = path.join(scriptsSource, 'hud');
+            const hudTarget = path.join(scriptsTarget, 'hud');
+            await copyDirectory(hudSource, hudTarget);
+            if (process.platform !== 'win32') {
+                await fs.chmod(path.join(scriptsTarget, 'hud.sh'), 0o755);
+            }
+        }
+        catch (error) {
+            p.log.error(`Failed to copy HUD scripts: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        }
+        // Write minimal manifest
+        const now = new Date().toISOString();
+        try {
+            await writeManifest(devflowDir, {
+                version,
+                plugins: [],
+                scope,
+                features: { teams: false, ambient: false, memory: false, hud: true },
+                installedAt: now,
+                updatedAt: now,
+            });
+        }
+        catch { /* non-fatal */ }
+        p.log.success('HUD installed');
+        p.log.info(`Configure later: ${color.cyan('devflow hud --status')}`);
+        p.outro(color.green('HUD-only install complete.'));
+        return;
+    }
     // Select plugins to install
     let selectedPlugins = [];
     if (options.plugin) {
@@ -121,11 +194,11 @@ export const initCommand = new Command('init')
     }
     else if (process.stdin.isTTY) {
         const choices = DEVFLOW_PLUGINS
-            .filter(pl => pl.name !== 'devflow-core-skills' && pl.name !== 'devflow-ambient')
+            .filter(pl => pl.name !== 'devflow-core-skills' && pl.name !== 'devflow-ambient' && pl.name !== 'devflow-audit-claude')
             .map(pl => ({
             value: pl.name,
             label: pl.name.replace('devflow-', ''),
-            hint: pl.description + (pl.optional ? ' (optional)' : ''),
+            hint: pl.description,
         }));
         const preSelected = DEVFLOW_PLUGINS
             .filter(pl => !pl.optional && pl.name !== 'devflow-core-skills' && pl.name !== 'devflow-ambient')
@@ -205,6 +278,25 @@ export const initCommand = new Command('init')
         }
         memoryEnabled = memoryChoice;
     }
+    // HUD selection (yes/no)
+    let hudEnabled;
+    if (options.hud !== undefined) {
+        hudEnabled = options.hud;
+    }
+    else if (!process.stdin.isTTY) {
+        hudEnabled = true;
+    }
+    else {
+        const hudChoice = await p.confirm({
+            message: 'Enable HUD status line?',
+            initialValue: true,
+        });
+        if (p.isCancel(hudChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        hudEnabled = hudChoice;
+    }
     // Security deny list placement (user scope + TTY only)
     let securityMode = 'user';
     if (scope === 'user' && process.stdin.isTTY) {
@@ -442,6 +534,23 @@ export const initCommand = new Command('init')
             await createMemoryDir(verbose);
             await migrateMemoryFiles(verbose);
         }
+        // Configure HUD
+        const existingHud = loadHudConfig();
+        saveHudConfig({ enabled: hudEnabled, detail: existingHud.detail });
+        // Update statusLine in settings.json (add or remove based on choice)
+        try {
+            const hudContent = await fs.readFile(settingsPath, 'utf-8');
+            const hudUpdated = hudEnabled
+                ? addHudStatusLine(hudContent, devflowDir)
+                : removeHudStatusLine(hudContent);
+            if (hudUpdated !== hudContent) {
+                await fs.writeFile(settingsPath, hudUpdated, 'utf-8');
+                if (verbose) {
+                    p.log.info(`HUD ${hudEnabled ? 'enabled' : 'disabled'}`);
+                }
+            }
+        }
+        catch { /* settings.json may not exist yet */ }
     }
     const fileExtras = selectedExtras.filter(e => e !== 'settings' && e !== 'safe-delete');
     if (fileExtras.length > 0) {
@@ -542,7 +651,7 @@ export const initCommand = new Command('init')
         version,
         plugins: resolvePluginList(installedPluginNames, existingManifest, !!options.plugin),
         scope,
-        features: { teams: teamsEnabled, ambient: ambientEnabled, memory: memoryEnabled },
+        features: { teams: teamsEnabled, ambient: ambientEnabled, memory: memoryEnabled, hud: hudEnabled },
         installedAt: existingManifest?.installedAt ?? now,
         updatedAt: now,
     };

package/dist/commands/list.js

@@ -15,6 +15,7 @@ export function formatFeatures(features) {
         features.teams ? 'teams' : null,
         features.ambient ? 'ambient' : null,
         features.memory ? 'memory' : null,
+        features.hud ? 'hud' : null,
     ].filter(Boolean).join(', ') || 'none';
 }
 /**

package/dist/commands/uninstall.js

@@ -11,6 +11,7 @@ import { isClaudeCliAvailable } from '../utils/cli.js';
 import { DEVFLOW_PLUGINS, getAllSkillNames, LEGACY_SKILL_NAMES } from '../plugins.js';
 import { removeAmbientHook } from './ambient.js';
 import { removeMemoryHooks } from './memory.js';
+import { removeHudStatusLine } from './hud.js';
 import { listShadowed } from './skills.js';
 import { detectShell, getProfilePath } from '../utils/safe-delete.js';
 import { isAlreadyInstalled, removeFromProfile } from '../utils/safe-delete-install.js';
@@ -360,23 +361,15 @@ export const uninstallCommand = new Command('uninstall')
             try {
                 const paths = await getInstallationPaths(scope);
                 const settingsPath = path.join(paths.claudeDir, 'settings.json');
-                let settingsContent = await fs.readFile(settingsPath, 'utf-8');
-                // Always remove ambient hook on full uninstall (idempotent)
-                const withoutAmbient = removeAmbientHook(settingsContent);
-                if (withoutAmbient !== settingsContent) {
-                    await fs.writeFile(settingsPath, withoutAmbient, 'utf-8');
-                    settingsContent = withoutAmbient;
+                const originalContent = await fs.readFile(settingsPath, 'utf-8');
+                // Remove all DevFlow hooks in one pass (idempotent)
+                let settingsContent = removeAmbientHook(originalContent);
+                settingsContent = removeMemoryHooks(settingsContent);
+                settingsContent = removeHudStatusLine(settingsContent);
+                if (settingsContent !== originalContent) {
+                    await fs.writeFile(settingsPath, settingsContent, 'utf-8');
                     if (verbose) {
-                        p.log.success(`Ambient mode hook removed from settings.json (${scope})`);
-                    }
-                }
-                // Always remove memory hooks on full uninstall (idempotent)
-                const withoutMemory = removeMemoryHooks(settingsContent);
-                if (withoutMemory !== settingsContent) {
-                    await fs.writeFile(settingsPath, withoutMemory, 'utf-8');
-                    settingsContent = withoutMemory;
-                    if (verbose) {
-                        p.log.success(`Memory hooks removed from settings.json (${scope})`);
+                        p.log.success(`DevFlow hooks removed from settings.json (${scope})`);
                     }
                 }
                 const settings = JSON.parse(settingsContent);

package/dist/hud/cache.d.ts

@@ -0,0 +1,14 @@
+export declare function getCacheDir(): string;
+/**
+ * Read a cached value. Returns null if missing or expired.
+ */
+export declare function readCache<T>(key: string): T | null;
+/**
+ * Read a cached value regardless of TTL (stale data). Returns null if missing.
+ */
+export declare function readCacheStale<T>(key: string): T | null;
+/**
+ * Write a value to cache with a TTL in milliseconds.
+ */
+export declare function writeCache<T>(key: string, data: T, ttlMs: number): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/hud/cache.js

@@ -0,0 +1,54 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+export function getCacheDir() {
+    const devflowDir = process.env.DEVFLOW_DIR || path.join(process.env.HOME || homedir(), '.devflow');
+    return path.join(devflowDir, 'cache');
+}
+/**
+ * Read a cached value. Returns null if missing or expired.
+ * When `ignoreExpiry` is true, returns data regardless of TTL (stale read).
+ */
+function readCacheEntry(key, ignoreExpiry) {
+    try {
+        const filePath = path.join(getCacheDir(), `${key}.json`);
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const entry = JSON.parse(raw);
+        if (ignoreExpiry || Date.now() - entry.timestamp < entry.ttl) {
+            return entry.data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read a cached value. Returns null if missing or expired.
+ */
+export function readCache(key) {
+    return readCacheEntry(key, false);
+}
+/**
+ * Read a cached value regardless of TTL (stale data). Returns null if missing.
+ */
+export function readCacheStale(key) {
+    return readCacheEntry(key, true);
+}
+/**
+ * Write a value to cache with a TTL in milliseconds.
+ */
+export function writeCache(key, data, ttlMs) {
+    try {
+        const dir = getCacheDir();
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const entry = { data, timestamp: Date.now(), ttl: ttlMs };
+        fs.writeFileSync(path.join(dir, `${key}.json`), JSON.stringify(entry));
+    }
+    catch {
+        // Cache write failure is non-fatal
+    }
+}
+//# sourceMappingURL=cache.js.map