claude-prism 1.0.0 → 1.1.0

package/README.md

@@ -1,73 +1,79 @@
 ```
-                         ╱╲
-            ━━━━━━━━━▶  ╱  ╲  ── U  Understand
-            complex    ╱    ╲ ── D  Decompose
-            problem   ╱ PRISM╲── E  Execute
-                     ╱________╲─ C  Checkpoint
+                           ╱╲
+              ━━━━━━━━━▶  ╱  ╲  ── E  Essence
+              complex    ╱    ╲ ── U  Understand
+              problem   ╱ PRISM╲── D  Decompose
+                       ╱        ╲─ E  Execute
+                      ╱__________╲─ C  Checkpoint
 ```
 
 [![npm version](https://img.shields.io/npm/v/claude-prism)](https://www.npmjs.com/package/claude-prism)
 [![license](https://img.shields.io/npm/l/claude-prism)](https://github.com/lazysaturday91/claude-prism/blob/main/LICENSE)
 [![node](https://img.shields.io/node/v/claude-prism)](https://nodejs.org)
+[![CI](https://github.com/lazysaturday91/claude-prism/actions/workflows/ci.yml/badge.svg)](https://github.com/lazysaturday91/claude-prism/actions/workflows/ci.yml)
 
-> `ai-coding` · `methodology` · `udec` · `claude-code`
+> `ai-coding` · `methodology` · `eudec` · `claude-code`
 
 # claude-prism
 
-**UDEC methodology framework for AI coding agents.**
+**EUDEC methodology framework for AI coding agents.**
 
-Installs the UDEC methodology — **Understand, Decompose, Execute, Checkpoint** — directly into your project's Claude Code environment. Includes an entry protocol (Assess) and session transition protocol (Handoff) that bookend the core cycle. Three lightweight hooks enforce the methodology where it matters most.
+Installs the EUDEC methodology — **Essence, Understand, Decompose, Execute, Checkpoint** — directly into your project's Claude Code environment. Includes a session transition protocol (Handoff) that bookends the core cycle. Three lightweight hooks enforce the methodology where it matters most.
 
 ## The Problem
 
 AI coding agents fail in predictable ways:
 
-| Failure Mode | What Happens | UDEC Fix |
+| Failure Mode | What Happens | EUDEC Fix |
 |---|---|---|
+| Skip essence extraction | Solves the wrong problem entirely | ESSENCE phase |
 | Skip understanding | Builds the wrong thing for 30 minutes | UNDERSTAND phase |
 | No decomposition | One massive change that's hard to review | DECOMPOSE into verifiable batches |
-| No verification | "should work" without evidence | Risk-based verification strategy |
-| Scope creep | "While I'm here..." changes nobody asked for | Scope Guard in methodology |
-| Context loss | New session = start from scratch | HANDOFF protocol |
+| No verification | "should work" without evidence | Risk-based verification + Fallback Ladder |
+| Scope creep | "While I'm here..." changes nobody asked for | Scope Guard + Thrashing Detector |
+| Context loss | New session = start from scratch | HANDOFF + Project Memory |
 
 **The biggest failure mode of AI coding isn't bad code — it's building the wrong thing.**
 
 ## Core Philosophy
 
-> Never implement what you haven't understood. Never execute what you haven't decomposed.
+> Never implement what you haven't understood. Never understand what you haven't distilled to its essence.
 
 ## What Prism Provides
 
-### 1. UDEC v2 Methodology (the core product)
+### 1. EUDEC Methodology (the core product)
 
-Injected into `CLAUDE.md`, UDEC is a behavioral framework that corrects how AI agents approach tasks:
+Injected into `CLAUDE.md`, EUDEC is a behavioral framework that corrects how AI agents approach tasks:
 
 ```
-  ASSESS ─── Classify: bugfix / feature / migration / refactor / investigation
-    │                                          (entry protocol)
-    ▼
-┌─────────────────── UDEC Core Cycle ───────────────────┐
+┌─────────────────── EUDEC Core Cycle ──────────────────┐
+│ ESSENCE ── Extract core problem → simplify → expand    │
+│   │        Task type derivation from essence           │
 │ UNDERSTAND ── Sufficiency assessment → ask → align     │
-│   │                                                    │
-│ DECOMPOSE ── Batches → plan file for 6+ files → [S][M][L] │
-│   │                                                    │
+│   │          Environment validation                    │
+│ DECOMPOSE ── Batches → plan file → quality gate        │
+│   │          Codebase audit → cross-plan check         │
 │ EXECUTE ── Adaptive batches → risk-based verification  │
-│   │                                                    │
-│ CHECKPOINT ── Report with evidence → get approval ─────┤
+│   │        Goal recitation → thrashing detection       │
+│ CHECKPOINT ── Report with evidence → plan-reality sync │
 │              (loops back for next batch)                │
 └────────────────────────────────────────────────────────┘
     │
     ▼
-  HANDOFF ── Session transition doc → next steps
+  HANDOFF ── Session transition doc + Project Memory
                                            (exit protocol)
 ```
 
 **Task-type aware**: Each task type (bugfix, feature, migration, refactor, investigation) follows a different optimal path. Migrations skip per-file decomposition. Bugfixes skip straight to locate-fix-verify. Investigations skip decomposition entirely.
 
-**Risk-based verification**: Verification matches the risk of the change, not the file path:
-- **High risk** (business logic, auth, state machines): TDD required
+**Risk-based verification** with Fallback Ladder:
+- **High risk** (business logic, auth, state machines): TDD required + negative tests
 - **Medium risk** (new components, API integration): Build + runtime check
 - **Low risk** (imports, types, renaming): Build/lint passes
+- **No test infra** (legacy PHP, WordPress): Grep-based static check + syntax validation
+- Fallback: Automated Tests → Approval Testing → Build → Lint → Smoke Check → Manual Diff
+
+**Quality gates** between phases prevent executing on broken baselines.
 
 ### 2. Three Focused Hooks
 
@@ -85,18 +91,56 @@ Hooks enforce the methodology at critical points. All three are deterministic (n
 
 | Command | Purpose |
 |---------|---------|
-| `/claude-prism:prism` | Run full UDEC cycle |
-| `/claude-prism:checkpoint` | Check batch progress |
+| `/claude-prism:prism` | Run full EUDEC cycle |
+| `/claude-prism:checkpoint` | Check batch progress with plan-reality sync |
 | `/claude-prism:plan` | List/create/view plan files |
+| `/claude-prism:analytics` | Show usage analytics (blocks, warns, tests) |
 | `/claude-prism:doctor` | Diagnose installation health |
 | `/claude-prism:stats` | Version, hooks, plan count |
 | `/claude-prism:update` | Update to latest version |
+| `/claude-prism:hud` | Manage the statusline HUD |
 | `/claude-prism:help` | Command reference |
 
+### 4. HUD Statusline
+
+Prism includes an optional statusline HUD for Claude Code that shows live project context at the bottom of the terminal:
+
+```
+⚡ my-project:main | Opus 4.6 | 🔋84% | 11:17
+📋 auth-refactor 60%(6/10) | 💾 fix: token validation (2h)
+📊 세션 45%(30m) │ 주간92%(목 19:00)
+```
+
+| Line | Content |
+|------|---------|
+| 1 | Project:branch · model · context % · time |
+| 2 | Active plan progress · last commit · test status |
+| 3 | Session and weekly usage (when available) |
+
+Enable during install (interactive prompt) or at any time:
+
+```bash
+prism hud enable    # Install script + update ~/.claude/settings.json
+prism hud disable   # Remove statusLine setting
+prism hud           # Show current status
+```
+
+Or from within Claude Code: `/claude-prism:hud enable`
+
+### 4. Analytics
+
+Hook events (blocks, warnings) are automatically logged to session files. View aggregated statistics:
+
+```bash
+prism analytics             # Summary across all sessions
+prism analytics --detail    # Include per-session breakdown
+```
+
 ## Installation
 
 ```bash
-npx claude-prism init              # Install with hooks
+npx claude-prism init              # Install with hooks (prompts for HUD)
+npx claude-prism init --hud        # Install + auto-enable HUD
 npx claude-prism init --no-hooks   # Methodology only, no hooks
 npx claude-prism init --global     # Global skill (all projects)
 npx claude-prism init --dry-run    # Preview what would be installed
@@ -106,15 +150,18 @@ npx claude-prism init --dry-run    # Preview what would be installed
 
 ```
 your-project/
-├── CLAUDE.md                    # UDEC methodology injected
+├── CLAUDE.md                    # EUDEC methodology injected
 ├── .claude-prism.json           # Hook configuration
 ├── .claude/
-│   ├── commands/claude-prism/   # 7 slash commands
+│   ├── commands/claude-prism/   # 9 slash commands
 │   ├── hooks/                   # pre-tool.mjs, post-tool.mjs
 │   ├── rules/                   # commit-guard, test-tracker, plan-enforcement
 │   ├── lib/                     # Shared dependencies
 │   └── settings.json            # Hook registration
 └── docs/plans/                  # Plan files (created during work)
+
+~/.claude/                       # (HUD — global, opt-in)
+└── hud/omc-hud.mjs              # Statusline script
 ```
 
 ## Configuration
@@ -123,6 +170,7 @@ Edit `.claude-prism.json`:
 
 ```json
 {
+  "version": 1,
   "hooks": {
     "commit-guard": { "enabled": true, "maxTestAge": 300 },
     "test-tracker": { "enabled": true },
@@ -133,6 +181,7 @@ Edit `.claude-prism.json`:
 
 | Setting | Default | Description |
 |---------|---------|-------------|
+| `version` | 1 | Config schema version (for future migrations) |
 | `commit-guard.maxTestAge` | 300 | Seconds before test run is considered stale |
 | `plan-enforcement.warnAt` | 6 | Unique source file count that triggers plan warning |
 
@@ -140,12 +189,17 @@ Edit `.claude-prism.json`:
 
 ```bash
 prism init [--no-hooks] [--global] [--dry-run]   # Install
+prism init --hud                                   # Install + auto-enable HUD
 prism check [--ci]                                 # Verify installation
 prism doctor                                       # Diagnose issues
 prism stats                                        # Installation summary
+prism analytics [--detail]                         # Usage analytics
 prism reset                                        # Clear hook state
 prism update [--global]                            # Update to latest
 prism uninstall [--global]                         # Remove
+prism hud                                          # HUD status
+prism hud enable                                   # Activate HUD statusline
+prism hud disable                                  # Deactivate HUD statusline
 ```
 
 ## Before & After
@@ -155,9 +209,9 @@ prism uninstall [--global]                         # Remove
 2. AI: 30 minutes autonomous execution, no questions asked
 3. Result: Structure nobody wanted, untested, scope creep everywhere
 
-**After** (with UDEC):
+**After** (with EUDEC):
 1. User: "Refactor auth module"
-2. AI classifies as **Refactor** type, assesses information as **[Partial]**
+2. AI extracts **essence**: "Separate concerns in auth module", classifies as **Refactor**, assesses information as **[Partial]**
 3. Asks: "Keep existing API surface? Or allowed to change public interface?"
 4. Decomposes into 3 batches with size tags, creates plan file
 5. Executes batch 1 → checkpoints with evidence → continues on approval
@@ -169,9 +223,9 @@ Prism auto-detects [oh-my-claudecode](https://github.com/raidenppl/oh-my-claudec
 
 ## Design Philosophy
 
-UDEC is the product. Everything else serves it.
+EUDEC is the product. Everything else serves it.
 
-The methodology works because it targets the specific failure modes of AI agents — not human developers. Humans naturally ask questions and break things down. AI optimizes for speed and skips these steps. UDEC forces the discipline that makes AI-assisted coding reliable.
+The methodology works because it targets the specific failure modes of AI agents — not human developers. Humans naturally ask questions and break things down. AI optimizes for speed and skips these steps. EUDEC forces the discipline that makes AI-assisted coding reliable — starting from the essence of the problem.
 
 The hooks exist to enforce the two most critical rules:
 1. **Don't commit untested code** (commit-guard + test-tracker)

package/bin/cli.mjs

@@ -11,7 +11,7 @@
  *        prism update
  */
 
-import { init, check, uninstall, update, doctor, stats, reset, initGlobal, uninstallGlobal } from '../lib/installer.mjs';
+import { init, check, uninstall, update, doctor, stats, reset, initGlobal, uninstallGlobal, installHud, uninstallHud, hudStatus } from '../lib/installer.mjs';
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -60,13 +60,41 @@ switch (command) {
     console.log('🌈 claude-prism init\n');
     await init(cwd, { hooks });
 
-    console.log('✅ UDEC methodology → CLAUDE.md');
+    console.log('✅ EUDEC methodology → CLAUDE.md');
     console.log('✅ Commands → /prism, /checkpoint, /plan');
     if (hooks) {
       console.log('✅ Commit guard → blocks commits with failing tests');
     } else {
       console.log('⏭️  Hooks skipped (--no-hooks)');
     }
+
+    // HUD prompt — only ask interactively if not already installed and no flag given
+    if (!hasFlag('no-hud') && process.stdin.isTTY) {
+      const status = hudStatus();
+      if (!status.enabled) {
+        const { createInterface } = await import('readline');
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve =>
+          rl.question('\n🖥️  Enable Prism HUD statusline? Shows project/branch/plan in Claude Code (y/N): ', a => {
+            rl.close();
+            resolve(a.trim().toLowerCase());
+          })
+        );
+        if (answer === 'y' || answer === 'yes') {
+          const { scriptPath } = installHud();
+          console.log(`✅ HUD enabled → ${scriptPath}`);
+          console.log('   Restart Claude Code to activate.');
+        } else {
+          console.log('⏭️  HUD skipped (run `prism hud enable` anytime)');
+        }
+      } else {
+        console.log('✅ HUD already enabled');
+      }
+    } else if (hasFlag('hud')) {
+      const { scriptPath } = installHud();
+      console.log(`✅ HUD enabled → ${scriptPath}`);
+    }
+
     console.log('\n🌈 Done. Use /prism before complex tasks.');
     break;
   }
@@ -132,6 +160,44 @@ switch (command) {
     break;
   }
 
+  case 'hud': {
+    const subcommand = args[1];
+
+    if (subcommand === 'enable') {
+      console.log('🌈 claude-prism hud enable\n');
+      const { scriptPath } = installHud();
+      console.log(`  ✅ HUD script → ${scriptPath}`);
+      console.log('  ✅ statusLine → ~/.claude/settings.json');
+      console.log('\n  Restart Claude Code to activate.');
+      break;
+    }
+
+    if (subcommand === 'disable') {
+      console.log('🌈 claude-prism hud disable\n');
+      uninstallHud();
+      console.log('  ✅ statusLine removed from ~/.claude/settings.json');
+      console.log('\n  Restart Claude Code to apply.');
+      break;
+    }
+
+    // Default: show status
+    console.log('🌈 claude-prism hud\n');
+    const status = hudStatus();
+    console.log(`  Status:  ${status.enabled ? '✅ enabled' : '⏭️  disabled'}`);
+    if (status.scriptExists) {
+      console.log(`  Script:  ~/.claude/hud/omc-hud.mjs`);
+    } else {
+      console.log('  Script:  ❌ not installed');
+    }
+    if (status.command) {
+      console.log(`  Command: ${status.command}`);
+    }
+    if (!status.enabled) {
+      console.log('\n  Run `prism hud enable` to activate.');
+    }
+    break;
+  }
+
   case 'uninstall': {
     if (hasFlag('global')) {
       console.log('🌈 claude-prism uninstall --global\n');
@@ -165,9 +231,9 @@ switch (command) {
     console.log('🌈 claude-prism update\n');
     const result = await update(cwd);
     if (result?.sourceRepo) {
-      console.log('✅ UDEC methodology updated (from local templates)');
+      console.log('✅ EUDEC methodology updated (from local templates)');
     } else {
-      console.log('✅ UDEC methodology updated');
+      console.log('✅ EUDEC methodology updated');
     }
     console.log('✅ Commands updated');
     console.log('✅ Commit guard updated');
@@ -239,7 +305,7 @@ switch (command) {
   }
 
   default: {
-    console.log(`🌈 claude-prism — UDEC methodology framework for AI coding agents
+    console.log(`🌈 claude-prism — EUDEC methodology framework for AI coding agents
 
 Usage:
   prism init [--no-hooks]                Install prism in current project
@@ -253,9 +319,14 @@ Usage:
   prism update --global                  Update global commands + OMC skill
   prism uninstall                        Remove prism from current project
   prism uninstall --global               Remove global commands + OMC skill
+  prism hud                              Show HUD statusline status
+  prism hud enable                       Install and activate the HUD
+  prism hud disable                      Deactivate the HUD
 
 Options:
   --no-hooks   Skip commit guard hook
+  --hud        Auto-enable HUD during init (no prompt)
+  --no-hud     Skip HUD prompt during init
   --dry-run    Show what init would do without making changes
   --global     Install/uninstall globally (all projects)
   --ci         Output JSON for CI integration

package/hooks/plan-enforcement.mjs

@@ -1,7 +1,7 @@
 /**
  * claude-prism — Plan Enforcement
  * Warns when editing many files without a plan file
- * Reinforces UDEC's DECOMPOSE phase
+ * Reinforces EUDEC's DECOMPOSE phase
  */
 
 import { readJsonState, writeJsonState } from '../lib/state.mjs';

package/lib/installer.mjs

@@ -28,7 +28,7 @@ export async function init(projectDir, options = {}) {
   const nsCommandsDir = join(claudeDir, 'commands', 'claude-prism');
   mkdirSync(nsCommandsDir, { recursive: true });
 
-  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md'];
+  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md', 'hud.md'];
   for (const cmd of commandFiles) {
     copyFileSync(
       join(TEMPLATES_DIR, 'commands', 'claude-prism', cmd),
@@ -302,7 +302,7 @@ export function doctor(projectDir, options = {}) {
 
   // Check namespaced commands
   const nsCommandsDir = join(claudeDir, 'commands', 'claude-prism');
-  const expectedCommands = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md'];
+  const expectedCommands = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md', 'hud.md'];
   for (const cmd of expectedCommands) {
     if (!existsSync(join(nsCommandsDir, cmd))) {
       issues.push(`Missing command: claude-prism/${cmd}`);
@@ -449,7 +449,7 @@ export function initGlobal(options = {}) {
   const commandsDir = join(claudeDir, 'commands', 'claude-prism');
   mkdirSync(commandsDir, { recursive: true });
 
-  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md'];
+  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md', 'hud.md'];
   for (const cmd of commandFiles) {
     copyFileSync(
       join(TEMPLATES_DIR, 'commands', 'claude-prism', cmd),
@@ -494,7 +494,7 @@ export function dryRun(projectDir, options = {}) {
 
   // Commands
   const nsCommandsDir = join(claudeDir, 'commands', 'claude-prism');
-  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md'];
+  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md', 'analytics.md', 'hud.md'];
   for (const cmd of commandFiles) {
     const target = join(nsCommandsDir, cmd);
     actions.push({
@@ -551,6 +551,88 @@ export function dryRun(projectDir, options = {}) {
   return { actions };
 }
 
+// ─── HUD management ───
+
+/**
+ * Install the Prism HUD statusline
+ * @param {Object} [options]
+ * @param {string} [options.homeDir] - Override home dir (for testing)
+ */
+export function installHud(options = {}) {
+  const home = options.homeDir || homedir();
+  const claudeDir = join(home, '.claude');
+  const hudDir = join(claudeDir, 'hud');
+
+  // 1. Copy HUD script
+  mkdirSync(hudDir, { recursive: true });
+  const scriptDest = join(hudDir, 'omc-hud.mjs');
+  const scriptSrc = join(TEMPLATES_DIR, 'hud', 'omc-hud.mjs');
+
+  // Backup existing custom HUD if present and different from generic wrapper
+  if (existsSync(scriptDest)) {
+    const existing = readFileSync(scriptDest, 'utf8');
+    // If existing file is larger than our template it's likely a custom HUD — keep a backup
+    const template = readFileSync(scriptSrc, 'utf8');
+    if (existing.length > template.length + 100) {
+      writeFileSync(join(hudDir, 'omc-hud.mjs.prism-backup'), existing);
+    }
+  }
+
+  copyFileSync(scriptSrc, scriptDest);
+
+  // 2. Update ~/.claude/settings.json
+  const settingsPath = join(claudeDir, 'settings.json');
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  }
+  settings.statusLine = {
+    type: 'command',
+    command: `node ${scriptDest}`
+  };
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+
+  return { scriptPath: scriptDest };
+}
+
+/**
+ * Disable the Prism HUD statusline (removes statusLine from settings)
+ * @param {Object} [options]
+ * @param {string} [options.homeDir] - Override home dir (for testing)
+ */
+export function uninstallHud(options = {}) {
+  const home = options.homeDir || homedir();
+  const settingsPath = join(home, '.claude', 'settings.json');
+
+  if (!existsSync(settingsPath)) return;
+
+  const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  delete settings.statusLine;
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+/**
+ * Get current HUD status
+ * @param {Object} [options]
+ * @param {string} [options.homeDir] - Override home dir (for testing)
+ * @returns {{ enabled: boolean, scriptExists: boolean, command: string|undefined }}
+ */
+export function hudStatus(options = {}) {
+  const home = options.homeDir || homedir();
+  const settingsPath = join(home, '.claude', 'settings.json');
+  const scriptPath = join(home, '.claude', 'hud', 'omc-hud.mjs');
+
+  if (!existsSync(settingsPath)) {
+    return { enabled: false, scriptExists: existsSync(scriptPath), command: undefined };
+  }
+
+  const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  const cmd = settings.statusLine?.command;
+  const enabled = settings.statusLine?.type === 'command' && !!cmd?.includes('omc-hud.mjs');
+
+  return { enabled, scriptExists: existsSync(scriptPath), command: cmd };
+}
+
 // ─── internal helpers ───
 
 function injectRules(projectDir, overrideRulesPath) {

package/lib/messages.mjs

@@ -7,7 +7,7 @@ const MESSAGES = {
   'commit-guard.warn.no-test': '🌈 Prism > No test run detected this session. Run tests before committing.',
   'commit-guard.warn.stale': '🌈 Prism > Last test run was {minutes}min ago. Run tests before committing.',
   'test-tracker.warn.failed': '🌈 Prism 📊 Tests FAILED. Fix before committing.',
-  'plan-enforcement.warn.no-plan': '🌈 Prism > Editing {count} unique source files without a plan. Create a plan at docs/plans/ per UDEC DECOMPOSE protocol.',
+  'plan-enforcement.warn.no-plan': '🌈 Prism > Editing {count} unique source files without a plan. Create a plan at docs/plans/ per EUDEC DECOMPOSE protocol.',
 };
 
 export function getMessage(_lang, key, params = {}) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-prism",
-  "version": "1.0.0",
-  "description": "UDEC methodology framework for AI coding agents — Understand, Decompose, Execute, Checkpoint.",
+  "version": "1.1.0",
+  "description": "EUDEC methodology framework for AI coding agents — Essence, Understand, Decompose, Execute, Checkpoint.",
   "type": "module",
   "bin": {
     "prism": "./bin/cli.mjs"
@@ -20,6 +20,7 @@
     "problem-decomposition",
     "claude-code-hooks",
     "udec",
+    "eudec",
     "ai-agent"
   ],
   "engines": {

package/templates/commands/claude-prism/help.md

@@ -4,7 +4,7 @@
 
 | Command | Description |
 |---------|-------------|
-| `/claude-prism:prism` | Start full UDEC workflow (Understand → Decompose → Execute → Checkpoint). Also handles analysis-only requests — stops after U phase when no code change is needed. |
+| `/claude-prism:prism` | Start full EUDEC workflow (Essence → Understand → Decompose → Execute → Checkpoint). Also handles analysis-only requests — stops after U phase when no code change is needed. |
 | `/claude-prism:checkpoint` | Check current batch progress, show next batch preview |
 | `/claude-prism:plan` | List, create, or view plan files in `docs/plans/` |
 | `/claude-prism:doctor` | Diagnose installation health and suggest fixes |
@@ -31,9 +31,10 @@ prism update                           # Re-install / migrate
 prism uninstall                        # Remove prism
 ```
 
-## UDEC Framework
+## EUDEC Framework
 
 ```
+E — Essence: Extract core problem, simplify to minimal case, define expansion path
 U — Understand: Assess sufficiency, ask questions, confirm alignment
      (analysis-only requests stop here with findings report)
 D — Decompose: Break into 2-5 min units, create plan file

package/templates/commands/claude-prism/hud.md

@@ -0,0 +1,65 @@
+# /claude-prism:hud — HUD Management
+
+When this command is invoked, manage the Prism statusline HUD.
+
+## Usage
+
+- No argument → show current HUD status
+- `enable`    → install and activate the HUD
+- `disable`   → deactivate the HUD
+
+## Steps
+
+### No argument — Show status
+
+Run:
+```bash
+npx claude-prism@latest hud status
+```
+
+Report format:
+```
+🌈 claude-prism hud
+
+  Status:   ✅ enabled
+  Script:   ~/.claude/hud/omc-hud.mjs
+  Command:  node /Users/<you>/.claude/hud/omc-hud.mjs
+
+  Lines:
+    1  ⚡ project:branch | Model | 🔋ctx% | HH:MM
+    2  📋 plan name XX%(done/total) | 💾 commit msg (elapsed)
+    3  📊 세션 XX%(Xm) │ 주간XX%(요일 HH:MM)
+```
+
+### enable
+
+1. Run:
+   ```bash
+   npx claude-prism@latest hud enable
+   ```
+
+2. Report:
+   ```
+   🌈 claude-prism hud enabled
+
+     ✅ HUD script → ~/.claude/hud/omc-hud.mjs
+     ✅ statusLine → ~/.claude/settings.json
+
+     Restart Claude Code to see the HUD.
+   ```
+
+### disable
+
+1. Run:
+   ```bash
+   npx claude-prism@latest hud disable
+   ```
+
+2. Report:
+   ```
+   🌈 claude-prism hud disabled
+
+     ✅ statusLine removed from ~/.claude/settings.json
+
+     Restart Claude Code to apply.
+   ```

package/templates/commands/claude-prism/plan.md

@@ -18,7 +18,7 @@ If user requests a new plan:
 
 1. **Determine topic** from user's description
 2. **Create file** at `docs/plans/YYYY-MM-DD-<topic>.md`
-3. **Use UDEC template**:
+3. **Use EUDEC template**:
 
 ```
 ## Goal

package/templates/commands/claude-prism/prism.md

@@ -1,15 +1,36 @@
 # /claude-prism:prism — Problem Decomposition
 
-When this command is invoked, follow the UDEC framework strictly:
+When this command is invoked, follow the EUDEC framework strictly:
+
+## E — ESSENCE
+
+0. **Extract the essence**: Before exploring code, ask: "What is the core problem here — in one sentence, without naming specific tools?"
+   - Output: `본질: [one sentence]`
+   - Output: `최소 케이스: [simplest working version]`
+   - Output: `확장 경로: minimal → [step1] → [step2] → [complete]`
+1. **Verify essence quality**:
+   - Does the essence sentence avoid specific technology names? If not → still at solution level, go higher
+   - Is the minimal case truly minimal? Can it be reduced further?
+   - Symptom vs cause: "Is this the cause, or a consequence?"
+   - Solution vs essence: "Caching" is a solution. "Eliminating redundant computation" is the essence.
+2. **Derive task type** from the essence:
+
+   | Essence Character | Type | Path |
+   |-------------------|------|------|
+   | "X is broken" | Bugfix | UNDERSTAND → locate → fix → verify |
+   | "X should be possible" | Feature | UNDERSTAND → DECOMPOSE → EXECUTE → CHECKPOINT |
+   | "All X must become Y" | Migration | UNDERSTAND → pattern → batch apply → verify |
+   | "X's structure must change" | Refactor | UNDERSTAND → DECOMPOSE → EXECUTE → CHECKPOINT |
+   | "Why does X happen?" | Investigation | explore → analyze → report |
 
 ## U — UNDERSTAND
 
-1. **Explore first**: Read package.json, project structure, related files before asking anything
-2. **Assess information sufficiency**:
+3. **Explore first**: Read package.json, project structure, related files before asking anything
+4. **Assess information sufficiency**:
    - [Sufficient] Specific file, function, symptom mentioned → skip to DECOMPOSE
    - [Partial] Direction clear but details missing → explore then ask 1-2 questions
    - [Insufficient] Abstract, vague, multiple interpretations → must ask questions first
-3. **Check for hidden assumptions** (Red Flag Detection):
+5. **Check for hidden assumptions** (Red Flag Detection):
 
    | Red Flag | Question to Ask Yourself |
    |----------|-------------------------|
@@ -21,63 +42,63 @@ When this command is invoked, follow the UDEC framework strictly:
    | No file/function names | [Insufficient]. Must ask. |
    | "just", "simply" | Complexity being underestimated |
 
-4. **Question rules** (if questions needed):
+6. **Question rules** (if questions needed):
    - One question at a time
    - Multiple choice with 2-3 options + recommendation
    - Include reasoning based on code exploration
    - Maximum 3 rounds of questions
-5. **Confirm alignment**: Summarize goal in one sentence, get user approval
-6. **Analysis-only requests**: If no code change is needed (architecture review, cause analysis, investigation), report findings and ask: "Further action needed?" Do NOT proceed to D/E/C unless the user requests implementation.
+7. **Confirm alignment**: Summarize goal in one sentence, get user approval
+8. **Analysis-only requests**: If no code change is needed (architecture review, cause analysis, investigation), report findings and ask: "Further action needed?" Do NOT proceed to D/E/C unless the user requests implementation.
 
 ## D — DECOMPOSE
 
-7. **Assess complexity** (consider BOTH file count AND logic complexity):
+9. **Assess complexity** (consider BOTH file count AND logic complexity):
    - [Simple] 1-2 files, minor changes (<50 LOC) → execute directly, no decomposition needed
    - [Medium] 3-5 files, OR 1-2 files with significant logic changes (50-150 LOC) → 2-3 batches
    - [Complex] 6+ files, OR substantial architectural changes → 5+ batches, must create plan file
    - [Complex system] Unclear scope → reduce scope first, then decompose
-8. **Create batches** following the 5 principles:
-   - Unit size: 2-5 minutes each (test/implement/verify as separate steps)
-   - Test first: test before implementation in each unit
-   - Independent verification: each unit has a pass criterion
-   - Files specified: list files to create/modify per unit
-   - Dependencies noted: mark if unit depends on a previous one
-9. **Assign size tags** to every task: [S] <30 LOC, [M] 30-100 LOC, [L] >100 LOC
-   - Batch composition: S+S+M = 1 batch, L = 1 batch alone
-10. **Assign verification strategy** per task: `| Verify: TDD` or `| Verify: Build` or `| Verify: Visual`
-11. **Pre-decomposition checklist**:
+10. **Create batches** following the 5 principles:
+    - Unit size: 2-5 minutes each (test/implement/verify as separate steps)
+    - Test first: test before implementation in each unit
+    - Independent verification: each unit has a pass criterion
+    - Files specified: list files to create/modify per unit
+    - Dependencies noted: mark if unit depends on a previous one
+11. **Assign size tags** to every task: [S] <30 LOC, [M] 30-100 LOC, [L] >100 LOC
+    - Batch composition: S+S+M = 1 batch, L = 1 batch alone
+12. **Assign verification strategy** per task: `| Verify: TDD` or `| Verify: Build` or `| Verify: Visual`
+13. **Pre-decomposition checklist**:
     - Required types/interfaces have the necessary fields?
     - External package APIs behave as expected?
     - Cross-package dependencies identified and noted as prerequisites?
-12. **Save plan** to `docs/plans/YYYY-MM-DD-<topic>.md`
-13. **Get approval**: "Proceed with this plan?"
+14. **Save plan** to `docs/plans/YYYY-MM-DD-<topic>.md`
+15. **Get approval**: "Proceed with this plan?"
 
 ## E — EXECUTE
 
-14. Execute in adaptive batches:
+16. Execute in adaptive batches:
     - Simple changes (imports, types, config): 5-8 per batch
     - Standard changes (feature add/modify): 3-4 per batch
     - Complex changes (new module, architecture): 1-2 per batch
-15. Apply context-aware verification:
+17. Apply context-aware verification:
     - `lib/`, `utils/`, `store/`, `hooks/`, `services/` → TDD (failing test → implement → verify)
     - `components/`, `pages/`, `views/` → Build verification (escalate to TDD if complex logic)
     - `config/`, `styles/`, `types/` → Build/lint only
-16. **Scope Guard**: Before each change, ask: "Was this requested?" If no → don't do it
-17. **Self-correction triggers**:
+18. **Scope Guard**: Before each change, ask: "Was this requested?" If no → don't do it
+19. **Self-correction triggers**:
     - Same file edited 3+ times **on the same region/logic** → stop, investigate root cause (progressive edits across different regions — imports, logic, JSX — are normal)
     - File not in plan → pause, ask about scope change
     - 3 consecutive test failures → stop, reconsider approach
     - New package needed → ask user first
     - Adding workarounds on workarounds → design problem, step back
-18. **Verification scoping**: When running build checks (tsc, lint, etc.), filter output to only changed files. Pre-existing errors in other files are not your concern. Example: `tsc --noEmit 2>&1 | grep -i "<changed-file>"`
-19. **Agent failure recovery**: If a delegated agent partially fails or produces incomplete results:
+20. **Verification scoping**: When running build checks (tsc, lint, etc.), filter output to only changed files. Pre-existing errors in other files are not your concern. Example: `tsc --noEmit 2>&1 | grep -i "<changed-file>"`
+21. **Agent failure recovery**: If a delegated agent partially fails or produces incomplete results:
     1. Verify actual file state (read the file, not just the agent's report)
     2. If partially correct → complete the remaining work directly
     3. If fully wrong → retry with clearer instructions or execute directly
 
 ## C — CHECKPOINT
 
-20. After each batch, report using this format:
+22. After each batch, report using this format:
 
     | Item | Before | After |
     |------|--------|-------|
@@ -88,10 +109,10 @@ When this command is invoked, follow the UDEC framework strictly:
     [████████░░] 80% — Next: [next batch name]
     ```
 
-21. Include: verification results, files modified, tests status
-22. **Checkpoint policy**: after 3 consecutive approvals, increase batch size to 5-8 for the rest of the phase
-23. Ask: "Continue to next batch?"
-24. User can redirect, adjust scope, or stop at any checkpoint
+23. Include: verification results, files modified, tests status
+24. **Checkpoint policy**: after 3 consecutive approvals, increase batch size to 5-8 for the rest of the phase
+25. Ask: "Continue to next batch?"
+26. User can redirect, adjust scope, or stop at any checkpoint
 
 ## OMC Integration
 

package/templates/hud/omc-hud.mjs

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir, tmpdir } from 'os';
+
+function shortenModelName(name) {
+  return name
+    .replace('Claude 3.5 Sonnet', 'Sonnet 3.5')
+    .replace('Claude 3 Opus', 'Opus 3')
+    .replace('Claude 3 Haiku', 'Haiku 3')
+    .replace('Claude ', '');
+}
+
+function getCurrentTime() {
+  const now = new Date();
+  return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+}
+
+function hasGitChanges(cwd) {
+  try {
+    const status = execSync('git -c core.fileMode=false status --porcelain 2>/dev/null', {
+      encoding: 'utf-8', cwd, stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    return status.length > 0;
+  } catch { return false; }
+}
+
+function getPlanUsage() {
+  try {
+    const cachePath = join(homedir(), '.claude', 'plugins', 'oh-my-claudecode', '.usage-cache.json');
+    if (!existsSync(cachePath)) return null;
+    const cache = JSON.parse(readFileSync(cachePath, 'utf-8'));
+    if (cache.error || !cache.data) return null;
+    const now = new Date();
+    const { fiveHourPercent, weeklyPercent, fiveHourResetsAt, weeklyResetsAt } = cache.data;
+    const minutesUntilReset = Math.max(0, Math.round((new Date(fiveHourResetsAt) - now) / 60000));
+    const weeklyReset = new Date(weeklyResetsAt);
+    const dayNames = ['일', '월', '화', '수', '목', '금', '토'];
+    return {
+      session: fiveHourPercent,
+      weekly: weeklyPercent,
+      sessionResetMin: minutesUntilReset,
+      weeklyResetLabel: `${dayNames[weeklyReset.getDay()]} ${String(weeklyReset.getHours()).padStart(2, '0')}:${String(weeklyReset.getMinutes()).padStart(2, '0')}`
+    };
+  } catch { return null; }
+}
+
+function getGitRoot(cwd) {
+  try {
+    return execSync('git rev-parse --show-toplevel 2>/dev/null', {
+      encoding: 'utf-8', cwd, stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+  } catch { return null; }
+}
+
+function getActivePlan(cwd) {
+  try {
+    const gitRoot = getGitRoot(cwd);
+    if (!gitRoot) return null;
+    const plansDir = join(gitRoot, 'docs', 'plans');
+    if (!existsSync(plansDir)) return null;
+    const files = readdirSync(plansDir).filter(f => f.endsWith('.md')).sort().reverse();
+    if (files.length === 0) return null;
+    const latestFile = files[0];
+    const content = readFileSync(join(plansDir, latestFile), 'utf-8');
+    const doneCount = (content.match(/- \[x\]/gi) || []).length;
+    const todoCount = (content.match(/- \[ \]/g) || []).length;
+    const total = doneCount + todoCount;
+    const planName = latestFile.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/\.md$/, '');
+    return { name: planName, done: doneCount, total, percent: total > 0 ? Math.round((doneCount / total) * 100) : 0 };
+  } catch { return null; }
+}
+
+function relativeTime(unixTimestamp) {
+  const diff = Math.floor(Date.now() / 1000) - unixTimestamp;
+  if (diff < 60) return `${diff}s`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h`;
+  if (diff < 604800) return `${Math.floor(diff / 86400)}d`;
+  return `${Math.floor(diff / 604800)}w`;
+}
+
+function getRecentCommit(cwd) {
+  try {
+    const raw = execSync('git log -1 --format="%s|%ct" 2>/dev/null', {
+      encoding: 'utf-8', cwd, stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    if (!raw) return null;
+    const sepIdx = raw.lastIndexOf('|');
+    if (sepIdx === -1) return null;
+    const message = raw.substring(0, sepIdx);
+    const timestamp = parseInt(raw.substring(sepIdx + 1), 10);
+    const maxLen = 25;
+    const truncated = message.length > maxLen ? message.substring(0, maxLen - 1) + '\u2026' : message;
+    return { message: truncated, elapsed: relativeTime(timestamp) };
+  } catch { return null; }
+}
+
+function getTestStatus() {
+  try {
+    const prismRoot = join(tmpdir(), '.prism');
+    if (!existsSync(prismRoot)) return null;
+    let latestRun = 0;
+    let latestDir = null;
+    for (const dir of readdirSync(prismRoot)) {
+      const dirPath = join(prismRoot, dir);
+      try { if (!statSync(dirPath).isDirectory()) continue; } catch { continue; }
+      const runFile = join(dirPath, 'last-test-run');
+      if (!existsSync(runFile)) continue;
+      const runTs = parseInt(readFileSync(runFile, 'utf-8').trim(), 10);
+      if (runTs > latestRun) { latestRun = runTs; latestDir = dirPath; }
+    }
+    if (!latestDir) return null;
+    const resultFile = join(latestDir, 'last-test-result');
+    const result = existsSync(resultFile) ? readFileSync(resultFile, 'utf-8').trim() : null;
+    return { passed: result === 'pass', elapsed: relativeTime(latestRun) };
+  } catch { return null; }
+}
+
+// ═══════════════════════════════════════════════════════════════
+
+try {
+  const fs = await import('fs');
+  const input = fs.readFileSync(0, 'utf-8');
+  const context = JSON.parse(input);
+
+  const cwd = context.workspace?.current_dir || process.cwd();
+  const dirName = cwd.split('/').pop();
+  const modelName = shortenModelName(context.model?.display_name || 'Claude');
+  const remaining = context.context_window?.remaining_percentage;
+  const planUsage = getPlanUsage();
+
+  let gitBranch = '';
+  let gitDirty = false;
+  try {
+    gitBranch = execSync(
+      'git -c core.fileMode=false -c core.checkStat=minimal symbolic-ref --short HEAD 2>/dev/null || git -c core.fileMode=false -c core.checkStat=minimal rev-parse --short HEAD 2>/dev/null',
+      { encoding: 'utf-8', cwd, stdio: ['ignore', 'pipe', 'ignore'] }
+    ).trim();
+    if (gitBranch) gitDirty = hasGitChanges(cwd);
+  } catch {}
+
+  const activePlan = getActivePlan(cwd);
+  const recentCommit = getRecentCommit(cwd);
+  const testStatus = getTestStatus();
+
+  const S = ' | ';
+
+  // ── Line 1: Project:Branch | Model | Ctx% | Time ──
+  const line1 = [];
+  if (gitBranch) {
+    const dirty = gitDirty ? '*' : '';
+    line1.push(`\u26A1 ${dirName}:${gitBranch}${dirty}`);
+  } else {
+    line1.push(`\u26A1 ${dirName}`);
+  }
+  line1.push(modelName);
+  if (remaining !== null && remaining !== undefined) {
+    const pct = Math.round(remaining);
+    const icon = pct < 20 ? '\uD83D\uDD34' : pct < 50 ? '\u26A0\uFE0F' : '\uD83D\uDD0B';
+    line1.push(`${icon}${pct}%`);
+  }
+  line1.push(getCurrentTime());
+
+  // ── Line 2: Plan + Commit + Test ──
+  const line2 = [];
+  if (activePlan) {
+    const short = activePlan.name.length > 12 ? activePlan.name.substring(0, 11) + '\u2026' : activePlan.name;
+    line2.push(`\uD83D\uDCCB ${short} ${activePlan.percent}%(${activePlan.done}/${activePlan.total})`);
+  }
+  if (recentCommit) {
+    line2.push(`\uD83D\uDCBE ${recentCommit.message}(${recentCommit.elapsed})`);
+  }
+  if (testStatus) {
+    line2.push(`${testStatus.passed ? '\u2705' : '\u274C'}${testStatus.elapsed}`);
+  }
+
+  // ── Line 3: Usage ──
+  const line3 = [];
+  if (planUsage) {
+    const warn = (planUsage.session > 95 || planUsage.weekly > 95) ? '\uD83D\uDD34' : (planUsage.session > 80 || planUsage.weekly > 80) ? '\u26A0\uFE0F' : '';
+    line3.push(`\uD83D\uDCCA ${planUsage.session}%(${planUsage.sessionResetMin}m) \u2502 \uC8FC\uAC04${planUsage.weekly}%(${planUsage.weeklyResetLabel})${warn}`);
+  }
+
+  // ── Compose ──
+  const lines = [line1.join(S)];
+  if (line2.length > 0) lines.push(line2.join(S));
+  if (line3.length > 0) lines.push(line3.join(S));
+
+  console.log(lines.join('\n'));
+
+} catch (e) {
+  const powerEmojis = ['\u26A1', '\uD83D\uDD25', '\uD83D\uDE80', '\u2728'];
+  const randomEmoji = powerEmojis[Math.floor(Math.random() * powerEmojis.length)];
+  console.log(`${randomEmoji} LazySaturday \u276F \uD83E\uDDE0 Claude \u276F \uD83D\uDD50 ${getCurrentTime()}`);
+}

package/templates/rules.md

@@ -1,33 +1,74 @@
 
 <!-- PRISM:START -->
-# Prism — UDEC Methodology Framework
+# Prism — EUDEC Methodology Framework
 
-**UDEC = Understand, Decompose, Execute, Checkpoint** — the core cycle.
-Bookended by ASSESS (entry protocol) and HANDOFF (exit protocol).
+**EUDEC = Essence, Understand, Decompose, Execute, Checkpoint** — the core cycle.
+Bookended by HANDOFF (exit protocol).
 
 ## Core Principle
 
-**Never implement what you haven't understood. Never execute what you haven't decomposed.**
+**Never implement what you haven't understood. Never understand what you haven't distilled to its essence.**
+
+The approach: **Essence → Simplify → Expand**. Strip down to the core of the problem, reduce to its simplest form, then build up from the smallest working unit.
 
 ---
 
-## Entry: ASSESS — Task Type Classification
+## EUDEC 1. ESSENCE — Essence Extraction Protocol
+
+Starting point for all work. Strip down to the core of the problem before implementation.
+
+### 1-1. Essence Extraction (3 Steps)
+
+| Step | Question | Output |
+|------|----------|--------|
+| **Extract** | "What do they actually want?" | Essence statement (1 sentence) |
+| **Simplify** | "What's the smallest working version?" | Minimal case |
+| **Expansion path** | "How do we grow from here?" | Expansion steps (2-4 steps) |
+
+**Output format:**
+```
+## ESSENCE
+- Essence: [one sentence — no technology/tool names]
+- Minimal case: [simplest working form]
+- Expansion path: minimal → [step1] → [step2] → [complete]
+```
 
-Before any work, classify the task. Each type follows a different optimal path.
+### 1-2. Task Type Derivation
 
-| Type | Signal | Path |
-|------|--------|------|
-| **Bugfix** | Error message, broken behavior, regression | UNDERSTAND → locate → hypothesis → fix → verify |
-| **Feature** | New capability, user story, "add X" | UNDERSTAND → DECOMPOSE → EXECUTE batches → CHECKPOINT |
-| **Migration** | Pattern replacement across many files, "convert all X to Y" | UNDERSTAND → define pattern + scope → apply × N → verify |
-| **Refactor** | Structural change, "extract", "reorganize" | UNDERSTAND → DECOMPOSE → EXECUTE batches → CHECKPOINT |
-| **Investigation** | "Why does X happen?", "How does Y work?" | explore → analyze → report (no DECOMPOSE needed) |
+The task type naturally emerges from the essence:
+
+| Essence Character | Type | Path |
+|-------------------|------|------|
+| "X is broken" | Bugfix | UNDERSTAND → locate → fix → verify |
+| "X should be possible" | Feature | UNDERSTAND → DECOMPOSE → EXECUTE → CHECKPOINT |
+| "All X must become Y" | Migration | UNDERSTAND → pattern → batch apply → verify |
+| "X's structure must change" | Refactor | UNDERSTAND → DECOMPOSE → EXECUTE → CHECKPOINT |
+| "Why does X happen?" | Investigation | explore → analyze → report |
 
 **Migration shortcut**: When applying the same transformation to 10+ files, don't decompose into individual file tasks. Define the pattern once, apply in batches of 5-10, verify after each batch. Scope guard thresholds are raised automatically when a plan file exists.
 
+### 1-3. Essence Validation (Error Prevention)
+
+| Trap | Response |
+|------|----------|
+| Mistaking symptom for essence | "Is this the cause, or a consequence?" |
+| Mistaking solution for essence | "Add caching" is not the essence. "Eliminate redundant computation" is. |
+| Too abstract | "Can I write even one line of code from this?" |
+| Too specific | "What's the real problem one level up?" |
+
+**Core test**: If the essence statement contains specific technology/tool names → it's still at solution level, not essence. Go one level higher.
+
+### 1-4. Quality Gate: ESSENCE → UNDERSTAND
+
+Before moving to UNDERSTAND, verify:
+- [ ] Essence statement is technology-neutral (holds without naming specific tools/libraries)
+- [ ] Minimal case is truly "minimal" (can it be reduced further?)
+- [ ] Each step in the expansion path works independently
+- [ ] Task type has been clearly derived
+
 ---
 
-## UDEC 1. UNDERSTAND — Understanding Protocol
+## EUDEC 2. UNDERSTAND — Understanding Protocol
 
 ### 2-1. Information Sufficiency Assessment (MANDATORY)
 
@@ -82,7 +123,7 @@ Before moving to DECOMPOSE:
 
 ---
 
-## UDEC 2. DECOMPOSE — Planning Protocol
+## EUDEC 3. DECOMPOSE — Planning Protocol
 
 ### 3-1. Decomposition Trigger
 
@@ -170,7 +211,7 @@ If any gate fails → resolve before executing. Do not start implementation on a
 
 ---
 
-## UDEC 3. EXECUTE — Execution Protocol
+## EUDEC 4. EXECUTE — Execution Protocol
 
 ### 4-1. Batch Execution
 
@@ -236,7 +277,7 @@ Choose verification proportional to the **risk of the change**, not the file pat
 
 - Same file edited 3+ times → "Possible thrashing. Investigate root cause."
 - Editing file not in plan → "Scope change needed?"
-- 3 consecutive test failures → "Approach problem. Back to UNDERSTAND."
+- 3 consecutive test failures → "Approach problem. Back to ESSENCE — did we get the essence wrong?"
 - New package needed → "Confirm with user"
 - 5 turns autonomous → "Report progress before continuing"
 - Adding workarounds to fix workarounds → "Design problem. Step back."
@@ -250,7 +291,7 @@ Choose verification proportional to the **risk of the change**, not the file pat
 **Thrashing Detector** (beyond simple edit counting):
 - Successive edits reverting previous changes (oscillation) → "Reverting own work. Wrong approach."
 - Scope of changes expanding beyond plan → "Scope creep. Return to DECOMPOSE."
-- Error messages changing type across fixes → "Chasing symptoms, not root cause. Back to UNDERSTAND."
+- Error messages changing type across fixes → "Chasing symptoms, not root cause. Back to ESSENCE."
 
 ### 4-5. Scope Guard
 
@@ -286,7 +327,7 @@ When delegating work to sub-agents:
 
 ---
 
-## UDEC 4. CHECKPOINT — Confirmation Protocol
+## EUDEC 5. CHECKPOINT — Confirmation Protocol
 
 ### Quality Gate: EXECUTE → CHECKPOINT
 
@@ -328,7 +369,7 @@ Plan freshness: verified [date] | Remaining targets: [N] confirmed in code
 
 ### 5-2. Direction Change
 
-User says "change direction" → return to UNDERSTAND
+User says "change direction" → return to ESSENCE (re-examine from the core)
 User says "stop here" → clean exit
 
 ---
@@ -415,6 +456,9 @@ If any of these excuses come to mind, **that's a warning signal**. Stop and retu
 | "Other plans won't conflict" | Check `docs/plans/` for overlapping files |
 | "Tests pass, so it must be correct" | Passing tests only prove what you tested. Check edge cases and negative cases |
 | "3 files is too few to decompose" | Depends on coupling. 2 files in a tightly-coupled legacy system may need decomposition |
+| "I already grasped the essence" | If the essence statement contains technology names, it's still at solution level |
+| "No need to simplify, just implement" | Starting without a minimal case drowns you in complexity |
+| "Expansion path can wait" | Without expansion direction, the minimal case becomes a dead end |
 
 ## 8. Completion Declaration Rules
 

package/templates/skills/prism/SKILL.md

@@ -1,19 +1,20 @@
 ---
 name: prism
-description: AI coding problem decomposition tool — UDEC methodology
+description: AI coding problem decomposition tool — EUDEC methodology
 triggers:
   - "prism"
   - "decompose"
   - "udec"
+  - "eudec"
 argument-hint: "[task description]"
 ---
 
 <Purpose>
-Prism applies the UDEC methodology (Understand, Decompose, Execute, Checkpoint) to any coding task. It prevents the biggest AI coding failure mode: building the wrong thing by skipping understanding and decomposition.
+Prism applies the EUDEC methodology (Essence, Understand, Decompose, Execute, Checkpoint) to any coding task. It prevents the biggest AI coding failure mode: building the wrong thing by skipping essence extraction and understanding.
 </Purpose>
 
 <Use_When>
-- User says "prism", "decompose", or "udec"
+- User says "prism", "decompose", "udec", or "eudec"
 - Complex task requiring structured approach (3+ files, unclear scope)
 - Vague request that needs clarification before implementation
 - User wants disciplined, checkpoint-based execution
@@ -31,9 +32,30 @@ AI agents optimize for speed, not correctness. Without structure, they skip unde
 
 <Steps>
 
+## E — ESSENCE
+
+0. **Extract the essence**: Before exploring code, ask: "What is the core problem here — in one sentence, without naming specific tools?"
+   - Output: `본질: [one sentence — no technology/tool names]`
+   - Output: `최소 케이스: [simplest working version]`
+   - Output: `확장 경로: minimal → [step1] → [step2] → [complete]`
+1. **Verify essence quality**:
+   - Does the essence sentence avoid specific technology names? If not → still at solution level, go higher
+   - Is the minimal case truly minimal? Can it be reduced further?
+   - Symptom vs cause: "Is this the cause, or a consequence?"
+   - Solution vs essence: "Caching" is a solution. "Eliminating redundant computation" is the essence.
+2. **Derive task type** from the essence:
+
+   | Essence Character | Type | Path |
+   |-------------------|------|------|
+   | "X is broken" | Bugfix | UNDERSTAND → locate → fix → verify |
+   | "X should be possible" | Feature | UNDERSTAND → DECOMPOSE → EXECUTE → CHECKPOINT |
+   | "All X must become Y" | Migration | UNDERSTAND → pattern → batch apply → verify |
+   | "X's structure must change" | Refactor | UNDERSTAND → DECOMPOSE → EXECUTE → CHECKPOINT |
+   | "Why does X happen?" | Investigation | explore → analyze → report |
+
 ## U — UNDERSTAND
 
-1. **Explore first**: Read package.json, project structure, related files before asking anything
+3. **Explore first**: Read package.json, project structure, related files before asking anything
 2. **Assess information sufficiency**:
    - [Sufficient] Specific file, function, symptom mentioned → skip to DECOMPOSE
    - [Partial] Direction clear but details missing → explore then ask 1-2 questions