claude-prism 0.3.2 → 0.4.1

package/README.ko.md

@@ -32,6 +32,22 @@ AI 코딩 문제 분해 도구 — Understand, Decompose, Execute, Checkpoint (U
 
 AI 코딩의 가장 비싼 실패는 나쁜 코드가 아니라 — **틀린 것을 만드는 것**이다. AI 에이전트는 이해를 건너뛰고, 분해를 건너뛰고, 30분간 자율 실행한 뒤 사용자가 원하지 않은 것을 만들어냄. Prism은 CLAUDE.md에 방법론 규칙을 주입하여 Claude의 사고방식을 바꾼다.
 
+### v0.4.0 주요 변경
+
+- **태스크 크기 태그** — 모든 태스크에 `[S]`, `[M]`, `[L]` 부여, 적응형 배치 구성 (S+S+M = 1배치, L = 단독)
+- **태스크별 검증 전략** — 플랜 템플릿에 `| 검증: TDD`, `| 검증: Build`, `| 검증: Visual` 명시
+- **사전 분해 체크리스트** — 플랜 작성 전 타입/스키마/의존성 확인 필수화
+- **진행률 대시보드** — 각 체크포인트에 Phase/Batch/Task 퍼센트와 시각적 프로그레스 바
+- **적응형 체크포인트** — 3회 연속 승인 시 남은 Phase 동안 배치 크기 5-8로 확대
+- **Scope Guard 디스크 폴백** — 세션 간 `docs/plans/*.md` 존재를 디스크에서 직접 확인 (거짓 "without a plan" 경고 해결)
+- **20개 테스트 러너 패턴** — bun, pnpm, yarn, deno, rspec, dotnet, mvn, gradle 감지 추가
+- **9개 프레임워크별 결과 감지** — node, jest, vitest, pytest, go, cargo, mocha, rspec, dotnet 정확한 성공/실패 판별
+- **통합 hook 파이프라인** — hook 이벤트당 단일 프로세스 (I/O 감소)
+- **i18n 메시지 시스템** — 모든 hook 메시지 en/ko/ja/zh 지역화
+- **세션 이벤트 로깅** — JSONL 기반 세션별 이벤트 기록
+- **정렬 감지** — 범위 이탈 추적 및 주요 결정 플래깅
+- **커스텀 규칙** — 설정을 통한 사용자 정의 hook 규칙
+
 ## 설치
 
 프로젝트 루트에서:
@@ -65,19 +81,23 @@ npx claude-prism update --global   # 글로벌 스킬도 업데이트
 │   │       ├── help.md          # /claude-prism:help
 │   │       └── update.md        # /claude-prism:update
 │   ├── hooks/                # (선택, --no-hooks 시 생략)
-│   │   ├── commit-guard.mjs
-│   │   ├── debug-loop.mjs
-│   │   ├── test-tracker.mjs
-│   │   └── scope-guard.mjs
+│   │   ├── pre-tool.mjs      # 통합 PreToolUse 러너
+│   │   ├── post-tool.mjs     # 통합 PostToolUse 러너
+│   │   └── user-prompt.mjs   # UserPromptSubmit 러너
 │   ├── rules/                # hook 규칙 로직
 │   │   ├── commit-guard.mjs
 │   │   ├── debug-loop.mjs
 │   │   ├── test-tracker.mjs
-│   │   └── scope-guard.mjs
+│   │   ├── scope-guard.mjs
+│   │   ├── alignment.mjs
+│   │   └── turn-reporter.mjs
 │   ├── lib/                  # hook 의존 모듈
 │   │   ├── adapter.mjs
+│   │   ├── pipeline.mjs
 │   │   ├── state.mjs
+│   │   ├── session.mjs
 │   │   ├── config.mjs
+│   │   ├── messages.mjs
 │   │   └── utils.mjs
 │   └── settings.json         # Claude Code hook 등록
 └── docs/plans/               # /claude-prism:prism 실행 시 계획 파일 생성
@@ -235,7 +255,7 @@ prism stats
 
 출력:
 ```
-  Version:   v0.3.1
+  Version:   v0.4.0
   Language:  ko
   Plans:     2 file(s)
   OMC:       ✅ v4.1.1
@@ -311,16 +331,19 @@ Hook은 선택 사항인 CLI 가드로, 개발 중 규율을 강제합니다. `p
 
 테스트 커맨드 실행을 감지하고 타임스탐프와 성공/실패 상태를 기록합니다. `commit-guard`가 최근 테스트 실행을 확인하는 데 사용합니다.
 
-**감지하는 테스트:**
-- `npm test`, `npm run test`
-- `jest`, `vitest`
-- `node --test`
-- `npx mocha`, `mocha`
-- `pytest`
-- `cargo test`
-- `go test`
+**감지하는 테스트 (20개 패턴):**
+- `npm test`, `pnpm test`, `yarn test`, `bun test`
+- `jest`, `vitest`, `mocha`, `rspec`
+- `node --test`, `deno test`
+- `npx jest`, `npx vitest`, `npx mocha`, `bunx vitest`
+- `pytest`, `cargo test`, `go test`
+- `dotnet test`, `mvn test`, `gradle test`
 - `make test`
 
+**프레임워크별 결과 감지 (9개):**
+- Node test runner, Jest, Vitest, Pytest, Go, Cargo, Mocha, RSpec, dotnet
+- stdout와 stderr를 모두 분석하여 정확한 성공/실패 판별
+
 **설정:**
 ```json
 {
@@ -366,6 +389,7 @@ Hook은 선택 사항인 CLI 가드로, 개발 중 규율을 강제합니다. `p
 - **플랜 인식**: 플랜 파일 생성 시 (`docs/plans/*.md`) 임계값이 자동으로 2배
   - 표준 + 플랜: 8개에서 경고, 14개에서 차단
   - Agent + 플랜: 16개에서 경고, 24개에서 차단
+- **세션 간 지속성**: 현재 세션에서 생성된 플랜뿐만 아니라 디스크에 존재하는 기존 플랜 파일(`docs/plans/*.md`)도 감지. 새 세션에서 작업 재개 시 거짓 "without a plan" 경고 해결.
 
 ## 설정
 
@@ -411,7 +435,7 @@ prism doctor      # 진단 정보에 OMC 감지 표시
 ## 기술 사양
 
 - **패키지명**: `claude-prism`
-- **버전**: 0.3.1
+- **버전**: 0.4.0
 - **CLI 커맨드**: `prism`
 - **Node 버전**: >= 18
 - **의존성**: 0 (순수 ESM 모듈)
@@ -430,10 +454,11 @@ prism doctor      # 진단 정보에 OMC 감지 표시
 
 1. **정보 충분성 판별** — 요청이 명확한가? 질문이 필요한가?
 2. **최대 3라운드 질문** — 한 번에 하나씩, 객관식 우선
-3. **분해 5원칙** — 단위 크기, 테스트 선행, 독립 검증, 파일 명시, 의존성 명시
-4. **적응형 배치 + 체크포인트** — 복잡도별 배치 크기 조절 (단순 5-8 / 일반 3-4 / 복잡 1-2), 배치마다 보고
-5. **컨텍스트 인식 검증** — 파일 경로별 검증 전략 (lib→TDD, components→빌드, config→lint)
-6. **자기 교정** — 같은 파일 3회 편집 시 멈추고 재검토
+3. **분해 5원칙 + 사전 체크** — 단위 크기, 테스트 선행, 독립 검증, 파일 명시, 의존성 명시 + 타입/스키마/교차패키지 확인
+4. **크기 태그 + 적응형 배치** — [S/M/L] 태그 기반 배치 구성, 3회 연속 승인 시 배치 확대
+5. **태스크별 검증 전략** — TDD / Build / Visual 명시, 파일 경로별 자동 선택
+6. **진행률 대시보드** — Phase/Batch/Task % 시각화, 체크포인트마다 보고
+7. **자기 교정** — 같은 파일 3회 편집 시 멈추고 재검토
 
 ## 라이선스
 

package/README.md

@@ -21,6 +21,22 @@ 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.
 
+### What's New in v0.4.0
+
+- **Task size tags** — Every task gets `[S]`, `[M]`, or `[L]` with adaptive batch composition (S+S+M = 1 batch, L = solo)
+- **Verification strategy per task** — `| Verify: TDD`, `| Verify: Build`, or `| Verify: Visual` in plan templates
+- **Pre-decomposition checklist** — Mandatory type/schema/dependency check before creating plans
+- **Progress dashboard** — Visual progress bar with phase/batch/task percentages at each checkpoint
+- **Adaptive checkpoints** — After 3 consecutive approvals, batch size expands to 5-8 for the rest of the phase
+- **Scope guard disk fallback** — Detects existing `docs/plans/*.md` on disk, not just in-session writes (fixes false "without a plan" warnings across sessions)
+- **20 test runner patterns** — Added bun, pnpm, yarn, deno, rspec, dotnet, mvn, gradle detection
+- **9 framework-specific result detectors** — Accurate pass/fail for node, jest, vitest, pytest, go, cargo, mocha, rspec, dotnet
+- **Unified hook pipeline** — Single process per hook event instead of separate processes per rule (reduced I/O)
+- **i18n message system** — All hook messages localized in en/ko/ja/zh
+- **Session event logging** — JSONL-based per-session event recording
+- **Alignment detection** — Scope drift tracking and major decision flagging
+- **Custom rules** — User-defined hook rules via config
+
 ## The Problem
 
 Without structure, Claude does this:
@@ -66,11 +82,13 @@ After running `prism init`, your project gains:
 - `/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:
+**Hooks** (optional, unless `--no-hooks` is set) — Six CLI guards that enforce discipline:
 - `commit-guard` — Prevents commits when tests haven't run recently
 - `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)
+- `test-tracker` — Detects test execution (20 patterns, 9 framework-specific result detectors) and records pass/fail
+- `scope-guard` — Warns at 4 unique files modified, blocks at 7 (agent-aware, plan-aware with disk fallback)
+- `alignment` — Detects scope drift (new directories outside base scope) and major decisions (package installs, db migrations, destructive deletes)
+- `turn-reporter` — Tracks turn count, warns at 5 autonomous turns without user input, provides previous turn summary
 
 **Configuration** — `.prism.json` stores language preference and hook settings. Includes OMC (oh-my-claudecode) detection.
 
@@ -91,19 +109,23 @@ your-project/
 │   │       ├── update.md        # /claude-prism:update
 │   │       └── help.md          # /claude-prism:help
 │   ├── hooks/               # (optional, if --no-hooks not set)
-│   │   ├── commit-guard.mjs
-│   │   ├── debug-loop.mjs
-│   │   ├── test-tracker.mjs
-│   │   └── scope-guard.mjs
+│   │   ├── pre-tool.mjs     # Unified PreToolUse runner
+│   │   ├── post-tool.mjs    # Unified PostToolUse runner
+│   │   └── user-prompt.mjs  # UserPromptSubmit runner
 │   ├── rules/               # Hook logic modules
 │   │   ├── commit-guard.mjs
 │   │   ├── debug-loop.mjs
 │   │   ├── test-tracker.mjs
-│   │   └── scope-guard.mjs
+│   │   ├── scope-guard.mjs
+│   │   ├── alignment.mjs
+│   │   └── turn-reporter.mjs
 │   ├── lib/                 # Hook dependencies
 │   │   ├── adapter.mjs
+│   │   ├── pipeline.mjs
 │   │   ├── state.mjs
+│   │   ├── session.mjs
 │   │   ├── config.mjs
+│   │   ├── messages.mjs
 │   │   └── utils.mjs
 │   └── settings.json        # Claude Code hook registration
 └── docs/plans/
@@ -268,16 +290,19 @@ Detects editing patterns on the same file. Distinguishes between **divergent** e
 
 Detects test command execution and records the timestamp and pass/fail state. Used by `commit-guard` to verify tests ran recently.
 
-**Detects:**
-- `npm test`, `npm run test`
-- `jest`, `vitest`
-- `node --test`
-- `npx mocha`, `mocha`
-- `pytest`
-- `cargo test`
-- `go test`
+**Detects (20 patterns):**
+- `npm test`, `pnpm test`, `yarn test`, `bun test`
+- `jest`, `vitest`, `mocha`, `rspec`
+- `node --test`, `deno test`
+- `npx jest`, `npx vitest`, `npx mocha`, `bunx vitest`
+- `pytest`, `cargo test`, `go test`
+- `dotnet test`, `mvn test`, `gradle test`
 - `make test`
 
+**Framework-specific result detection (9 detectors):**
+- Node test runner, Jest, Vitest, Pytest, Go, Cargo, Mocha, RSpec, dotnet
+- Analyzes both stdout and stderr for accurate pass/fail determination
+
 **Configuration:**
 ```json
 {
@@ -323,6 +348,7 @@ Tracks unique source files modified per session. Warns when scope grows without
 - **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
+- **Cross-session persistence**: Detects existing plan files on disk (`docs/plans/*.md`), not just plans created in the current session. Fixes false "without a plan" warnings when resuming work in a new session.
 
 ## Configuration
 
@@ -412,7 +438,7 @@ prism stats
 
 Output:
 ```
-  Version:   v0.3.1
+  Version:   v0.4.0
   Language:  en
   Plans:     2 file(s)
   OMC:       ✅ v4.1.1

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,11 @@
  */
 
 import { readJsonState, writeJsonState } from '../lib/state.mjs';
+import { DEFAULTS, buildSourcePattern, buildTestPattern } from '../lib/config.mjs';
+import { getMessage } from '../lib/messages.mjs';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
 
-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 +19,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') || [];
@@ -43,7 +49,25 @@ export const scopeGuard = {
     let blockAt = isAgent ? (config.agentBlockAt || 12) : (config.blockAt || 7);
 
     // Active plan → double thresholds (planned work is expected to touch many files)
-    const hasPlan = readJsonState(stateDir, 'scope-has-plan');
+    let hasPlan = readJsonState(stateDir, 'scope-has-plan');
+
+    // Fallback: check disk for existing plan files (survives session restart)
+    if (!hasPlan) {
+      try {
+        const root = config.projectRoot || process.cwd();
+        const plansDir = join(root, 'docs', 'plans');
+        if (existsSync(plansDir)) {
+          const planFiles = readdirSync(plansDir).filter(f => f.endsWith('.md'));
+          if (planFiles.length > 0) {
+            hasPlan = true;
+            writeJsonState(stateDir, 'scope-has-plan', true);
+          }
+        }
+      } catch {
+        // Ignore filesystem errors — fail open
+      }
+    }
+
     if (hasPlan) {
       warnAt *= 2;
       blockAt *= 2;
@@ -52,14 +76,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 })
       };
     }