devflow-kit 1.7.0 → 1.8.1

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 { installSettings, installManagedSettings, installClaudeignore, updateGitignore, createDocsStructure, createMemoryDir, migrateMemoryFiles, } from '../utils/post-install.js';
+import { installViaCli, installViaFileCopy, copyDirectory } from '../utils/installer.js';
+import { installSettings, installManagedSettings, installClaudeignore, discoverProjectGitRoots, 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 { substituteSettingsTemplate, computeGitignoreAppend, applyTeamsConfig, stripTeamsConfig, mergeDenyList, discoverProjectGitRoots } 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);
 /**
@@ -35,26 +38,6 @@ export function parsePluginSelection(input, validPlugins) {
     const invalid = selected.filter(p => !validNames.includes(p));
     return { selected, invalid };
 }
-/**
- * Build the list of configuration extras available for the given scope/git context.
- * Pure function — no I/O, no side effects.
- */
-export function buildExtrasOptions(scope, gitRoot) {
-    const options = [
-        { value: 'settings', label: 'Settings & Working Memory', hint: 'Model defaults, session memory hooks, status line' },
-    ];
-    if (gitRoot) {
-        options.push({ value: 'claudeignore', label: '.claudeignore', hint: 'Exclude secrets, deps, build artifacts from Claude context' });
-    }
-    if (scope === 'local' && gitRoot) {
-        options.push({ value: 'gitignore', label: '.gitignore entries', hint: 'Add .claude/ and .devflow/ to .gitignore' });
-    }
-    if (scope === 'local') {
-        options.push({ value: 'docs', label: '.docs/ directory', hint: 'Review reports, dev logs, status tracking for this project' });
-    }
-    options.push({ value: 'safe-delete', label: 'Safe-delete (rm → trash)', hint: 'Override rm to use trash CLI — prevents accidental deletion' });
-    return options;
-}
 export const initCommand = new Command('init')
     .description('Initialize DevFlow for Claude Code')
     .option('--scope <type>', 'Installation scope: user or local (project-only)', /^(user|local)$/i)
@@ -66,6 +49,9 @@ 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('--hud', 'Enable HUD (git info, context usage, session stats)')
+    .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 +68,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 +98,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) {
@@ -120,12 +174,29 @@ export const initCommand = new Command('init')
         }
     }
     else if (process.stdin.isTTY) {
+        // Short hints to prevent overflow in multiselect — full descriptions live in plugins.ts
+        const pluginHints = {
+            'devflow-specify': 'feature specs → GitHub issues',
+            'devflow-implement': 'explore, plan, code, review',
+            'devflow-code-review': 'parallel specialized reviewers',
+            'devflow-resolve': 'fix review issues by risk',
+            'devflow-debug': 'competing hypotheses',
+            'devflow-self-review': 'Simplifier + Scrutinizer',
+            'devflow-typescript': 'TypeScript patterns',
+            'devflow-react': 'React patterns',
+            'devflow-accessibility': 'WCAG compliance',
+            'devflow-frontend-design': 'typography, color, spacing',
+            'devflow-go': 'Go patterns',
+            'devflow-java': 'Java patterns',
+            'devflow-python': 'Python patterns',
+            'devflow-rust': 'Rust patterns',
+        };
         const choices = DEVFLOW_PLUGINS
             .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,
+            hint: pluginHints[pl.name] ?? pl.description,
         }));
         const preSelected = DEVFLOW_PLUGINS
             .filter(pl => !pl.optional && pl.name !== 'devflow-core-skills' && pl.name !== 'devflow-ambient')
@@ -151,11 +222,14 @@ export const initCommand = new Command('init')
         teamsEnabled = false;
     }
     else {
+        p.note('Agent Teams enable peer debate between agents — adversarial\n' +
+            'review, competing hypotheses in debugging, and consensus-driven\n' +
+            'exploration. Experimental: may be unstable.', 'Agent Teams');
         const teamsChoice = await p.select({
             message: 'Enable Agent Teams?',
             options: [
-                { value: false, label: 'No (Recommended)', hint: 'Experimental — may be unstable' },
-                { value: true, label: 'Yes', hint: 'Advanced — peer debate in review, exploration, debugging' },
+                { value: false, label: 'Not yet', hint: 'Recommended' },
+                { value: true, label: 'Yes', hint: 'Experimental' },
             ],
         });
         if (p.isCancel(teamsChoice)) {
@@ -173,11 +247,15 @@ export const initCommand = new Command('init')
         ambientEnabled = true;
     }
     else {
+        p.note('Auto-classifies every prompt by intent and depth. Loads relevant\n' +
+            'skills automatically and escalates to full agent pipelines\n' +
+            '(review, debug, implement) when the task warrants it.\n\n' +
+            'Adds a small amount of context to each prompt for classification.', 'Ambient Mode');
         const ambientChoice = await p.select({
             message: 'Enable ambient mode?',
             options: [
-                { value: true, label: 'Yes (Recommended)', hint: 'Classifies intent, loads skills, orchestrates agents' },
-                { value: false, label: 'No', hint: 'Full control — load skills manually' },
+                { value: true, label: 'Yes', hint: 'Recommended' },
+                { value: false, label: 'No', hint: 'Manual skill loading via slash commands' },
             ],
         });
         if (p.isCancel(ambientChoice)) {
@@ -195,8 +273,13 @@ export const initCommand = new Command('init')
         memoryEnabled = true;
     }
     else {
+        p.note('Preserves session context across /clear, restarts, and context\n' +
+            'compaction. Clear your session at any point and resume right\n' +
+            'where you left off.\n\n' +
+            'Runs a background agent on session stop that consumes additional\n' +
+            'tokens. Consider skipping if token usage is a concern.', 'Working Memory');
         const memoryChoice = await p.confirm({
-            message: 'Enable working memory? (automatic session context preservation)',
+            message: 'Enable working memory? (Recommended)',
             initialValue: true,
         });
         if (p.isCancel(memoryChoice)) {
@@ -205,14 +288,131 @@ export const initCommand = new Command('init')
         }
         memoryEnabled = memoryChoice;
     }
-    // Security deny list placement (user scope + TTY only)
+    // HUD selection (yes/no)
+    let hudEnabled;
+    if (options.hud !== undefined) {
+        hudEnabled = options.hud;
+    }
+    else if (!process.stdin.isTTY) {
+        hudEnabled = true;
+    }
+    else {
+        p.note('The HUD displays git branch, context usage, and session stats\n' +
+            'in the Claude Code status bar. Configurable via devflow hud.', 'HUD');
+        const hudChoice = await p.confirm({
+            message: 'Enable HUD? (Recommended)',
+            initialValue: true,
+        });
+        if (p.isCancel(hudChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        hudEnabled = hudChoice;
+    }
+    // .claudeignore prompt (needs early git detection)
+    const earlyGitRoot = await getGitRoot();
+    let claudeignoreEnabled = true;
+    let discoveredProjects = [];
+    if (earlyGitRoot && process.stdin.isTTY) {
+        if (scope === 'user') {
+            // User scope: discover all projects and offer batch install
+            discoveredProjects = await discoverProjectGitRoots();
+            p.note('Scans all projects Claude has worked on and creates a\n' +
+                '.claudeignore in each git repository. Excludes secrets,\n' +
+                'API keys, dependencies, and build artifacts from context.', '.claudeignore');
+            if (discoveredProjects.length > 0) {
+                const maxShow = 5;
+                const projectLines = discoveredProjects.slice(0, maxShow).join('\n');
+                const overflow = discoveredProjects.length > maxShow
+                    ? `\n... (${discoveredProjects.length - maxShow} more)`
+                    : '';
+                p.note(projectLines + overflow, `Discovered ${discoveredProjects.length} projects`);
+                const claudeignoreChoice = await p.confirm({
+                    message: `Install .claudeignore to ${discoveredProjects.length} projects? (Recommended)`,
+                    initialValue: true,
+                });
+                if (p.isCancel(claudeignoreChoice)) {
+                    p.cancel('Installation cancelled.');
+                    process.exit(0);
+                }
+                claudeignoreEnabled = claudeignoreChoice;
+            }
+            else {
+                // No projects discovered — fall back to current project only
+                const claudeignoreChoice = await p.confirm({
+                    message: 'Create .claudeignore? (Recommended)',
+                    initialValue: true,
+                });
+                if (p.isCancel(claudeignoreChoice)) {
+                    p.cancel('Installation cancelled.');
+                    process.exit(0);
+                }
+                claudeignoreEnabled = claudeignoreChoice;
+            }
+        }
+        else {
+            // Local scope: single-project note
+            p.note('Creates a .claudeignore in this project that excludes\n' +
+                'secrets, API keys, dependencies, and build artifacts from\n' +
+                'Claude\'s context window.', '.claudeignore');
+            const claudeignoreChoice = await p.confirm({
+                message: 'Create .claudeignore? (Recommended)',
+                initialValue: true,
+            });
+            if (p.isCancel(claudeignoreChoice)) {
+                p.cancel('Installation cancelled.');
+                process.exit(0);
+            }
+            claudeignoreEnabled = claudeignoreChoice;
+        }
+    }
+    else if (!earlyGitRoot) {
+        claudeignoreEnabled = false;
+    }
+    // Safe-delete detection + prompt (all detection early, action deferred)
+    const platform = detectPlatform();
+    const shell = detectShell();
+    const safeDeleteInfo = getSafeDeleteInfo(platform);
+    const safeDeleteAvailable = hasSafeDelete(platform);
+    const profilePath = getProfilePath(shell);
+    let safeDeleteAction = 'skip';
+    let safeDeleteBlock = null;
+    if (process.stdin.isTTY && profilePath && safeDeleteAvailable) {
+        const trashCmd = safeDeleteInfo.command;
+        safeDeleteBlock = generateSafeDeleteBlock(shell, process.platform, trashCmd);
+        if (safeDeleteBlock) {
+            const installedVersion = await getInstalledVersion(profilePath);
+            if (installedVersion === SAFE_DELETE_BLOCK_VERSION) {
+                safeDeleteAction = 'skip'; // already current
+            }
+            else if (installedVersion > 0) {
+                safeDeleteAction = 'upgrade'; // auto-upgrade, no prompt needed
+            }
+            else {
+                // Fresh install — prompt
+                p.note('Overrides rm to use your system trash CLI instead of permanent\n' +
+                    'deletion. Prevents accidental data loss from rm -rf.', 'Safe Delete');
+                const safeDeleteConfirm = await p.confirm({
+                    message: `Install safe-delete to ${profilePath}? (uses ${trashCmd ?? 'recycle bin'})`,
+                    initialValue: true,
+                });
+                if (!p.isCancel(safeDeleteConfirm) && safeDeleteConfirm) {
+                    safeDeleteAction = 'install';
+                }
+            }
+        }
+    }
+    // Security deny list placement (user scope + TTY only — last prompt before install)
     let securityMode = 'user';
     if (scope === 'user' && process.stdin.isTTY) {
+        p.note('DevFlow includes a security deny list that blocks dangerous\n' +
+            'commands (rm -rf, sudo, eval, etc). It can be installed as a\n' +
+            'read-only system file or in your editable settings.json.', 'Security Deny List');
         const securityChoice = await p.select({
-            message: 'How should DevFlow install the security deny list?',
+            message: 'How should DevFlow install the deny list?',
             options: [
-                { value: 'managed', label: 'Managed settings (Recommended)', hint: 'Cannot be overridden, requires admin' },
-                { value: 'user', label: 'User settings', hint: 'Included in settings.json, editable' },
+                { value: 'managed', label: 'Managed settings', hint: 'Recommended — read-only, cannot be overridden' },
+                { value: 'user', label: 'User settings', hint: 'Editable in settings.json' },
             ],
         });
         if (p.isCancel(securityChoice)) {
@@ -221,7 +421,32 @@ export const initCommand = new Command('init')
         }
         securityMode = securityChoice;
     }
-    // Start spinner immediately after prompts — covers path resolution + git detection
+    // Managed settings sudo confirmation (last interactive step — may prompt for password)
+    let managedSettingsConfirmed = false;
+    if (securityMode === 'managed') {
+        p.note('This writes a read-only security deny list to a system directory\n' +
+            'and may prompt for your password (sudo).\n\n' +
+            'Not sure about this? Paste this into another Claude Code session:\n\n' +
+            '  "I\'m installing DevFlow and it wants to write a\n' +
+            '   managed-settings.json file using sudo. Review the source\n' +
+            '   at https://github.com/dean0x/devflow and tell me if\n' +
+            '   it\'s safe."', 'Managed Settings');
+        const sudoChoice = await p.select({
+            message: 'Continue with managed settings?',
+            options: [
+                { value: 'yes', label: 'Yes, continue', hint: 'May prompt for your password' },
+                { value: 'no', label: 'No, fall back to settings.json', hint: 'Editable user settings instead' },
+            ],
+        });
+        if (p.isCancel(sudoChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        managedSettingsConfirmed = sudoChoice === 'yes';
+    }
+    // ╭──────────────────────────────────────────────────────────╮
+    // │  All prompts collected — installation begins             │
+    // ╰──────────────────────────────────────────────────────────╯
     const s = p.spinner();
     s.start('Resolving paths');
     // Get installation paths
@@ -232,7 +457,7 @@ export const initCommand = new Command('init')
         const paths = await getInstallationPaths(scope);
         claudeDir = paths.claudeDir;
         devflowDir = paths.devflowDir;
-        gitRoot = paths.gitRoot ?? await getGitRoot();
+        gitRoot = paths.gitRoot ?? earlyGitRoot;
     }
     catch (error) {
         s.stop('Path resolution failed');
@@ -316,8 +541,8 @@ export const initCommand = new Command('init')
             process.exit(1);
         }
     }
-    s.stop('Plugins installed');
     // Clean up stale skills from previous installations
+    s.message('Cleaning up');
     const skillsDir = path.join(claudeDir, 'skills');
     let staleRemoved = 0;
     for (const legacy of LEGACY_SKILL_NAMES) {
@@ -351,114 +576,90 @@ export const initCommand = new Command('init')
     if (staleCommandsRemoved > 0 && verbose) {
         p.log.info(`Cleaned up ${staleCommandsRemoved} legacy command(s)`);
     }
-    // === Configuration extras ===
-    const extrasOptions = buildExtrasOptions(scope, gitRoot);
-    let selectedExtras;
-    if (process.stdin.isTTY) {
-        const extrasSelection = await p.multiselect({
-            message: 'Configure extras',
-            options: extrasOptions,
-            initialValues: extrasOptions.map(o => o.value),
-            required: false,
-        });
-        if (p.isCancel(extrasSelection)) {
-            p.cancel('Installation cancelled.');
-            process.exit(0);
-        }
-        selectedExtras = extrasSelection;
+    // === Settings & hooks (all automatic based on collected choices) ===
+    s.message('Configuring settings');
+    // Determine effective security mode (managed settings executed later, after safe-delete)
+    let effectiveSecurityMode = securityMode;
+    if (securityMode === 'managed' && !managedSettingsConfirmed) {
+        effectiveSecurityMode = 'user';
     }
-    else {
-        selectedExtras = extrasOptions.map(o => o.value);
-    }
-    // Settings may trigger its own TTY sub-prompt — run outside spinner
-    if (selectedExtras.includes('settings')) {
-        // Attempt managed settings write if user chose managed mode
-        let effectiveSecurityMode = securityMode;
-        if (securityMode === 'managed') {
-            p.note('This writes a read-only security deny list to a system directory\n' +
-                'and may prompt for your password (sudo).\n\n' +
-                'Not sure about this? Paste this into another Claude Code session:\n\n' +
-                '  "I\'m installing DevFlow and it wants to write a\n' +
-                '   managed-settings.json file using sudo. Review the source\n' +
-                '   at https://github.com/dean0x/devflow and tell me if\n' +
-                '   it\'s safe."', 'Managed Settings');
-            const sudoChoice = await p.select({
-                message: 'Continue with managed settings?',
-                options: [
-                    { value: 'yes', label: 'Yes, continue', hint: 'May prompt for your password' },
-                    { value: 'no', label: 'No, fall back to settings.json', hint: 'Deny list stored in editable user settings instead' },
-                ],
-            });
-            if (p.isCancel(sudoChoice)) {
-                p.cancel('Installation cancelled.');
-                process.exit(0);
-            }
-            if (sudoChoice === 'yes') {
-                const managed = await installManagedSettings(rootDir, verbose);
-                if (!managed) {
-                    p.log.warn('Managed settings write failed — falling back to user settings');
-                    effectiveSecurityMode = 'user';
-                }
-            }
-            else {
-                effectiveSecurityMode = 'user';
-            }
-        }
-        await installSettings(claudeDir, rootDir, devflowDir, verbose, teamsEnabled, effectiveSecurityMode);
-        // Install ambient hook if enabled
+    await installSettings(claudeDir, rootDir, devflowDir, verbose, teamsEnabled, effectiveSecurityMode);
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    // Configure ambient hook, memory hooks, and HUD statusLine in a single read-modify-write pass
+    try {
+        let content = await fs.readFile(settingsPath, 'utf-8');
+        const original = content;
+        // Ambient hook
         if (ambientEnabled) {
-            const settingsPath = path.join(claudeDir, 'settings.json');
-            try {
-                const content = await fs.readFile(settingsPath, 'utf-8');
-                const updated = addAmbientHook(content, devflowDir);
-                if (updated !== content) {
-                    await fs.writeFile(settingsPath, updated, 'utf-8');
-                    if (verbose) {
-                        p.log.success('Ambient mode hook installed');
-                    }
-                }
-            }
-            catch { /* settings.json may not exist yet */ }
+            content = addAmbientHook(content, devflowDir);
         }
-        // Manage memory hooks based on user choice
-        const settingsPath = path.join(claudeDir, 'settings.json');
-        try {
-            const content = await fs.readFile(settingsPath, 'utf-8');
-            // Always remove-then-add to upgrade hook format (e.g., .sh → run-hook)
-            const cleaned = removeMemoryHooks(content);
-            const updated = memoryEnabled
-                ? addMemoryHooks(cleaned, devflowDir)
-                : cleaned;
-            if (updated !== content) {
-                await fs.writeFile(settingsPath, updated, 'utf-8');
-                if (verbose) {
-                    p.log.info(`Working memory ${memoryEnabled ? 'enabled' : 'disabled'}`);
-                }
+        // Memory hooks — always remove-then-add to upgrade hook format (e.g., .sh → run-hook)
+        const cleaned = removeMemoryHooks(content);
+        content = memoryEnabled ? addMemoryHooks(cleaned, devflowDir) : cleaned;
+        // HUD statusLine
+        content = hudEnabled
+            ? addHudStatusLine(content, devflowDir)
+            : removeHudStatusLine(content);
+        if (content !== original) {
+            await fs.writeFile(settingsPath, content, 'utf-8');
+            if (verbose) {
+                if (ambientEnabled)
+                    p.log.success('Ambient mode hook installed');
+                p.log.info(`Working memory ${memoryEnabled ? 'enabled' : 'disabled'}`);
+                p.log.info(`HUD ${hudEnabled ? 'enabled' : 'disabled'}`);
             }
         }
-        catch { /* settings.json may not exist yet */ }
-        // Ensure .memory/ exists when memory is enabled (hooks are no-ops without it)
-        if (memoryEnabled) {
-            await createMemoryDir(verbose);
-            await migrateMemoryFiles(verbose);
-        }
     }
-    const fileExtras = selectedExtras.filter(e => e !== 'settings' && e !== 'safe-delete');
-    if (fileExtras.length > 0) {
-        const sExtras = p.spinner();
-        sExtras.start('Configuring extras');
-        if (selectedExtras.includes('claudeignore') && gitRoot) {
-            await installClaudeignore(gitRoot, rootDir, verbose);
+    catch { /* settings.json may not exist yet */ }
+    // Ensure .memory/ exists when memory is enabled (hooks are no-ops without it)
+    if (memoryEnabled) {
+        await createMemoryDir(verbose);
+        await migrateMemoryFiles(verbose);
+    }
+    // Configure HUD
+    const existingHud = loadHudConfig();
+    saveHudConfig({ enabled: hudEnabled, detail: existingHud.detail });
+    // File extras
+    if (claudeignoreEnabled) {
+        if (scope === 'user' && discoveredProjects.length > 0) {
+            const results = await Promise.all(discoveredProjects.map(root => installClaudeignore(root, rootDir, verbose)));
+            const created = results.filter(Boolean).length;
+            if (created > 0) {
+                p.log.success(`.claudeignore created in ${created} project(s)`);
+            }
+            else {
+                p.log.info(`.claudeignore already exists in all ${discoveredProjects.length} project(s)`);
+            }
         }
-        if (selectedExtras.includes('gitignore') && gitRoot) {
-            await updateGitignore(gitRoot, verbose);
+        else if (gitRoot) {
+            await installClaudeignore(gitRoot, rootDir, verbose);
         }
-        if (selectedExtras.includes('docs')) {
-            await createDocsStructure(verbose);
+    }
+    if (scope === 'local' && gitRoot) {
+        await updateGitignore(gitRoot, verbose);
+    }
+    if (scope === 'local') {
+        await createDocsStructure(verbose);
+    }
+    // Safe-delete execution (decision was captured during prompt phase)
+    if (safeDeleteAction === 'install' && safeDeleteBlock && profilePath) {
+        await installToProfile(profilePath, safeDeleteBlock);
+    }
+    else if (safeDeleteAction === 'upgrade' && safeDeleteBlock && profilePath) {
+        await removeFromProfile(profilePath);
+        await installToProfile(profilePath, safeDeleteBlock);
+    }
+    // Managed settings (last install step — sudo may prompt for password)
+    if (securityMode === 'managed' && managedSettingsConfirmed) {
+        s.stop('Installing managed settings (may prompt for password)');
+        const managed = await installManagedSettings(rootDir, verbose);
+        if (!managed) {
+            p.log.warn('Managed settings write failed — falling back to user settings');
         }
-        sExtras.stop('Extras configured');
+        s.start('Finalizing');
     }
-    // Summary output
+    s.stop('Installation complete');
+    // === Summary ===
     if (usedNativeCli) {
         p.log.success('Installed via Claude plugin system');
     }
@@ -472,54 +673,34 @@ export const initCommand = new Command('init')
             .join('  ');
         p.note(commandsNote, 'Available commands');
     }
-    // Safe-delete auto-install (gated by extras selection)
-    if (selectedExtras.includes('safe-delete')) {
-        const platform = detectPlatform();
-        const shell = detectShell();
-        const safeDeleteInfo = getSafeDeleteInfo(platform);
-        const safeDeleteAvailable = hasSafeDelete(platform);
-        const profilePath = getProfilePath(shell);
-        if (process.stdin.isTTY && profilePath) {
-            if (!safeDeleteAvailable && safeDeleteInfo.installHint) {
-                p.log.info(`Install ${color.cyan(safeDeleteInfo.command ?? 'trash')} first: ${color.dim(safeDeleteInfo.installHint)}`);
-                p.log.info(`Then re-run ${color.cyan('devflow init')} to auto-configure safe-delete.`);
-            }
-            else if (safeDeleteAvailable) {
-                const trashCmd = safeDeleteInfo.command;
-                const block = generateSafeDeleteBlock(shell, process.platform, trashCmd);
-                if (block) {
-                    const installedVersion = await getInstalledVersion(profilePath);
-                    if (installedVersion === SAFE_DELETE_BLOCK_VERSION) {
-                        p.log.info(`Safe-delete already configured in ${color.dim(profilePath)}`);
-                    }
-                    else if (installedVersion > 0) {
-                        await removeFromProfile(profilePath);
-                        await installToProfile(profilePath, block);
-                        p.log.success(`Safe-delete upgraded in ${color.dim(profilePath)}`);
-                        p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
-                    }
-                    else {
-                        const confirm = await p.confirm({
-                            message: `Install safe-delete to ${profilePath}? (overrides rm to use ${trashCmd ?? 'recycle bin'})`,
-                            initialValue: true,
-                        });
-                        if (!p.isCancel(confirm) && confirm) {
-                            await installToProfile(profilePath, block);
-                            p.log.success(`Safe-delete installed to ${color.dim(profilePath)}`);
-                            p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
-                        }
-                    }
-                }
-            }
+    // Safe-delete status messages (after spinner)
+    if (process.stdin.isTTY && profilePath) {
+        if (safeDeleteAction === 'install') {
+            p.log.success(`Safe-delete installed to ${color.dim(profilePath)}`);
+            p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
         }
-        else if (!process.stdin.isTTY) {
-            if (safeDeleteAvailable && safeDeleteInfo.command) {
-                p.log.info(`Safe-delete available (${safeDeleteInfo.command}). Run interactively to auto-install.`);
-            }
-            else if (safeDeleteInfo.installHint) {
-                p.log.info(`Protect against accidental ${color.red('rm -rf')}: ${color.cyan(safeDeleteInfo.installHint)}`);
+        else if (safeDeleteAction === 'upgrade') {
+            p.log.success(`Safe-delete upgraded in ${color.dim(profilePath)}`);
+            p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
+        }
+        else if (safeDeleteAvailable && safeDeleteBlock) {
+            const installedVersion = await getInstalledVersion(profilePath);
+            if (installedVersion === SAFE_DELETE_BLOCK_VERSION) {
+                p.log.info(`Safe-delete already configured in ${color.dim(profilePath)}`);
             }
         }
+        else if (!safeDeleteAvailable && safeDeleteInfo.installHint) {
+            p.log.info(`Install ${color.cyan(safeDeleteInfo.command ?? 'trash')} first: ${color.dim(safeDeleteInfo.installHint)}`);
+            p.log.info(`Then re-run ${color.cyan('devflow init')} to auto-configure safe-delete.`);
+        }
+    }
+    else if (!process.stdin.isTTY) {
+        if (safeDeleteAvailable && safeDeleteInfo.command) {
+            p.log.info(`Safe-delete available (${safeDeleteInfo.command}). Run interactively to auto-install.`);
+        }
+        else if (safeDeleteInfo.installHint) {
+            p.log.info(`Protect against accidental ${color.red('rm -rf')}: ${color.cyan(safeDeleteInfo.installHint)}`);
+        }
     }
     // Verbose mode: show details
     if (verbose) {
@@ -542,7 +723,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,
     };