claude-prism 0.3.1 → 0.4.0

package/README.ko.md

@@ -11,13 +11,19 @@ AI 코딩 문제 분해 도구 — Understand, Decompose, Execute, Checkpoint (U
                                      스펙트럼
 ```
 
+[![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)
+
+> `ai-coding` · `problem-decomposition` · `claude-code-hooks` · `claude-code-plugin` · `udec` · `scope-guard`
+
 ## 무엇인가
 
 `claude-prism`은 UDEC 방법론 프레임워크를 Claude Code 프로젝트에 설치합니다.
 
 - **U**nderstand (이해) — 행동하기 전에 정보 충분성을 판별. 구조화된 질문 (한 번에 하나씩, 객관식, 최대 3라운드)
 - **D**ecompose (분해) — 복잡한 문제를 2-5분 크기의 검증 가능한 단위로 분해, TDD 기반
-- **E**xecute (실행) — 배치 실행 (배치당 3-4개 태스크), TDD Iron Law 준수
+- **E**xecute (실행) — 적응형 배치 실행, 파일 경로별 컨텍스트 인식 검증 (TDD / 빌드 / lint-only)
 - **C**heckpoint (확인) — 매 배치 후 보고, 다음 진행 전 사용자 확인
 
 ## 핵심 철학
@@ -37,6 +43,9 @@ npx claude-prism init --lang=ja    # 일본어
 npx claude-prism init --lang=zh    # 중국어
 npx claude-prism init --no-hooks   # 규칙만, hook 없이
 prism check                        # 설치 확인
+npx claude-prism init --global     # 글로벌 스킬로 설치 (모든 프로젝트에서 사용)
+npx claude-prism update            # 규칙과 커맨드를 최신으로 업데이트
+npx claude-prism update --global   # 글로벌 스킬도 업데이트
 ```
 
 ## 설치 후 구조
@@ -53,7 +62,8 @@ prism check                        # 설치 확인
 │   │       ├── plan.md          # /claude-prism:plan
 │   │       ├── doctor.md        # /claude-prism:doctor
 │   │       ├── stats.md         # /claude-prism:stats
-│   │       └── help.md          # /claude-prism:help
+│   │       ├── help.md          # /claude-prism:help
+│   │       └── update.md        # /claude-prism:update
 │   ├── hooks/                # (선택, --no-hooks 시 생략)
 │   │   ├── commit-guard.mjs
 │   │   ├── debug-loop.mjs
@@ -86,6 +96,7 @@ prism check                        # 설치 확인
 | `/claude-prism:doctor` | 설치 문제 | 건강 진단, 수정 제안 |
 | `/claude-prism:stats` | 현재 상태 | 버전, hooks, 언어, 플랜 진행률 |
 | `/claude-prism:help` | 커맨드 확인 | 커맨드 레퍼런스 |
+| `/claude-prism:update` | 업데이트 후 | 규칙과 커맨드를 최신 버전으로 업데이트 |
 
 ### 워크플로우
 
@@ -224,7 +235,7 @@ prism stats
 
 출력:
 ```
-  Version:   v0.1.0
+  Version:   v0.3.1
   Language:  ko
   Plans:     2 file(s)
   OMC:       ✅ v4.1.1
@@ -276,7 +287,7 @@ Hook은 선택 사항인 CLI 가드로, 개발 중 규율을 강제합니다. `p
 
 ### debug-loop
 
-같은 파일을 연속으로 편집할 때 경고 (3회), 차단 (5회). 무한 디버깅 루프 감지.
+같은 파일의 편집 패턴을 분석합니다. **발산 편집** (같은 코드 영역 반복 — 삽질 가능성)과 **수렴 편집** (다른 영역: import, 로직, JSX — 정상적인 점진적 작업)을 구별합니다.
 
 ```json
 {
@@ -291,9 +302,10 @@ Hook은 선택 사항인 CLI 가드로, 개발 중 규율을 강제합니다. `p
 ```
 
 **동작:**
-- 세션 내 같은 파일의 연속 편집 추적
-- 3회 편집: 경고 "문제를 이해하기 위해 한 발 물러나세요"
-- 5회 편집: 차단 후 재평가 강제
+- 스니펫 분석으로 편집 패턴 추적
+- **발산 패턴** (같은 영역): 3회에서 경고, 5회에서 차단
+- **수렴 패턴** (다른 영역): 조용히 통과, 차단도 경고로 다운그레이드
+- 무한 디버깅 루프를 감지하면서 정상적인 다영역 편집은 허용
 
 ### test-tracker
 
@@ -322,7 +334,7 @@ Hook은 선택 사항인 CLI 가드로, 개발 중 규율을 강제합니다. `p
 
 **동작:**
 - 모든 Bash 커맨드에서 실행
-- 커맨드가 테스트 패턴과 일치하면 타임스탐프 기록
+- 커맨드가 테스트 패턴과 일치하면 타임스탬프 기록
 - 결과 기록 (종료 코드 기반 성공/실패)
 - `commit-guard`가 이 상태를 읽어 커밋 허용/차단
 
@@ -351,6 +363,9 @@ Hook은 선택 사항인 CLI 가드로, 개발 중 규율을 강제합니다. `p
 - Agent 임계값 (OMC sub-agent 실행 중): 8개에서 경고, 12개에서 차단
 - 경고: "/claude-prism:prism을 실행하여 작업을 분해하는 것을 고려하세요"
 - 차단: "/claude-prism:prism을 실행하여 계속 진행하기 전에 분해하세요"
+- **플랜 인식**: 플랜 파일 생성 시 (`docs/plans/*.md`) 임계값이 자동으로 2배
+  - 표준 + 플랜: 8개에서 경고, 14개에서 차단
+  - Agent + 플랜: 16개에서 경고, 24개에서 차단
 
 ## 설정
 
@@ -396,7 +411,7 @@ prism doctor      # 진단 정보에 OMC 감지 표시
 ## 기술 사양
 
 - **패키지명**: `claude-prism`
-- **버전**: 0.1.0
+- **버전**: 0.3.1
 - **CLI 커맨드**: `prism`
 - **Node 버전**: >= 18
 - **의존성**: 0 (순수 ESM 모듈)
@@ -416,8 +431,8 @@ prism doctor      # 진단 정보에 OMC 감지 표시
 1. **정보 충분성 판별** — 요청이 명확한가? 질문이 필요한가?
 2. **최대 3라운드 질문** — 한 번에 하나씩, 객관식 우선
 3. **분해 5원칙** — 단위 크기, 테스트 선행, 독립 검증, 파일 명시, 의존성 명시
-4. **배치 + 체크포인트** — 3-4개 태스크씩 실행, 배치마다 보고
-5. **TDD Iron Law** — 실패 테스트 먼저, 테스트 없이 커밋 금지
+4. **적응형 배치 + 체크포인트** — 복잡도별 배치 크기 조절 (단순 5-8 / 일반 3-4 / 복잡 1-2), 배치마다 보고
+5. **컨텍스트 인식 검증** — 파일 경로별 검증 전략 (lib→TDD, components→빌드, config→lint)
 6. **자기 교정** — 같은 파일 3회 편집 시 멈추고 재검토
 
 ## 라이선스

package/README.md

@@ -1,12 +1,18 @@
 ```
-                         ╱╲
-            ━━━━━━━━━▶  ╱  ╲  ──── U  Understand
-            complex    ╱    ╲ ──── D  Decompose
-            problem   ╱ PRISM╲──── E  Execute
-                     ╱________╲─── C  Checkpoint
-                                     spectrum
+                        ╱╲
+           ━━━━━━━━━▶  ╱  ╲  ──── U  Understand
+           complex    ╱    ╲ ──── D  Decompose
+           problem   ╱ PRISM╲──── E  Execute
+                    ╱________╲─── C  Checkpoint
+                                    spectrum
 ```
 
+[![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)
+
+> `ai-coding` · `problem-decomposition` · `claude-code-hooks` · `claude-code-plugin` · `udec` · `scope-guard`
+
 # claude-prism
 
 An AI coding problem decomposition tool for Claude Code. Installs the **UDEC** methodology — Understand, Decompose, Execute, Checkpoint — directly into your project's Claude Code environment.
@@ -15,11 +21,6 @@ An AI coding problem decomposition tool for Claude Code. Installs the **UDEC** m
 
 **Core philosophy:** Never implement what you haven't understood. Never execute what you haven't decomposed.
 
-- Zero dependencies
-- Node >= 18
-- MIT License
-- Repository: https://github.com/lazysaturday91/claude-prism
-
 ## The Problem
 
 Without structure, Claude does this:
@@ -29,7 +30,7 @@ Without structure, Claude does this:
 | Reads request → assumes understanding | Reads request → assesses sufficiency |
 | Starts coding immediately | Asks 1-2 clarifying questions first |
 | Builds one 30-minute mega-feature | Decomposes into 2-5 minute verifiable units |
-| Runs autonomously (no checkpoints) | Batches execution: 3-4 tasks → checkpoint → ask permission |
+| Runs autonomously (no checkpoints) | Adaptive batches (1-8 tasks by complexity) → checkpoint → ask permission |
 | Produces working code that's wrong | Produces code that's correct *and* wanted |
 
 ## Installation
@@ -40,6 +41,9 @@ npx claude-prism init --lang=ko    # Korean
 npx claude-prism init --lang=ja    # Japanese
 npx claude-prism init --lang=zh    # Chinese
 npx claude-prism init --no-hooks   # Rules only, no hooks
+npx claude-prism init --global     # Install as global skill (available in all projects)
+npx claude-prism update            # Update rules and commands to latest
+npx claude-prism update --global   # Update global skill too
 prism check                        # Verify installation
 ```
 
@@ -50,7 +54,7 @@ After running `prism init`, your project gains:
 **UDEC Rules** — Injected into `CLAUDE.md` between `PRISM:START` and `PRISM:END` markers. Explains the four-phase methodology:
 - **U** — Assess information sufficiency before acting. Ask one question at a time, multiple choice, max 3 rounds.
 - **D** — Decompose complex problems into 2-5 minute units with TDD. Create a plan file for 6+ file changes.
-- **E** — Execute in batches (3-4 tasks per batch). Apply TDD Iron Law: failing test → implementation → verify → commit.
+- **E** — Execute in adaptive batches. Apply context-aware verification by file path (TDD / build / lint-only).
 - **C** — Checkpoint after each batch. Report progress, show next batch preview, get confirmation before continuing.
 
 **Slash Commands** — Added to `.claude/commands/claude-prism/`:
@@ -59,11 +63,12 @@ After running `prism init`, your project gains:
 - `/claude-prism:plan` — List, create, or view plan files
 - `/claude-prism:doctor` — Diagnose installation health via Claude
 - `/claude-prism:stats` — Show project statistics, hook status, and plan progress
+- `/claude-prism:update` — Update rules and commands to latest version
 - `/claude-prism:help` — Command reference
 
 **Hooks** (optional, unless `--no-hooks` is set) — Four CLI guards that enforce discipline:
 - `commit-guard` — Prevents commits when tests haven't run recently
-- `debug-loop` — Warns at 3 edits, blocks at 5 edits to same file (catches infinite debugging loops)
+- `debug-loop` — Detects divergent editing patterns on the same file (catches infinite debugging loops)
 - `test-tracker` — Detects test command execution (npm test, jest, vitest, pytest, etc.) and records pass/fail state
 - `scope-guard` — Warns at 4 unique files modified, blocks at 7 (agent-aware: warns at 8, blocks at 12)
 
@@ -83,6 +88,7 @@ your-project/
 │   │       ├── plan.md          # /claude-prism:plan
 │   │       ├── doctor.md        # /claude-prism:doctor
 │   │       ├── stats.md         # /claude-prism:stats
+│   │       ├── update.md        # /claude-prism:update
 │   │       └── help.md          # /claude-prism:help
 │   ├── hooks/               # (optional, if --no-hooks not set)
 │   │   ├── commit-guard.mjs
@@ -116,7 +122,7 @@ your-project/
     [ DECOMPOSE ]   ← Break into 2-5 min units, create plan file
           |
           v
-    [ EXECUTE ]     ← Run batch (3-4 tasks), TDD each unit
+    [ EXECUTE ]     ← Run adaptive batch, verify each unit
           |
           v
     [ CHECKPOINT ]  ← Report, show next batch, ask to continue
@@ -135,6 +141,7 @@ your-project/
 | `/claude-prism:checkpoint` | Mid-project | Check batch progress, preview next batch |
 | `/claude-prism:doctor` | Installation issues | Diagnose health, suggest fixes |
 | `/claude-prism:stats` | Check current state | Version, hooks, language, plan progress |
+| `/claude-prism:update` | After `npm update` | Update rules and commands to latest |
 | `/claude-prism:help` | Forgot commands | Quick reference |
 
 ### Workflow
@@ -237,7 +244,7 @@ Blocks commits if tests haven't been run in the last 5 minutes (configurable via
 
 ### debug-loop
 
-Warns when the same file is edited 3 times in a row, blocks at 5 edits. Catches infinite debugging cycles.
+Detects editing patterns on the same file. Distinguishes between **divergent** edits (same code area repeatedly — likely thrashing) and **convergent** edits (different areas like imports, logic, JSX — normal progressive work).
 
 ```json
 {
@@ -252,9 +259,10 @@ Warns when the same file is edited 3 times in a row, blocks at 5 edits. Catches
 ```
 
 **Behavior:**
-- Tracks consecutive edits to same file within a session
-- Warns at 3 edits: "Consider stepping back to understand the problem"
-- Blocks at 5 edits: Forces reassessment before continuing
+- Tracks edit patterns using snippet analysis
+- **Divergent pattern** (same area): warns at 3 edits, blocks at 5
+- **Convergent pattern** (different areas): passes silently, downgrades block to warn
+- Catches infinite debugging loops while allowing normal multi-area edits
 
 ### test-tracker
 
@@ -312,6 +320,9 @@ Tracks unique source files modified per session. Warns when scope grows without
 - Agent thresholds (when OMC sub-agents running): warns at 8, blocks at 12
 - Warning: "Consider running /claude-prism:prism to decompose the task"
 - Block: "Run /claude-prism:prism to decompose before continuing"
+- **Plan-aware**: When a plan file is created (`docs/plans/*.md`), thresholds are automatically doubled
+  - Standard with plan: warns at 8, blocks at 14
+  - Agent with plan: warns at 16, blocks at 24
 
 ## Configuration
 
@@ -401,7 +412,7 @@ prism stats
 
 Output:
 ```
-  Version:   v0.1.0
+  Version:   v0.3.1
   Language:  en
   Plans:     2 file(s)
   OMC:       ✅ v4.1.1
@@ -469,16 +480,21 @@ prism doctor      # Shows OMC detection in diagnostics
 
 This allows OMC agents (executor, architect, etc.) to modify more files per task without triggering scope warnings, recognizing that coordinated multi-agent work has different constraints than single-agent development.
 
-## TDD Iron Law
+## Verification Strategy
 
-Every task in the EXECUTE phase follows:
+Prism uses context-aware verification — the right level of rigor for each file type:
 
-1. Write a failing test
-2. Write minimum code to pass
-3. Verify the test passes
-4. Commit
+| Path Pattern | Strategy | Escalation |
+|---|---|---|
+| `lib/`, `utils/`, `store/`, `hooks/`, `services/` | **TDD required** — failing test → implement → verify | Always TDD |
+| `components/`, `pages/`, `views/` | **Build verification** — build passes + visual check | Escalate to TDD if complex logic |
+| `config/`, `styles/`, `types/`, `*.json` | **Build/lint only** | Never |
 
-Never execute without this cycle.
+**Core rules (all paths):**
+1. Never claim completion without fresh verification evidence
+2. Never commit code that doesn't build
+3. TDD paths: write failing test → minimal code → verify
+4. Build paths: run build/lint → confirm no regressions
 
 ## Design Philosophy
 
@@ -487,7 +503,7 @@ Prism is built on the insight that **AI needs structure more than humans do.** H
 - Explicit understanding phase (no assumptions)
 - Enforced decomposition (no mega-tasks)
 - Batched execution with checkpoints (human in the loop)
-- TDD for every unit (verified, not assumed)
+- Context-aware verification (TDD, build, or lint — matched to file type)
 
 The prism metaphor: white light (complex problem) enters from one side and decomposes into a spectrum of colors (manageable units). Each color (unit) is individually verified, then recombined into a working whole.
 

package/bin/cli.mjs

@@ -35,6 +35,7 @@ if (hasFlag('version') || hasFlag('v')) {
 
 const cwd = process.cwd();
 
+try {
 switch (command) {
   case 'init': {
     if (hasFlag('global')) {
@@ -49,6 +50,19 @@ switch (command) {
     const language = getFlag('lang') || 'en';
     const hooks = !hasFlag('no-hooks');
 
+    if (hasFlag('dry-run')) {
+      const { dryRun } = await import('../lib/installer.mjs');
+      const result = dryRun(cwd, { language, hooks });
+      console.log('🌈 claude-prism init --dry-run\n');
+      console.log('  Files that would be created/updated:\n');
+      for (const action of result.actions) {
+        const icon = action.status === 'create' ? '🆕' : '🔄';
+        console.log(`  ${icon} [${action.status}] ${action.path}`);
+      }
+      console.log(`\n  Total: ${result.actions.length} files`);
+      break;
+    }
+
     console.log('🌈 claude-prism init\n');
     await init(cwd, { language, hooks });
 
@@ -182,8 +196,23 @@ Usage:
 Options:
   --lang=XX    Language: en (default), ko, ja, zh
   --no-hooks   Skip enforcement hooks
+  --dry-run    Show what init would do without making changes
   --global     Install/uninstall globally (all projects)
   --ci         Output JSON for CI integration
   --version    Show version`);
   }
 }
+} catch (err) {
+  const msg = err.message || String(err);
+  process.stderr.write(`🌈 Prism Error: ${msg}\n`);
+
+  if (/EACCES|permission/i.test(msg)) {
+    process.stderr.write('💡 Check directory permissions\n');
+  } else if (/JSON|parse/i.test(msg)) {
+    process.stderr.write('💡 Config file may be corrupted. Try `prism reset` or delete .claude-prism.json\n');
+  } else if (/ENOENT.*package\.json/i.test(msg)) {
+    process.stderr.write('💡 Not in a project directory?\n');
+  }
+
+  process.exit(1);
+}

package/hooks/alignment.mjs

@@ -0,0 +1,94 @@
+/**
+ * claude-prism — Alignment Detection
+ * Detects scope drift and major unconfirmed decisions
+ */
+
+import { readJsonState, writeJsonState } from '../lib/state.mjs';
+import { getMessage } from '../lib/messages.mjs';
+
+// Major decision patterns — commands that represent significant choices
+const MAJOR_DECISION_PATTERNS = [
+  { pattern: /\bnpm\s+install\b|\bpnpm\s+add\b|\byarn\s+add\b|\bbun\s+add\b/, label: 'package-install' },
+  { pattern: /\bprisma\s+migrate\b|\bsequelize\b|\bknex\s+migrate\b/, label: 'db-migration' },
+  { pattern: /\brm\s+-rf?\b|\brmdir\b/, label: 'destructive-delete' },
+];
+
+// Config files that represent major changes when modified
+const MAJOR_CONFIG_FILES = [
+  'tsconfig.json', 'package.json', '.env', 'docker-compose.yml',
+  'Dockerfile', '.github/workflows', 'webpack.config', 'vite.config',
+  'next.config', 'tailwind.config',
+];
+
+export const alignment = {
+  name: 'alignment',
+
+  evaluate(ctx, config, stateDir) {
+    if (!config.enabled) return { type: 'pass' };
+
+    const messages = [];
+
+    // 1. Directory scope tracking
+    if (ctx.filePath) {
+      const dir = ctx.filePath.split('/').slice(0, -1).join('/') || '.';
+      let scopeDirs = readJsonState(stateDir, 'scope-directories') || [];
+
+      if (!scopeDirs.includes(dir)) {
+        // First 3 unique directories establish the "base scope"
+        if (scopeDirs.length < 3) {
+          scopeDirs.push(dir);
+          writeJsonState(stateDir, 'scope-directories', scopeDirs);
+        } else {
+          // New directory outside base scope — potential drift
+          const driftCount = parseInt(
+            (readJsonState(stateDir, 'drift-count') || 0).toString(), 10
+          ) || 0;
+          const newDriftCount = driftCount + 1;
+          writeJsonState(stateDir, 'drift-count', newDriftCount);
+
+          if (newDriftCount >= (config.driftThreshold || 2)) {
+            return {
+              type: 'warn',
+              message: `🌈 Prism 🧭 Scope drift: editing ${dir} (outside base scope: ${scopeDirs.slice(0, 3).join(', ')}). Verify this is intended.`
+            };
+          }
+        }
+      }
+
+      // 2. Major config file detection
+      const fileName = ctx.filePath.split('/').pop();
+      const isMajorConfig = MAJOR_CONFIG_FILES.some(f =>
+        ctx.filePath.includes(f) || fileName === f
+      );
+      if (isMajorConfig) {
+        messages.push(`🌈 Prism 🔧 Config change: ${fileName}. Ensure this was discussed with user.`);
+      }
+    }
+
+    // 3. Major command detection
+    if (ctx.command) {
+      for (const { pattern, label } of MAJOR_DECISION_PATTERNS) {
+        if (pattern.test(ctx.command)) {
+          if (label === 'destructive-delete') {
+            return {
+              type: 'warn',
+              message: `🌈 Prism ⚠️ Destructive command detected: ${ctx.command.slice(0, 60)}. Confirm with user before proceeding.`
+            };
+          }
+          if (label === 'package-install') {
+            messages.push(`🌈 Prism 📦 New dependency being installed. Verify this was agreed upon.`);
+          }
+          if (label === 'db-migration') {
+            messages.push(`🌈 Prism 🗄️ Database migration detected. This is a major decision — confirm with user.`);
+          }
+        }
+      }
+    }
+
+    if (messages.length > 0) {
+      return { type: 'pass', message: messages.join('\n') };
+    }
+
+    return { type: 'pass' };
+  }
+};

package/hooks/commit-guard.mjs

@@ -4,12 +4,14 @@
  */
 
 import { readState } from '../lib/state.mjs';
+import { getMessage } from '../lib/messages.mjs';
 
 export const commitGuard = {
   name: 'commit-guard',
 
   evaluate(ctx, config, stateDir) {
     const command = ctx.command || '';
+    const lang = config.language || 'en';
 
     if (!command.includes('git commit')) return { type: 'pass' };
     if (command.includes('--allow-empty')) return { type: 'pass' };
@@ -19,7 +21,7 @@ export const commitGuard = {
     if (testResult !== null && testResult.trim() === 'fail') {
       return {
         type: 'block',
-        message: '🌈 Prism ✋ Commit blocked: last test run FAILED. Fix tests before committing.'
+        message: getMessage(lang, 'commit-guard.block.failed')
       };
     }
 
@@ -28,7 +30,7 @@ export const commitGuard = {
     if (lastTestRaw === null) {
       return {
         type: 'warn',
-        message: '🌈 Prism > No test run detected this session. Run tests before committing.'
+        message: getMessage(lang, 'commit-guard.warn.no-test')
       };
     }
 
@@ -39,7 +41,7 @@ export const commitGuard = {
     if (diff > (config.maxTestAge || 300)) {
       return {
         type: 'warn',
-        message: `🌈 Prism > Last test run was ${Math.floor(diff / 60)}min ago. Run tests before committing.`
+        message: getMessage(lang, 'commit-guard.warn.stale', { minutes: Math.floor(diff / 60) })
       };
     }
 

package/hooks/debug-loop.mjs

@@ -5,6 +5,8 @@
 
 import { createHash } from 'crypto';
 import { readState, writeState, readJsonState, writeJsonState } from '../lib/state.mjs';
+import { DEFAULTS, buildSourcePattern } from '../lib/config.mjs';
+import { getMessage } from '../lib/messages.mjs';
 
 export const debugLoop = {
   name: 'debug-loop',
@@ -14,7 +16,8 @@ export const debugLoop = {
     if (!filePath) return { type: 'pass' };
 
     // Skip non-source files
-    if (!/\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h)$/.test(filePath)) return { type: 'pass' };
+    const sourcePattern = buildSourcePattern(config.sourceExtensions || DEFAULTS.sourceExtensions);
+    if (!sourcePattern.test(filePath)) return { type: 'pass' };
 
     const hash = createHash('md5').update(filePath).digest('hex').slice(0, 8);
     const countKey = `edit-count-${hash}`;
@@ -34,6 +37,7 @@ export const debugLoop = {
     writeJsonState(stateDir, logKey, editLog);
 
     const name = filePath.split('/').pop();
+    const lang = config.language || 'en';
     const pattern = count >= config.warnAt ? analyzePattern(editLog) : null;
 
     if (count >= config.blockAt) {
@@ -41,12 +45,12 @@ export const debugLoop = {
       if (pattern === 'divergent') {
         return {
           type: 'block',
-          message: `🌈 Prism ✋ Debug Loop blocked: ${name} edited ${count} times on same area. Discuss approach with user before continuing.`
+          message: getMessage(lang, 'debug-loop.block.divergent', { name, count })
         };
       }
       return {
         type: 'warn',
-        message: `🌈 Prism > Debug Loop: ${name} edited ${count} times (different areas). Consider if this is expected.`
+        message: getMessage(lang, 'debug-loop.warn.convergent', { name, count })
       };
     }
 
@@ -55,7 +59,7 @@ export const debugLoop = {
       if (pattern === 'divergent') {
         return {
           type: 'warn',
-          message: `🌈 Prism > Debug Loop: ${name} edited ${count} times on same area. Stop and investigate root cause.`
+          message: getMessage(lang, 'debug-loop.warn.divergent', { name, count })
         };
       }
       // Convergent edits (different areas) = normal progressive work → pass
@@ -68,8 +72,19 @@ export const debugLoop = {
 function analyzePattern(log) {
   if (log.length < 3) return null;
   const recent = log.slice(-3).map(e => e.snippet);
+
+  // Filter out empty/whitespace snippets — can't determine pattern
+  if (recent.some(s => !s || !s.trim())) return null;
+
+  // Exact duplicates = clearly divergent (same code edited repeatedly)
   const uniqueSnippets = new Set(recent).size;
   if (uniqueSnippets === 1) return 'divergent';
-  const overlap = recent.filter(s => recent[0] && s.includes(recent[0].slice(0, 20))).length;
+
+  // Check for meaningful overlap using longer window
+  const baseSnippet = recent[0].slice(0, 40);
+  // Skip overlap check if base is too short for meaningful comparison
+  if (baseSnippet.length < 10) return uniqueSnippets <= 2 ? 'divergent' : 'convergent';
+
+  const overlap = recent.filter(s => s.includes(baseSnippet)).length;
   return overlap >= 2 ? 'divergent' : 'convergent';
 }

package/hooks/scope-guard.mjs

@@ -4,9 +4,9 @@
  */
 
 import { readJsonState, writeJsonState } from '../lib/state.mjs';
+import { DEFAULTS, buildSourcePattern, buildTestPattern } from '../lib/config.mjs';
+import { getMessage } from '../lib/messages.mjs';
 
-const SOURCE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h|svelte|vue)$/;
-const TEST_PATTERN = /\.(test|spec|_test)\./;
 const PLAN_PATTERN = /(?:^|\/)docs\/plans\/.*\.md$|(?:^|\/).*plan.*\.md$/i;
 
 export const scopeGuard = {
@@ -17,16 +17,20 @@ export const scopeGuard = {
     if (!filePath) return { type: 'pass' };
 
     // Plan file created → mark plan as active (thresholds will be doubled)
+    const lang = config.language || 'en';
     if (PLAN_PATTERN.test(filePath)) {
       writeJsonState(stateDir, 'scope-has-plan', true);
-      return { type: 'pass', message: '🌈 Prism 📋 Plan file detected. Scope thresholds raised.' };
+      return { type: 'pass', message: getMessage(lang, 'scope-guard.plan-detected') };
     }
 
     // Only track source files
-    if (!SOURCE_PATTERN.test(filePath)) return { type: 'pass' };
+    const sourcePattern = buildSourcePattern(config.sourceExtensions || DEFAULTS.sourceExtensions);
+    const testPattern = buildTestPattern(config.testPatterns || DEFAULTS.testPatterns);
+
+    if (!sourcePattern.test(filePath)) return { type: 'pass' };
 
     // Don't count test files toward scope
-    if (TEST_PATTERN.test(filePath)) return { type: 'pass' };
+    if (testPattern.test(filePath)) return { type: 'pass' };
 
     // Track unique files
     let files = readJsonState(stateDir, 'scope-files') || [];
@@ -52,14 +56,14 @@ export const scopeGuard = {
     if (count >= blockAt) {
       return {
         type: 'block',
-        message: `🌈 Prism ✋ Scope Guard: ${count} unique files modified without a plan. Run /prism to decompose before continuing.`
+        message: getMessage(lang, 'scope-guard.block', { count })
       };
     }
 
     if (count >= warnAt) {
       return {
         type: 'warn',
-        message: `🌈 Prism > Scope Guard: ${count} unique files modified. Consider running /prism to decompose the task.`
+        message: getMessage(lang, 'scope-guard.warn', { count })
       };
     }