erne-universal 0.10.18 → 0.10.20

package/CLAUDE.md

@@ -1,185 +1,35 @@
-# ERNE — Everything React Native & Expo
-
-You are working in an ERNE-powered React Native/Expo project.
+<!-- ERNE-GENERATED -->
+<!-- erne-profile: standard -->
+# erne-universal — ERNE Configuration
 
 ## Project Stack
-
-> **Note:** When `erne init` runs in a project, this section is replaced with a stack summary generated from deep detection of the project's actual dependencies (state management, navigation, styling, lists, images, forms, storage, testing, build system).
-
-- **Framework**: React Native with Expo (managed or bare)
-- **Language**: TypeScript (strict mode)
-- **Navigation**: Detected at init (Expo Router, React Navigation, etc.)
-- **State**: Detected at init (Zustand, Redux Toolkit, MobX, etc.)
-- **Testing**: Jest + React Native Testing Library + Detox
-- **Styling**: Detected at init (StyleSheet.create, NativeWind, etc.)
+- **Framework**: React Native
+- **Language**: JavaScript
+- **Navigation**: None
+- **State**: None
+- **Styling**: StyleSheet.create
+- **Lists**: FlatList (built-in)
+- **Images**: Image (built-in)
+- **Testing**: None configured
+- **Build**: Manual
 
 ## Key Rules
-
-### Code Style
 - Functional components only with `const` + arrow functions
-- PascalCase for components, camelCase for hooks/utils, SCREAMING_SNAKE for constants
 - Named exports only (no default exports)
-- Group imports: react → react-native → expo → external → internal → types
-- Max component length: 250 lines — extract if larger
-
-### Performance
-- Memoize with `React.memo`, `useMemo`, `useCallback` where measurable
-- Use `FlashList` over `FlatList` for large lists (100+ items)
-- Avoid anonymous functions in JSX render paths
-- Optimize images: WebP format, resizeMode, caching
-- Keep JS bundle under 1.5MB
-
-### Testing
-- Every new component/hook needs a test file
-- Test user behavior, not implementation details
-- Mock native modules at `__mocks__/` level
-- E2E critical paths with Detox
-
-### Security
-- Never hardcode secrets — use environment variables
-- Validate all deep link parameters
-- Pin SSL certificates for sensitive API calls
-- Use secure storage for tokens (expo-secure-store, react-native-keychain, etc.)
-
-### Git
-- Conventional Commits: `feat:`, `fix:`, `refactor:`, `test:`, `docs:`, `chore:`
-- Branch naming: `feat/`, `fix/`, `refactor/` prefix
-- Atomic commits — one logical change per commit
-
-## Workflow Orchestration
-
-### 1. Plan Mode Default
-- Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
-- If something goes sideways, STOP and re-plan immediately — don't keep pushing
-- Use plan mode for verification steps, not just building
-- Write detailed specs upfront to reduce ambiguity
-
-### 2. Subagent Strategy
-- Use subagents liberally to keep main context window clean
-- Offload research, exploration, and parallel analysis to subagents
-- For complex problems, throw more compute at it via subagents
-- One task per subagent for focused execution
-
-### 3. Self-Improvement Loop
-- After ANY correction from the user: save a `feedback` memory via the memory system
-- Write rules for yourself that prevent the same mistake
-- Memory is auto-loaded each session — no manual review needed
-
-### 4. Verification Before Done
-- Never mark a task complete without proving it works
-- Diff behavior between main and your changes when relevant
-- Ask yourself: "Would a staff engineer approve this?"
-- Run tests, check logs, demonstrate correctness
-
-### 5. Demand Elegance (Balanced)
-- For non-trivial changes: pause and ask "is there a more elegant way?"
-- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
-- Skip this for simple, obvious fixes — don't over-engineer
-- Challenge your own work before presenting it
-
-### 6. Autonomous Bug Fixing
-- When given a bug report: just fix it. Don't ask for hand-holding
-- Point at logs, errors, failing tests — then resolve them
-- Zero context switching required from the user
-- Go fix failing CI tests without being told how
-
-## Smart Agent Routing
-
-When a user's message matches these signals, automatically use the corresponding agent via a subagent. The user should NOT need to type explicit `/commands` — detect intent from context. Explicit `/command` invocations always override auto-routing.
-
-**How routing works:** Read the user's message. If it matches trigger signals below, dispatch the matching agent as a subagent. If multiple agents could match, prefer the more specific one. If unclear, ask the user.
-
-**Image detection:** When the user shares an image/screenshot alongside a description of a visual problem, ALWAYS route to visual-debugger.
-
-| Agent | Trigger Signals |
-|-------|----------------|
-| `visual-debugger` | Image in chat with UI issue, screenshot, "doesn't look right", "UI is broken", "layout not working", "fix this" + image, spacing, alignment, overflow, "wrong colors", "doesn't match Figma", pixel, responsive, "design issue", "visual bug", "cut off", overlapping, "not centered", "wrong font", "dark mode broken", "safe area", notch, "status bar", "keyboard covers" |
-| `performance-profiler` | "slow", lag, FPS, "memory leak", jank, freeze, hanging, "bundle size", TTI, "startup time", "re-render", heavy, "animation stutter", "frame drop", "battery drain", "CPU usage", "JS thread blocked", "bridge overhead", "large list", "image loading slow", "splash screen long", ANR |
-| `code-reviewer` | review, PR, refactor, "code quality", "clean up", "best practice", "technical debt", "code smell", maintainability, "check my code", "is this okay", "anti-pattern", readability, DRY, SOLID, "type safety" |
-| `architect` | "how to build", architecture, structure, plan, "system design", "new feature", "want to add", "how to approach", decompose, "design pattern", "folder structure", "state management", "data flow", "API design", "navigation structure", monorepo, "separation of concerns" |
-| `feature-builder` | implement, build, create, "add feature", "create component", "write this", "make this", scaffold, "add screen", "wire up", integrate, "connect to API", "hook up", "add functionality", CRUD |
-| `tdd-guide` | test, coverage, jest, detox, TDD, "write test", "unit test", e2e, "failing test", "test broken", "snapshot test", mock, fixture, "testing library", "integration test", "test flaky" |
-| `expo-config-resolver` | build error, red screen, crash, "won't start", error, "build failed", metro, babel, "config issue", "EAS build", "can't build", "module not found", "pod install", gradle, "Xcode error", "Android build", "iOS build", "linking error", prebuild, "app.json", "app.config", "plugin not working", "white screen", "blank screen" |
-| `native-bridge-builder` | "native module", bridge, "turbo module", Swift, Kotlin, Java, "Objective-C", "native code", "platform specific", "expo module", JSI, Fabric, "New Architecture", codegen, "C++", "native view", Nitro, "expo-modules-core" |
-| `upgrade-assistant` | upgrade, update, version, migration, "breaking change", deprecated, "Expo SDK", "React Native version", bump, migrate, changelog, compatibility, "peer dependency", outdated, "npx expo install --fix" |
-| `ui-designer` | component, button, modal, form, screen, page, tab, "navigation UI", "build UI", "design system", styled, theme, icon, animation, transition, gesture, "bottom sheet", drawer, header, card, skeleton, loading, toast |
-| `pipeline-orchestrator` | deploy, publish, EAS, "app store", "play store", "CI/CD", release, "OTA update", submit, distribution, TestFlight, "internal testing", "code signing", provisioning, certificate, keystore, fastlane, "GitHub Actions" |
-| `senior-developer` | "what do you think", opinion, advice, approach, tradeoff, "not sure how", mentor, "help me decide", "best way to", "should I", "pros and cons", "compare options", "which is better", "common pitfall", "production ready", scalable |
-| `documentation-generator` | "generate docs", "document this", "write documentation", "project overview", "architecture docs", "what does this project do", "onboard me", "explain codebase", "project structure", "how does this work" |
-
-## Task Management
-
-1. **Plan First**: Use plan mode or TodoWrite for non-trivial tasks
-2. **Verify Plan**: Check in before starting implementation
-3. **Track Progress**: Use built-in task system (TodoWrite/TaskCreate) to mark progress
-4. **Explain Changes**: High-level summary at each step
-5. **Capture Lessons**: Save corrections as `feedback` memories
-
-## Core Principles
-
-- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
-- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
-- **Minimal Impact**: Changes should only touch what's necessary. Avoid introducing bugs.
+- Use secure storage for tokens — avoid AsyncStorage for sensitive data
+- Conventional Commits: feat:, fix:, refactor:, test:, docs:, chore:
 
 ## Available Commands
+/erne-plan, /erne-code-review, /erne-tdd, /erne-build-fix, /erne-perf, /erne-upgrade, /erne-native-module, /erne-debug, /erne-debug-visual, /erne-deploy,
+/erne-component, /erne-navigate, /erne-animate, /erne-orchestrate, /erne-quality-gate, /erne-code, /erne-feature, /erne-worker, /erne-audit, /erne-learn, /erne-retrospective, /erne-setup-device
 
-Use `/erne-plan`, `/erne-code-review`, `/erne-tdd`, `/erne-build-fix`, `/erne-perf`, `/erne-upgrade`, `/erne-native-module`, `/erne-navigate`, `/erne-animate`, `/erne-deploy`, `/erne-component`, `/erne-debug`, `/erne-debug-visual`, `/erne-audit`, `/erne-quality-gate`, `/erne-code`, `/erne-feature`, `/erne-learn`, `/erne-retrospective`, `/erne-setup-device` for guided workflows.
-
-## Worker Mode (Autonomous Ticket Execution)
-
-ERNE can run as an autonomous worker that polls a ticket provider, picks up ready tasks, and executes the full pipeline without human intervention.
-
-### Quick Start
-
-```bash
-erne worker --config worker.json
-```
-
-### How It Works
-
-1. Polls a configured provider (ClickUp, GitHub Issues, Linear, Jira, or local JSON) for tickets marked as ready
-2. Validates each ticket has sufficient detail (title, description, acceptance criteria)
-3. Scores confidence (0-100) — skips tickets below the configured threshold
-4. Generates an implementation plan from ticket context + project audit data
-5. Executes in an isolated git worktree to avoid disrupting the main branch
-6. Runs the test suite and verifies no regressions
-7. Performs automated self-review against ERNE coding standards
-8. Compares audit health score before and after changes
-9. Creates a pull request with summary, test results, and ticket link
-
-### Quality Gates
-
-Each ticket must pass these gates before a PR is created:
-- Confidence score above threshold (default: 70)
-- All existing tests pass
-- No audit score regression
-- Self-review finds no critical issues
-
-### Configuration
-
-See `worker.example.json` for a full template. Key options:
-- `provider.type` — clickup, github, linear, jira, local
-- `provider.poll_interval_seconds` — How often to check for new tickets (default: 60)
-- `erne.min_confidence` — Minimum confidence score to attempt a ticket (default: 70)
-- `erne.hook_profile` — ERNE hook profile to use (minimal, standard, strict)
-- `repo.path` — Absolute path to the local repository
-- `repo.base_branch` — Branch to create worktrees from (default: main)
-
-### CLI Options
-
-| Flag | Description |
-|------|-------------|
-| `--config <path>` | Path to worker config JSON (required) |
-| `--dry-run` | Fetch and display tickets without executing |
-| `--once` | Process one ticket then exit |
+## Dashboard
+ERNE includes a visual dashboard for monitoring agents, project health, worker status, and documentation.
+Launch: `npx erne-universal dashboard`
+The dashboard shows 6 tabs: HQ (pixel-art agent office), Worker (autonomous tickets), Health (doctor score), Docs (generated documentation), Project (stack & MCP), Insights (analytics).
 
-## Available Skills
+## Rules
+@import .claude/rules/common/
 
-Skills in `skills/` activate automatically:
-- `coding-standards` — Audit and enforce standards
-- `tdd-workflow` — Red-green-refactor cycle
-- `performance-optimization` — Diagnose and fix perf issues
-- `security-review` — Mobile security audit
-- `native-module-scaffold` — Create Turbo/Expo modules
-- `upgrade-workflow` — Version migration guide
-- `continuous-learning-v2` — Pattern extraction and learning
+## Skills
+@import .claude/skills/

package/commands/erne-init.md

@@ -1,54 +1,58 @@
 ---
 name: erne-init
-description: ERNE — Initialize the AI agent harness in this project. Sets up 13 agents, hooks, rules, MCP servers, and dashboard. Use when user says "set up erne", "initialize erne", "install erne", or first time setup.
+description: Initialize ERNE — the AI agent harness for React Native & Expo projects. Sets up 13 specialized agents, hook-based code quality enforcement, MCP server integrations, and a visual dashboard. Triggers on "set up erne", "initialize erne", "install erne", "configure agents", "add erne to project", or any first-time ERNE setup request. Always use this skill when the user wants to set up ERNE, even if they don't say "init" explicitly.
 ---
 
-# /erne-init — Initialize ERNE
+# Initialize ERNE
 
-You are executing the `/erne-init` command. This sets up ERNE in the current project.
+ERNE is an AI agent harness for React Native and Expo. Setting it up involves choosing a few preferences and then running a single CLI command. The reason you need to ask the user before running is that the CLI's interactive prompts don't work reliably in Claude Code — so you handle the interaction here in conversation instead.
 
-## Before Running
+## Step 1: Ask preferences
 
-You MUST ask the user these questions before proceeding. Do NOT skip this step. Do NOT default silently.
+Before running anything, ask the user two things in a single message:
 
-### Question 1: Hook Profile
+**Profile:** ERNE uses hook profiles to control how much code quality checking happens automatically. Ask which one they'd like:
+- **minimal** — Almost no automated checks. Good for quick prototyping or when you just want the agents without guardrails.
+- **standard** — Catches common issues (formatting, console.logs, platform-specific bugs) without slowing things down. This is what most people pick.
+- **strict** — Adds security scanning, accessibility checks, and test gates. Good for production apps or teams.
 
-Ask the user:
+**MCP servers:** ERNE can configure agent-device (controls iOS Simulator and Android Emulator for screenshots, taps, navigation) and GitHub integration. Ask if they want these set up now or later.
 
-> Which hook profile would you like?
->
-> **a) minimal** — Fast iteration, minimal checks. For rapid prototyping.
-> **b) standard** (recommended) — Balanced quality and speed. For most projects.
-> **c) strict** — Production-grade enforcement. For teams requiring CI-level quality.
+Wait for the user to respond before continuing.
 
-Wait for their response.
+## Step 2: Run the init command
 
-### Question 2: MCP Servers
+Once you have their preferences, run this in Bash:
 
-Ask the user:
+```bash
+npx erne-universal@latest init --yes --profile <profile> [--no-mcp]
+```
 
-> ERNE can configure MCP servers for device control and GitHub integration. Configure now?
->
-> **a) Yes** — Set up agent-device (simulator/emulator control) + GitHub
-> **b) No** — Skip MCP setup, configure later
+Replace `<profile>` with their choice (minimal, standard, or strict). Add `--no-mcp` only if they said no to MCP servers.
 
-Wait for their response.
+The `--yes` flag is important — it tells the CLI to skip its own interactive prompts since you already gathered the preferences.
 
-## Run Init
+## Step 3: Launch the dashboard
 
-Based on their answers, construct and run the command:
+After init completes, start the dashboard:
 
 ```bash
-npx erne-universal init --yes --profile <chosen-profile> [--no-mcp if they chose no]
+npx erne-universal dashboard &
 ```
 
-Examples:
-- User chose standard + yes to MCP: `npx erne-universal init --yes --profile standard`
-- User chose strict + no to MCP: `npx erne-universal init --yes --profile strict --no-mcp`
-- User chose minimal + yes to MCP: `npx erne-universal init --yes --profile minimal`
+The dashboard runs in the background. Read the output to find which port it started on (usually 3333, but it auto-selects a free port if 3333 is taken).
+
+If the dashboard needs to install dependencies on first run (takes about 2 minutes), tell the user it's installing and will open in the browser when ready.
 
-## After Init
+## Step 4: Tell the user what happened
 
-1. Tell the user to **restart the Claude Code session** to activate MCP servers and hooks
-2. Mention they can run `npx erne-universal dashboard` to launch the visual dashboard
-3. List available commands: `/erne-plan`, `/erne-perf`, `/erne-doctor`, etc.
+Summarize in a clear message:
+- What was set up (agents, hooks, rules, skills, MCP servers)
+- The dashboard URL (e.g., http://localhost:3333)
+- That they need to **restart this Claude Code session** for MCP servers and hooks to activate
+- A few commands they can try after restart:
+  - `/erne-plan` — plan a new feature
+  - `/erne-perf` — profile performance issues
+  - `/erne-doctor` — check project health
+  - `/erne-code-review` — review code quality
+  - Type `/erne-` and press Tab to see all commands

package/lib/init.js

@@ -8,6 +8,7 @@
 
 'use strict';
 
+const fs = require('fs');
 const path = require('path');
 const readline = require('readline/promises');
 const { stdin, stdout } = require('process');
@@ -16,6 +17,24 @@ const { detectProject } = require('./detect');
 const { generateConfig, determineRuleLayers } = require('./generate');
 const { handleClaudeMd } = require('./claude-md');
 
+// ─── ANSI helpers ────────────────────────────────────────────────────────────
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+};
+
+const ok = `${c.green}\u2713${c.reset}`;
+const fail = `${c.red}\u2717${c.reset}`;
+const warn = `${c.yellow}\u26A0${c.reset}`;
+const info = `${c.cyan}\u2139${c.reset}`;
+
 // ─── Label maps for detection report ─────────────────────────────────────────
 
 const labels = {
@@ -88,41 +107,56 @@ function parseArgs() {
 
 function printDetectionReport(detection) {
   const s = detection.stack;
-  const lbl = (map, key) => map[key] || key;
+  const lbl = (map, key) => (key in map ? map[key] : key);
 
   // Build state display: combine client + server state
   let stateDisplay = lbl(labels.state, s.state);
   const serverLabel = lbl(labels.serverState, s.serverState);
   if (serverLabel) stateDisplay += ` + ${serverLabel}`;
 
-  const claudeMdStatus = detection.existingClaudeMd
-    ? 'Exists (will append, backup to CLAUDE.md.pre-erne)'
-    : 'Will generate';
-
   const rows = [
-    ['Framework',   `${frameworkLabels[detection.framework] || detection.framework}`],
+    ['Framework',   frameworkLabels[detection.framework] || detection.framework],
     ['State',       stateDisplay],
     ['Navigation',  lbl(labels.navigation, s.navigation)],
     ['Styling',     lbl(labels.styling, s.styling)],
     ['Lists',       lbl(labels.lists, s.lists)],
     ['Images',      lbl(labels.images, s.images)],
-    ['Forms',       lbl(labels.forms, s.forms)],
-    ['Storage',     lbl(labels.storage, s.storage)],
     ['Testing',     lbl(labels.testing, s.testing)],
-    ['Build',       lbl(labels.build, s.build)],
     ['TypeScript',  detection.hasTypescript ? 'Yes' : 'No'],
     ['New Arch',    detection.hasNewArch ? 'Yes' : 'No'],
-    ['Monorepo',    detection.hasMonorepo ? 'Yes' : 'No'],
-    ['Components',  detection.componentStyle === 'functional' ? 'Functional' : detection.componentStyle === 'class' ? 'Class' : 'Mixed'],
-    ['CLAUDE.md',   claudeMdStatus],
   ];
 
   console.log();
   for (const [label, value] of rows) {
-    console.log(`    ${label.padEnd(13)}${value}`);
+    console.log(`    ${c.dim}${label.padEnd(14)}${c.reset}${c.cyan}${value}${c.reset}`);
   }
 }
 
+// ─── Count generated files ───────────────────────────────────────────────────
+
+function countFiles(claudeDir) {
+  let agentCount = 0;
+  let skillCount = 0;
+
+  try {
+    const agentsDir = path.join(claudeDir, 'agents');
+    if (fs.existsSync(agentsDir)) {
+      agentCount = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).length;
+    }
+  } catch { /* skip */ }
+
+  try {
+    const skillsDir = path.join(claudeDir, 'skills');
+    if (fs.existsSync(skillsDir)) {
+      skillCount = fs.readdirSync(skillsDir).filter(f => {
+        try { return fs.statSync(path.join(skillsDir, f)).isDirectory(); } catch { return false; }
+      }).length;
+    }
+  } catch { /* skip */ }
+
+  return { agentCount, skillCount };
+}
+
 // ─── Main init flow ──────────────────────────────────────────────────────────
 
 module.exports = async function init() {
@@ -137,18 +171,18 @@ module.exports = async function init() {
   const cwd = process.cwd();
 
   try {
-    console.log('\n  erne — Setting up AI agent harness for React Native & Expo\n');
+    console.log(`\n  ${c.bold}erne${c.reset} ${c.dim}\u2014 Setting up AI agent harness for React Native & Expo${c.reset}\n`);
 
     // ─── Step 1: Detect project type ───
-    console.log('  Scanning project...');
+    console.log(`  ${c.bold}Step 1:${c.reset} Deep-scanning project...`);
     const detection = detectProject(cwd);
     printDetectionReport(detection);
 
     if (!detection.isRNProject) {
       if (nonInteractive) {
-        console.log('\n  ⚠ No React Native project detected — continuing (non-interactive mode).');
+        console.log(`\n  ${warn} No React Native project detected \u2014 continuing (non-interactive mode).`);
       } else {
-        console.log('\n  ⚠ No React Native project detected in current directory.');
+        console.log(`\n  ${warn} No React Native project detected in current directory.`);
         const proceed = await rl.question('  Continue anyway? (y/N) ');
         if (proceed.toLowerCase() !== 'y') {
           console.log('  Aborted.');
@@ -163,15 +197,15 @@ module.exports = async function init() {
 
     if (opts.profile && validProfiles.includes(opts.profile)) {
       profile = opts.profile;
-      console.log(`\n  Step 2: Hook profile: ${profile} (from --profile flag)`);
+      console.log(`\n  ${c.bold}Step 2:${c.reset} Hook profile \u2192 ${c.cyan}${profile}${c.reset}`);
     } else if (nonInteractive) {
       profile = 'standard';
-      console.log('\n  Step 2: Hook profile: standard (default)');
+      console.log(`\n  ${c.bold}Step 2:${c.reset} Hook profile \u2192 ${c.cyan}standard${c.reset}`);
     } else {
-      console.log('\n  Step 2: Select hook profile:\n');
-      console.log('    (a) minimal  — fast iteration, minimal checks');
-      console.log('    (b) standard — balanced quality + speed [recommended]');
-      console.log('    (c) strict   — production-grade enforcement');
+      console.log(`\n  ${c.bold}Step 2:${c.reset} Select hook profile:\n`);
+      console.log('    (a) minimal  \u2014 fast iteration, minimal checks');
+      console.log('    (b) standard \u2014 balanced quality + speed [recommended]');
+      console.log('    (c) strict   \u2014 production-grade enforcement');
       console.log();
 
       let profileChoice = await rl.question('  Profile (a/b/c) [b]: ');
@@ -186,32 +220,33 @@ module.exports = async function init() {
     const defaultMcpKeys = ['agent-device', 'github'];
 
     if (opts.noMcp) {
-      console.log('\n  Step 3: MCP servers: none (--no-mcp)');
+      console.log(`\n  ${c.bold}Step 3:${c.reset} MCP servers \u2192 ${c.dim}none${c.reset}`);
       for (const key of allMcpKeys) mcpSelections[key] = false;
     } else if (opts.mcp !== null) {
-      console.log(`\n  Step 3: MCP servers: ${opts.mcp.join(', ') || 'none'} (from --mcp flag)`);
+      const mcpDisplay = opts.mcp.length > 0 ? opts.mcp.join(', ') : 'none';
+      console.log(`\n  ${c.bold}Step 3:${c.reset} MCP servers \u2192 ${c.cyan}${mcpDisplay}${c.reset}`);
       for (const key of allMcpKeys) mcpSelections[key] = opts.mcp.includes(key);
     } else if (opts.yes) {
-      console.log(`\n  Step 3: MCP servers: ${defaultMcpKeys.join(', ')} (defaults)`);
+      console.log(`\n  ${c.bold}Step 3:${c.reset} MCP servers \u2192 ${c.cyan}${defaultMcpKeys.join(', ')}${c.reset}`);
       for (const key of allMcpKeys) mcpSelections[key] = defaultMcpKeys.includes(key);
     } else {
-      console.log('\n  Step 3: MCP server integrations:\n');
+      console.log(`\n  ${c.bold}Step 3:${c.reset} MCP server integrations:\n`);
 
       // Recommended servers
       console.log('  Recommended:');
-      const agentDevice = await rl.question('    [Y/n] agent-device — Control iOS Simulator & Android Emulator: ');
+      const agentDevice = await rl.question('    [Y/n] agent-device \u2014 Control iOS Simulator & Android Emulator: ');
       mcpSelections['agent-device'] = agentDevice.toLowerCase() !== 'n';
 
-      const github = await rl.question('    [Y/n] GitHub — PR management, issue tracking: ');
+      const github = await rl.question('    [Y/n] GitHub \u2014 PR management, issue tracking: ');
       mcpSelections['github'] = github.toLowerCase() !== 'n';
 
       // Optional servers
       console.log('\n  Optional (press Enter to skip):');
       const optionalServers = [
-        { key: 'supabase', label: 'Supabase — Database & auth' },
-        { key: 'firebase', label: 'Firebase — Analytics & push' },
-        { key: 'figma', label: 'Figma — Design token sync' },
-        { key: 'sentry', label: 'Sentry — Error tracking' },
+        { key: 'supabase', label: 'Supabase \u2014 Database & auth' },
+        { key: 'firebase', label: 'Firebase \u2014 Analytics & push' },
+        { key: 'figma', label: 'Figma \u2014 Design token sync' },
+        { key: 'sentry', label: 'Sentry \u2014 Error tracking' },
       ];
 
       for (const server of optionalServers) {
@@ -221,7 +256,7 @@ module.exports = async function init() {
     }
 
     // ─── Step 4: Generate config ───
-    console.log('\n  Step 4: Generating configuration...\n');
+    console.log();
 
     const erneRoot = path.resolve(__dirname, '..');
     const claudeDir = path.join(cwd, '.claude');
@@ -233,51 +268,52 @@ module.exports = async function init() {
 
     const { ruleLayers, mcpCount } = generateConfig(erneRoot, claudeDir, detection, profile, enabledMcp);
 
-    // Print what was generated
-    console.log(`    ✓ .claude/ (agents, skills, rules, contexts, hooks)`);
-    console.log(`    ✓ .claude/rules/ (layers: ${ruleLayers.join(', ')})`);
-    console.log(`    ✓ .claude/hooks.json (${profile} profile)`);
-    console.log(`    ✓ .claude/mcp/ (${mcpCount} servers)`);
-    if (mcpCount > 0) {
-      console.log('    ⚠ MCP servers configured in .mcp.json — restart Claude Code session to activate');
-    }
-    console.log('    ✓ .claude/settings.json');
-
     // Handle CLAUDE.md
     const claudeMdResult = handleClaudeMd(cwd, detection, profile, ruleLayers);
 
+    // Count what was generated
+    const { agentCount, skillCount } = countFiles(claudeDir);
+
+    // ─── Summary ───
+    console.log(`  ${ok} ${c.bold}${agentCount}${c.reset} agents matched to your stack`);
+    console.log(`  ${ok} ${c.bold}${skillCount}${c.reset} skills installed`);
+    console.log(`  ${ok} .claude/ configured \u2014 agents, skills, rules, hooks`);
+    if (mcpCount > 0) {
+      console.log(`  ${ok} .mcp.json \u2014 ${c.bold}${mcpCount}${c.reset} MCP servers configured`);
+    }
+
     const claudeMdMessages = {
-      appended: 'CLAUDE.md (appended — original backed up to CLAUDE.md.pre-erne)',
-      regenerated: 'CLAUDE.md (regenerated for detected stack)',
-      generated: 'CLAUDE.md (generated for detected stack)',
+      appended: 'CLAUDE.md updated (original backed up)',
+      regenerated: 'CLAUDE.md regenerated for detected stack',
+      generated: 'CLAUDE.md generated',
     };
-    console.log(`    ✓ ${claudeMdMessages[claudeMdResult]}`);
+    console.log(`  ${ok} ${claudeMdMessages[claudeMdResult]}`);
 
     // ─── Step 5: Project Audit ───
-    console.log('\n  Step 5: Running project audit...\n');
+    console.log();
     try {
       const { runAudit } = require('./audit');
       const { score, findings, strengths } = runAudit(cwd);
       const critical = findings.filter(f => f.severity === 'critical');
       const warnings = findings.filter(f => f.severity === 'warning');
-      const scoreColor = score >= 80 ? '\x1b[32m' : score >= 60 ? '\x1b[33m' : '\x1b[31m';
-      const reset = '\x1b[0m';
-      console.log(`    Score: ${scoreColor}${score}/100${reset}  (${strengths.length} strengths, ${critical.length} critical, ${warnings.length} warnings)`);
+      const scoreColor = score >= 80 ? c.green : score >= 60 ? c.yellow : c.red;
+      console.log(`  Audit score: ${scoreColor}${c.bold}${score}/100${c.reset} (${strengths.length} strengths, ${critical.length} critical, ${warnings.length} warnings)`);
       if (critical.length > 0) {
         for (const f of critical) {
-          console.log(`    \x1b[31m✗\x1b[0m ${f.title} — Fix: ${f.fix}`);
+          console.log(`  ${fail} ${f.title} \u2014 Fix: ${f.fix}`);
         }
       }
-      console.log('    ✓ .erne/audit.md (full report)');
     } catch (err) {
-      console.log(`    ⚠ Audit skipped: ${err.message}`);
+      console.log(`  ${warn} Audit skipped: ${err.message}`);
     }
 
-    // ─── Dashboard ───
-    console.log('    ℹ Dashboard: run \x1b[36mnpx erne-universal dashboard\x1b[0m to launch');
-    console.log('');
-    console.log('  \x1b[32mDone!\x1b[0m ERNE is ready. Use /erne- commands (e.g. /erne-plan, /erne-perf, /erne-doctor).');
-    console.log('');
+    // ─── Footer ───
+    console.log();
+    console.log(`  ${info} Dashboard: run ${c.cyan}npx erne-universal dashboard${c.reset} to launch`);
+    console.log();
+    console.log(`  ${c.green}Done!${c.reset} Use /erne- commands (e.g. /erne-plan, /erne-perf, /erne-doctor)`);
+    console.log(`  Restart Claude Code session to activate MCP servers and hooks.`);
+    console.log();
   } finally {
     if (rl) rl.close();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erne-universal",
-  "version": "0.10.18",
+  "version": "0.10.20",
   "description": "Complete AI coding agent harness for React Native and Expo development",
   "keywords": [
     "react-native",

package/scripts/hooks/session-start.js

@@ -1,9 +1,12 @@
 'use strict';
+
 const fs = require('fs');
 const path = require('path');
 
 const projectDir = process.env.ERNE_PROJECT_DIR || process.cwd();
 
+// ─── Helper functions for layer detection ────────────────────────────────────
+
 function fileExists(relPath) {
   return fs.existsSync(path.join(projectDir, relPath));
 }
@@ -46,7 +49,8 @@ function hasExpoDependency(pkg) {
   return 'expo' in deps;
 }
 
-// Detect layers
+// ─── Detect layers (always needed for backward compat) ───────────────────────
+
 const layers = ['common'];
 const pkg = readPackageJson();
 const hasIosDir = dirExists('ios');
@@ -68,12 +72,17 @@ if (hasAndroidDir && findFilesWithExt('android', '.kt')) {
 
 const hasSignals = layers.length > 1;
 
-// Read ERNE settings for richer session info
+// ─── Read ERNE settings for richer banner ────────────────────────────────────
+
+const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+let version = '';
 let profile = 'unknown';
 let agentCount = 0;
-let version = '';
+let hasSettings = false;
+
 try {
-  const settings = JSON.parse(fs.readFileSync(path.join(projectDir, '.claude', 'settings.json'), 'utf8'));
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  hasSettings = true;
   profile = settings.profile || 'standard';
   version = settings.erneVersion || '';
 } catch { /* no settings */ }
@@ -86,23 +95,60 @@ try {
   }
 } catch { /* skip */ }
 
-// Find dashboard port
-let dashboardInfo = '';
-try {
-  const { resolveDashboardPort } = require('./lib/port-registry');
-  const port = resolveDashboardPort(projectDir);
-  if (port) dashboardInfo = ` | Dashboard: http://localhost:${port}`;
-} catch { /* no registry */ }
-
-// Build status line
-const parts = [];
-if (version) parts.push(`v${version}`);
-parts.push(`${profile} profile`);
-if (agentCount > 0) parts.push(`${agentCount} agents`);
-parts.push(`layers: ${layers.join(', ')}`);
-
-console.log(`ERNE ${parts.join(' | ')}${dashboardInfo}`);
-console.log(`Use /erne- commands (e.g. /erne-plan, /erne-perf, /erne-doctor)`);
+// ─── Dashboard auto-start ────────────────────────────────────────────────────
+
+let dashboardUrl = '';
+
+if (hasSettings) {
+  try {
+    const { getRegisteredPort } = require('./lib/port-registry');
+    const existingPort = getRegisteredPort(projectDir);
+
+    if (existingPort) {
+      dashboardUrl = `http://localhost:${existingPort}`;
+    } else if (!process.env.ERNE_SKIP_DASHBOARD) {
+      // Try to start dashboard in background
+      try {
+        const dashboardDir = path.resolve(__dirname, '..', '..', 'dashboard');
+        const serverScript = path.join(dashboardDir, 'server.js');
+        const depsExist = fs.existsSync(path.join(dashboardDir, 'node_modules', 'better-sqlite3'));
+
+        if (fs.existsSync(serverScript) && depsExist) {
+          const { fork } = require('child_process');
+          const child = fork(serverScript, [], {
+            cwd: projectDir,
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env, ERNE_PROJECT_DIR: projectDir },
+          });
+          child.unref();
+          dashboardUrl = 'http://localhost:3333 (starting...)';
+        }
+      } catch { /* dashboard not available — skip */ }
+    }
+  } catch { /* port-registry not available — skip */ }
+}
+
+// ─── Print banner ────────────────────────────────────────────────────────────
+
+if (hasSettings) {
+  // Rich banner when ERNE is properly installed
+  const parts = [];
+  if (version) parts.push(`v${version}`);
+  parts.push(profile);
+  if (agentCount > 0) parts.push(`${agentCount} agents`);
+  if (dashboardUrl) parts.push(`Dashboard: ${dashboardUrl}`);
+  console.log(`ERNE ${parts.join(' | ')}`);
+} else {
+  // Fallback: layer-based output for projects without full ERNE init
+  const parts = [];
+  if (version) parts.push(`v${version}`);
+  parts.push(`${profile} profile`);
+  if (agentCount > 0) parts.push(`${agentCount} agents`);
+  parts.push(`layers: ${layers.join(', ')}`);
+  console.log(`ERNE ${parts.join(' | ')}`);
+  console.log(`Use /erne- commands (e.g. /erne-plan, /erne-perf, /erne-doctor)`);
+}
 
 if (!hasSignals) {
   process.exit(2); // warn