claude-prism 0.3.2 → 0.4.0

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 })
       };
     }
 

package/hooks/test-tracker.mjs

@@ -4,6 +4,7 @@
  */
 
 import { writeState } from '../lib/state.mjs';
+import { getMessage } from '../lib/messages.mjs';
 
 const TEST_PATTERNS = [
   /\bnpm\s+test\b/,
@@ -16,6 +17,64 @@ const TEST_PATTERNS = [
   /\bgo\s+test\b/,
   /\bmake\s+test\b/,
   /\bnpx\s+(jest|vitest|mocha)\b/,
+  /\bbun\s+test\b/,
+  /\bpnpm\s+test\b/,
+  /\byarn\s+test\b/,
+  /\bdeno\s+test\b/,
+  /\bpnpm\s+exec\s+jest\b/,
+  /\bbunx\s+vitest\b/,
+  /\brspec\b/,
+  /\bdotnet\s+test\b/,
+  /\bmvn\s+test\b/,
+  /\bgradle\s+test\b/,
+];
+
+const RESULT_DETECTORS = [
+  {
+    name: 'node-test-runner',
+    detect: (output) => /# (?:pass|fail) \d+/.test(output),
+    isFail: (output) => /# fail [1-9]/.test(output),
+  },
+  {
+    name: 'jest',
+    detect: (output) => /Tests:.*\d+/.test(output),
+    isFail: (output) => /\d+ failed/.test(output),
+  },
+  {
+    name: 'vitest',
+    detect: (output) => /Tests\s+\d+ (?:passed|failed)/.test(output),
+    isFail: (output) => /Tests\s+\d+ failed/.test(output),
+  },
+  {
+    name: 'pytest',
+    detect: (output) => /={3,}.*={3,}/.test(output) || /\d+ passed/.test(output),
+    isFail: (output) => /\d+ failed/.test(output) || /\d+ error/.test(output),
+  },
+  {
+    name: 'go',
+    detect: (output) => /^(?:PASS|FAIL)$|--- (?:PASS|FAIL)/m.test(output),
+    isFail: (output) => /^FAIL$/m.test(output) || /--- FAIL:/m.test(output),
+  },
+  {
+    name: 'cargo',
+    detect: (output) => /test result:/.test(output),
+    isFail: (output) => /test result: FAILED/.test(output),
+  },
+  {
+    name: 'mocha',
+    detect: (output) => /\d+ passing/.test(output),
+    isFail: (output) => /\d+ failing/.test(output),
+  },
+  {
+    name: 'rspec',
+    detect: (output) => /\d+ examples?/.test(output),
+    isFail: (output) => /[1-9] failures?/.test(output),
+  },
+  {
+    name: 'dotnet',
+    detect: (output) => /Test Run (?:Successful|Failed)/.test(output),
+    isFail: (output) => /Test Run Failed/.test(output),
+  },
 ];
 
 export const testTracker = {
@@ -27,32 +86,28 @@ export const testTracker = {
     const isTestCommand = TEST_PATTERNS.some(p => p.test(command));
     if (!isTestCommand) return { type: 'pass' };
 
-    // Record timestamp
     const now = Math.floor(Date.now() / 1000);
     writeState(stateDir, 'last-test-run', String(now));
 
-    // Record result — Claude Code does not provide exitCode,
-    // so we infer pass/fail from stdout and interrupted flag
     let passed;
     if (ctx.interrupted) {
       passed = false;
     } else {
-      const stdout = ctx.stdout || '';
-      const failMatch = stdout.match(/# fail (\d+)/);
-      if (failMatch) {
-        passed = parseInt(failMatch[1], 10) === 0;
-      } else if (/(?:FAIL|FAILED|ERROR)\b/i.test(stdout) && !/# pass \d+/.test(stdout)) {
-        passed = false;
+      const output = (ctx.stdout || '') + '\n' + (ctx.stderr || '');
+      const matched = RESULT_DETECTORS.find(d => d.detect(output));
+      if (matched) {
+        passed = !matched.isFail(output);
       } else {
         passed = true;
       }
     }
+
     writeState(stateDir, 'last-test-result', passed ? 'pass' : 'fail');
 
     if (!passed) {
       return {
         type: 'warn',
-        message: '🌈 Prism 📊 Tests FAILED. Fix before committing.'
+        message: getMessage(config.language || 'en', 'test-tracker.warn.failed')
       };
     }
 

package/hooks/turn-reporter.mjs

@@ -0,0 +1,70 @@
+/**
+ * claude-prism — Turn Reporter
+ * UserPromptSubmit hook: tracks turns, injects previous turn summary
+ */
+
+import { readState, writeState, readJsonState, writeJsonState } from '../lib/state.mjs';
+import { getMessage } from '../lib/messages.mjs';
+
+export const turnReporter = {
+  name: 'turn-reporter',
+
+  evaluate(ctx, config, stateDir) {
+    // Increment turn counter
+    const prevTurn = parseInt(readState(stateDir, 'turn-count') || '0', 10) || 0;
+    const turnNumber = prevTurn + 1;
+    writeState(stateDir, 'turn-count', String(turnNumber));
+
+    // Read previous turn actions (recorded by post-tool pipeline)
+    const prevActions = readJsonState(stateDir, 'turn-actions') || [];
+    // Reset actions for new turn
+    writeJsonState(stateDir, 'turn-actions', []);
+
+    // Check autonomous run length
+    const autoTurns = parseInt(readState(stateDir, 'auto-turns') || '0', 10) || 0;
+    if (ctx.userPrompt) {
+      // User input detected — reset auto counter
+      writeState(stateDir, 'auto-turns', '0');
+    } else {
+      // Autonomous turn
+      const newAutoTurns = autoTurns + 1;
+      writeState(stateDir, 'auto-turns', String(newAutoTurns));
+
+      if (newAutoTurns >= (config.silentTurnsWarning || 5)) {
+        const scopeFiles = readJsonState(stateDir, 'scope-files') || [];
+        return {
+          type: 'warn',
+          message: `🌈 Prism ⏰ ${newAutoTurns} turns without user input. Files changed: ${scopeFiles.length}. Report progress before continuing.`
+        };
+      }
+    }
+
+    // Build previous turn summary if there were actions
+    if (prevActions.length === 0) return { type: 'pass' };
+
+    const fileActions = prevActions.filter(a => a.type === 'file-edit' || a.type === 'file-create');
+    const testActions = prevActions.filter(a => a.type === 'test-run');
+    const blockActions = prevActions.filter(a => a.type === 'block');
+
+    const parts = [`🌈 Prism Turn #${turnNumber - 1}:`];
+    if (fileActions.length > 0) {
+      const names = [...new Set(fileActions.map(a => a.file))].slice(0, 5);
+      parts.push(`Files: ${names.join(', ')}${fileActions.length > 5 ? ` +${fileActions.length - 5} more` : ''}`);
+    }
+    if (testActions.length > 0) {
+      const passed = testActions.filter(a => a.passed).length;
+      const failed = testActions.length - passed;
+      parts.push(`Tests: ${passed} passed${failed > 0 ? `, ${failed} failed` : ''}`);
+    }
+    if (blockActions.length > 0) {
+      parts.push(`Blocks: ${blockActions.length}`);
+    }
+
+    if (parts.length <= 1) return { type: 'pass' };
+
+    return {
+      type: 'pass',
+      message: parts.join(' | ')
+    };
+  }
+};

package/lib/adapter.mjs

@@ -19,6 +19,7 @@ const TOOL_ACTION_MAP = {
 const EVENT_PHASE_MAP = {
   'PreToolUse': 'pre',
   'PostToolUse': 'post',
+  'UserPromptSubmit': 'prompt',
 };
 
 export function parseInput() {

package/lib/config.mjs

@@ -8,11 +8,15 @@ import { join } from 'path';
 
 const DEFAULTS = {
   language: 'en',
+  sourceExtensions: ['ts', 'tsx', 'js', 'jsx', 'py', 'go', 'rs', 'java', 'c', 'cpp', 'h', 'svelte', 'vue', 'rb', 'kt', 'swift', 'php', 'cs', 'scala', 'ex', 'clj', 'zig', 'lua', 'dart'],
+  testPatterns: ['test', 'spec', '_test'],
+  customRules: [],
   hooks: {
     'commit-guard': { enabled: true, maxTestAge: 300 },
     'debug-loop': { enabled: true, warnAt: 3, blockAt: 5 },
     'test-tracker': { enabled: true },
-    'scope-guard': { enabled: true, warnAt: 4, blockAt: 7, agentWarnAt: 8, agentBlockAt: 12 }
+    'scope-guard': { enabled: true, warnAt: 4, blockAt: 7, agentWarnAt: 8, agentBlockAt: 12 },
+    'alignment': { enabled: true, driftThreshold: 2 }
   }
 };
 
@@ -33,7 +37,12 @@ export function loadConfig(projectRoot) {
 
 export function getHookConfig(hookName, projectRoot) {
   const config = loadConfig(projectRoot);
-  return config.hooks?.[hookName] || DEFAULTS.hooks[hookName] || { enabled: true };
+  const hookConfig = config.hooks?.[hookName] || DEFAULTS.hooks[hookName] || { enabled: true };
+  // Include top-level fields needed by hooks
+  hookConfig.language = config.language || DEFAULTS.language;
+  hookConfig.sourceExtensions = config.sourceExtensions || DEFAULTS.sourceExtensions;
+  hookConfig.testPatterns = config.testPatterns || DEFAULTS.testPatterns;
+  return hookConfig;
 }
 
 const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -51,4 +60,14 @@ function deepMerge(target, source) {
   return result;
 }
 
+export function buildSourcePattern(extensions) {
+  const escaped = extensions.map(e => e.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  return new RegExp(`\\.(${escaped.join('|')})$`);
+}
+
+export function buildTestPattern(patterns) {
+  const escaped = patterns.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  return new RegExp(`\\.(${escaped.join('|')})\\.`);
+}
+
 export { DEFAULTS };

package/lib/installer.mjs

@@ -49,6 +49,11 @@ export async function init(projectDir, options = {}) {
     copyFileSync(join(runnersDir, 'test-tracker.mjs'), join(hooksDir, 'test-tracker.mjs'));
     copyFileSync(join(runnersDir, 'scope-guard.mjs'), join(hooksDir, 'scope-guard.mjs'));
 
+    // Copy unified pipeline runners
+    copyFileSync(join(runnersDir, 'post-tool.mjs'), join(hooksDir, 'post-tool.mjs'));
+    copyFileSync(join(runnersDir, 'pre-tool.mjs'), join(hooksDir, 'pre-tool.mjs'));
+    copyFileSync(join(runnersDir, 'user-prompt.mjs'), join(hooksDir, 'user-prompt.mjs'));
+
     // Copy rule logic files
     const rulesDestDir = join(claudeDir, 'rules');
     mkdirSync(rulesDestDir, { recursive: true });
@@ -57,12 +62,14 @@ export async function init(projectDir, options = {}) {
     copyFileSync(join(hooksSourceDir, 'debug-loop.mjs'), join(rulesDestDir, 'debug-loop.mjs'));
     copyFileSync(join(hooksSourceDir, 'test-tracker.mjs'), join(rulesDestDir, 'test-tracker.mjs'));
     copyFileSync(join(hooksSourceDir, 'scope-guard.mjs'), join(rulesDestDir, 'scope-guard.mjs'));
+    copyFileSync(join(hooksSourceDir, 'turn-reporter.mjs'), join(rulesDestDir, 'turn-reporter.mjs'));
+    copyFileSync(join(hooksSourceDir, 'alignment.mjs'), join(rulesDestDir, 'alignment.mjs'));
 
     // Copy lib dependencies (adapter + state + config + utils)
     const libDestDir = join(claudeDir, 'lib');
     mkdirSync(libDestDir, { recursive: true });
     const libSourceDir = join(__dirname);
-    for (const file of ['adapter.mjs', 'state.mjs', 'config.mjs', 'utils.mjs']) {
+    for (const file of ['adapter.mjs', 'state.mjs', 'config.mjs', 'utils.mjs', 'pipeline.mjs']) {
       copyFileSync(join(libSourceDir, file), join(libDestDir, file));
     }
 
@@ -82,10 +89,16 @@ export async function init(projectDir, options = {}) {
         'commit-guard': { enabled: true, maxTestAge: 300 },
         'debug-loop': { enabled: true, warnAt: 3, blockAt: 5 },
         'test-tracker': { enabled: true },
-        'scope-guard': { enabled: true, warnAt: 4, blockAt: 7, agentWarnAt: 8, agentBlockAt: 12 }
+        'scope-guard': { enabled: true, warnAt: 4, blockAt: 7, agentWarnAt: 8, agentBlockAt: 12 },
+        'alignment': { enabled: true, driftThreshold: 2 }
       }
     }, null, 2) + '\n');
   }
+
+  // Write version file for doctor to detect mismatches
+  const pkgPath = join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  writeFileSync(join(claudeDir, '.prism-version'), pkg.version);
 }
 
 /**
@@ -153,7 +166,7 @@ export function uninstall(projectDir) {
   }
 
   // 3. Remove prism hooks
-  for (const hook of ['commit-guard.mjs', 'debug-loop.mjs', 'test-tracker.mjs', 'scope-guard.mjs']) {
+  for (const hook of ['commit-guard.mjs', 'debug-loop.mjs', 'test-tracker.mjs', 'scope-guard.mjs', 'user-prompt.mjs']) {
     const p = join(claudeDir, 'hooks', hook);
     if (existsSync(p)) rmSync(p);
   }
@@ -171,7 +184,7 @@ export function uninstall(projectDir) {
     if (settings.hooks) {
       for (const [event, hookList] of Object.entries(settings.hooks)) {
         settings.hooks[event] = hookList.filter(
-          h => !h.hooks?.some(hh => hh.command?.includes('commit-guard') || hh.command?.includes('debug-loop') || hh.command?.includes('test-tracker') || hh.command?.includes('scope-guard'))
+          h => !h.hooks?.some(hh => hh.command?.includes('commit-guard') || hh.command?.includes('debug-loop') || hh.command?.includes('test-tracker') || hh.command?.includes('scope-guard') || hh.command?.includes('user-prompt'))
         );
         if (settings.hooks[event].length === 0) delete settings.hooks[event];
       }
@@ -184,6 +197,10 @@ export function uninstall(projectDir) {
   if (existsSync(configPath)) rmSync(configPath);
   const legacyConfigPath = join(projectDir, '.prism.json');
   if (existsSync(legacyConfigPath)) rmSync(legacyConfigPath);
+
+  // Remove version file
+  const versionFile = join(claudeDir, '.prism-version');
+  if (existsSync(versionFile)) rmSync(versionFile);
 }
 
 /**
@@ -265,6 +282,14 @@ export function doctor(projectDir, options = {}) {
     }
   }
 
+  // Check optional hooks (warn only, don't affect ok)
+  for (const hook of ['user-prompt.mjs']) {
+    if (!existsSync(join(claudeDir, 'hooks', hook))) {
+      issues.push(`Missing optional hook: ${hook} (turn reporter)`);
+      fixes.push('Run `prism update` to restore missing files');
+    }
+  }
+
   // Check CLAUDE.md
   const claudeMdPath = join(projectDir, 'CLAUDE.md');
   if (!existsSync(claudeMdPath)) {
@@ -300,6 +325,18 @@ export function doctor(projectDir, options = {}) {
     fixes.push('Run `prism update` to restore');
   }
 
+  // Check version mismatch
+  const versionFile = join(claudeDir, '.prism-version');
+  if (existsSync(versionFile)) {
+    const installedVersion = readFileSync(versionFile, 'utf8').trim();
+    const pkgPath = join(__dirname, '..', 'package.json');
+    const currentVersion = JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+    if (installedVersion !== currentVersion) {
+      issues.push(`Version mismatch: installed v${installedVersion}, CLI v${currentVersion}`);
+      fixes.push('Run `prism update` to sync installed files with current CLI version');
+    }
+  }
+
   // Deduplicate fixes
   const uniqueFixes = [...new Set(fixes)];
 
@@ -419,20 +456,93 @@ export function uninstallGlobal(options = {}) {
   if (existsSync(skillDir)) rmSync(skillDir, { recursive: true });
 }
 
+/**
+ * Dry-run: show what init would do without making changes
+ * @param {string} projectDir
+ * @param {Object} options
+ * @returns {{ actions: Array<{type: string, path: string, status: string}> }}
+ */
+export function dryRun(projectDir, options = {}) {
+  const { language = 'en', hooks = true } = options;
+  const claudeDir = join(projectDir, '.claude');
+  const actions = [];
+
+  // Commands
+  const nsCommandsDir = join(claudeDir, 'commands', 'claude-prism');
+  const commandFiles = ['prism.md', 'checkpoint.md', 'plan.md', 'doctor.md', 'stats.md', 'help.md', 'update.md'];
+  for (const cmd of commandFiles) {
+    const target = join(nsCommandsDir, cmd);
+    actions.push({
+      type: 'command',
+      path: `.claude/commands/claude-prism/${cmd}`,
+      status: existsSync(target) ? 'update' : 'create'
+    });
+  }
+
+  // Hooks
+  if (hooks) {
+    const hookFiles = ['commit-guard.mjs', 'debug-loop.mjs', 'test-tracker.mjs', 'scope-guard.mjs', 'pre-tool.mjs', 'post-tool.mjs', 'user-prompt.mjs'];
+    for (const hook of hookFiles) {
+      const target = join(claudeDir, 'hooks', hook);
+      actions.push({
+        type: 'hook',
+        path: `.claude/hooks/${hook}`,
+        status: existsSync(target) ? 'update' : 'create'
+      });
+    }
+
+    const ruleFiles = ['commit-guard.mjs', 'debug-loop.mjs', 'test-tracker.mjs', 'scope-guard.mjs', 'turn-reporter.mjs'];
+    for (const rule of ruleFiles) {
+      const target = join(claudeDir, 'rules', rule);
+      actions.push({
+        type: 'rule',
+        path: `.claude/rules/${rule}`,
+        status: existsSync(target) ? 'update' : 'create'
+      });
+    }
+
+    const libFiles = ['adapter.mjs', 'state.mjs', 'config.mjs', 'utils.mjs', 'messages.mjs', 'pipeline.mjs'];
+    for (const lib of libFiles) {
+      const target = join(claudeDir, 'lib', lib);
+      actions.push({
+        type: 'lib',
+        path: `.claude/lib/${lib}`,
+        status: existsSync(target) ? 'update' : 'create'
+      });
+    }
+  }
+
+  // CLAUDE.md
+  const claudeMdPath = join(projectDir, 'CLAUDE.md');
+  actions.push({
+    type: 'rules',
+    path: 'CLAUDE.md',
+    status: existsSync(claudeMdPath) ? 'update' : 'create'
+  });
+
+  // Config
+  const configPath = join(projectDir, '.claude-prism.json');
+  if (!existsSync(configPath)) {
+    actions.push({ type: 'config', path: '.claude-prism.json', status: 'create' });
+  }
+
+  return { actions };
+}
+
 // ─── internal helpers ───
 
 function injectRules(projectDir, language) {
   const claudeMdPath = join(projectDir, 'CLAUDE.md');
   const rulesFile = `rules.${language}.md`;
-  const rulesPath = join(TEMPLATES_DIR, rulesFile);
+  let rulesPath = join(TEMPLATES_DIR, rulesFile);
 
+  // Fallback to English if requested language not available
   if (!existsSync(rulesPath)) {
-    // Fallback to English
-    const fallback = join(TEMPLATES_DIR, 'rules.en.md');
-    if (!existsSync(fallback)) return;
+    rulesPath = join(TEMPLATES_DIR, 'rules.en.md');
+    if (!existsSync(rulesPath)) return;
   }
 
-  const rules = readFileSync(existsSync(rulesPath) ? rulesPath : join(TEMPLATES_DIR, 'rules.en.md'), 'utf8');
+  const rules = readFileSync(rulesPath, 'utf8');
 
   let existing = '';
   if (existsSync(claudeMdPath)) {

package/lib/messages.mjs

@@ -0,0 +1,60 @@
+/**
+ * claude-prism — Hook Message Templates
+ * Provides localized messages for hook output
+ */
+
+const MESSAGES = {
+  en: {
+    'commit-guard.block.failed': '🌈 Prism ✋ Commit blocked: last test run FAILED. Fix tests before committing.',
+    '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.',
+    'debug-loop.block.divergent': '🌈 Prism ✋ Debug Loop blocked: {name} edited {count} times on same area. Discuss approach with user before continuing.',
+    'debug-loop.warn.divergent': '🌈 Prism > Debug Loop: {name} edited {count} times on same area. Stop and investigate root cause.',
+    'debug-loop.warn.convergent': '🌈 Prism > Debug Loop: {name} edited {count} times (different areas). Consider if this is expected.',
+    'scope-guard.block': '🌈 Prism ✋ Scope Guard: {count} unique files modified without a plan. Run /prism to decompose before continuing.',
+    'scope-guard.warn': '🌈 Prism > Scope Guard: {count} unique files modified. Consider running /prism to decompose the task.',
+    'scope-guard.plan-detected': '🌈 Prism 📋 Plan file detected. Scope thresholds raised.',
+    'test-tracker.warn.failed': '🌈 Prism 📊 Tests FAILED. Fix before committing.',
+  },
+  ko: {
+    'commit-guard.block.failed': '🌈 Prism ✋ 커밋 차단: 마지막 테스트 실패. 테스트를 수정한 후 커밋하세요.',
+    'commit-guard.warn.no-test': '🌈 Prism > 이 세션에서 테스트 실행 이력이 없습니다. 커밋 전에 테스트를 실행하세요.',
+    'commit-guard.warn.stale': '🌈 Prism > 마지막 테스트가 {minutes}분 전입니다. 커밋 전에 테스트를 실행하세요.',
+    'debug-loop.block.divergent': '🌈 Prism ✋ 디버그 루프 차단: {name}이 같은 영역에서 {count}회 수정됨. 사용자와 접근 방식을 논의하세요.',
+    'debug-loop.warn.divergent': '🌈 Prism > 디버그 루프: {name}이 같은 영역에서 {count}회 수정됨. 멈추고 근본 원인을 조사하세요.',
+    'debug-loop.warn.convergent': '🌈 Prism > 디버그 루프: {name}이 {count}회 수정됨 (다른 영역). 예상된 작업인지 확인하세요.',
+    'scope-guard.block': '🌈 Prism ✋ 스코프 가드: 계획 없이 {count}개 고유 파일 수정됨. /prism으로 분해 후 계속하세요.',
+    'scope-guard.warn': '🌈 Prism > 스코프 가드: {count}개 고유 파일 수정됨. /prism으로 작업을 분해하는 것을 고려하세요.',
+    'scope-guard.plan-detected': '🌈 Prism 📋 계획 파일 감지됨. 스코프 임계값이 상향 조정되었습니다.',
+    'test-tracker.warn.failed': '🌈 Prism 📊 테스트 실패. 커밋 전에 수정하세요.',
+  },
+  ja: {
+    'commit-guard.block.failed': '🌈 Prism ✋ コミットブロック: 最後のテストが失敗しました。テストを修正してからコミットしてください。',
+    'commit-guard.warn.no-test': '🌈 Prism > このセッションでテスト実行が検出されません。コミット前にテストを実行してください。',
+    'commit-guard.warn.stale': '🌈 Prism > 最後のテスト実行は{minutes}分前です。コミット前にテストを実行してください。',
+    'debug-loop.block.divergent': '🌈 Prism ✋ デバッグループブロック: {name}が同じ領域で{count}回編集されました。ユーザーとアプローチを議論してください。',
+    'debug-loop.warn.divergent': '🌈 Prism > デバッグループ: {name}が同じ領域で{count}回編集されました。停止して根本原因を調査してください。',
+    'debug-loop.warn.convergent': '🌈 Prism > デバッグループ: {name}が{count}回編集されました（異なる領域）。想定通りか確認してください。',
+    'scope-guard.block': '🌈 Prism ✋ スコープガード: 計画なしに{count}個のファイルが変更されました。/prismで分解してから続行してください。',
+    'scope-guard.warn': '🌈 Prism > スコープガード: {count}個のファイルが変更されました。/prismでタスクの分解を検討してください。',
+    'scope-guard.plan-detected': '🌈 Prism 📋 計画ファイルを検出。スコープ閾値を引き上げました。',
+    'test-tracker.warn.failed': '🌈 Prism 📊 テスト失敗。コミット前に修正してください。',
+  },
+  zh: {
+    'commit-guard.block.failed': '🌈 Prism ✋ 提交被阻止：上次测试失败。请修复测试后再提交。',
+    'commit-guard.warn.no-test': '🌈 Prism > 本次会话未检测到测试运行。请在提交前运行测试。',
+    'commit-guard.warn.stale': '🌈 Prism > 上次测试运行在{minutes}分钟前。请在提交前运行测试。',
+    'debug-loop.block.divergent': '🌈 Prism ✋ 调试循环阻止：{name}在同一区域被编辑了{count}次。请与用户讨论方法。',
+    'debug-loop.warn.divergent': '🌈 Prism > 调试循环：{name}在同一区域被编辑了{count}次。停止并调查根本原因。',
+    'debug-loop.warn.convergent': '🌈 Prism > 调试循环：{name}被编辑了{count}次（不同区域）。请确认这是否是预期行为。',
+    'scope-guard.block': '🌈 Prism ✋ 范围守卫：未制定计划就修改了{count}个文件。请运行/prism分解后再继续。',
+    'scope-guard.warn': '🌈 Prism > 范围守卫：已修改{count}个文件。请考虑运行/prism来分解任务。',
+    'scope-guard.plan-detected': '🌈 Prism 📋 检测到计划文件。范围阈值已提高。',
+    'test-tracker.warn.failed': '🌈 Prism 📊 测试失败。请在提交前修复。',
+  },
+};
+
+export function getMessage(lang, key, params = {}) {
+  const template = MESSAGES[lang]?.[key] || MESSAGES.en[key] || key;
+  return template.replace(/\{(\w+)\}/g, (_, k) => params[k] ?? `{${k}}`);
+}

package/lib/pipeline.mjs

@@ -0,0 +1,188 @@
+/**
+ * claude-prism — Hook Pipeline
+ * Runs multiple rules in a single hook invocation for reduced I/O
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { sanitizeId } from './utils.mjs';
+import { loadConfig } from './config.mjs';
+import { getStateDir } from './state.mjs';
+
+const TOOL_ACTION_MAP = {
+  'Edit': 'edit',
+  'Write': 'write',
+  'Bash': 'command',
+  'Read': 'read',
+  'Task': 'subagent',
+};
+
+const EVENT_PHASE_MAP = {
+  'PreToolUse': 'pre',
+  'PostToolUse': 'post',
+  'UserPromptSubmit': 'prompt',
+};
+
+function parseInput() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function toContext(input, hookEventName) {
+  const toolName = input.tool_name || '';
+  return {
+    action: TOOL_ACTION_MAP[toolName] || toolName.toLowerCase(),
+    phase: EVENT_PHASE_MAP[hookEventName] || 'pre',
+    filePath: input.tool_input?.file_path || undefined,
+    command: input.tool_input?.command || undefined,
+    oldString: input.tool_input?.old_string || undefined,
+    sessionId: sanitizeId(input.session_id),
+    agentId: sanitizeId(input.agent_id || ''),
+    stdout: input.tool_response?.stdout ?? undefined,
+    stderr: input.tool_response?.stderr ?? undefined,
+    interrupted: input.tool_response?.interrupted ?? false,
+    userPrompt: input.tool_input?.user_prompt ?? undefined,
+  };
+}
+
+function formatOutput(hookEventName, messages) {
+  if (messages.length === 0) return null;
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName,
+      additionalContext: messages.join('\n')
+    }
+  });
+}
+
+/**
+ * Run a pipeline of rules for a single hook event
+ * @param {Array<{name: string, rule: Object}>} rules - Rules with evaluate() methods
+ * @param {string} hookEventName - 'PreToolUse' or 'PostToolUse'
+ */
+export function runPipeline(rules, hookEventName) {
+  const input = parseInput();
+  if (!input) process.exit(0);
+
+  // Read config ONCE
+  const fullConfig = loadConfig(process.cwd());
+
+  const ctx = toContext(input, hookEventName);
+  const stateDir = getStateDir(ctx.sessionId, ctx.agentId);
+
+  const messages = [];
+  let blocked = false;
+  let blockMessage = '';
+
+  for (const { name, rule } of rules) {
+    // Build hook-specific config (same as getHookConfig but without re-reading file)
+    const hookConfig = fullConfig.hooks?.[name] || { enabled: true };
+    hookConfig.language = fullConfig.language || 'en';
+    hookConfig.sourceExtensions = fullConfig.sourceExtensions;
+    hookConfig.testPatterns = fullConfig.testPatterns;
+
+    if (!hookConfig.enabled) continue;
+
+    const result = rule.evaluate(ctx, hookConfig, stateDir);
+
+    if (result.type === 'block') {
+      blocked = true;
+      blockMessage = result.message || '🌈 Prism ✋ Action blocked.';
+      break; // First block wins, stop pipeline
+    }
+
+    if (result.message) {
+      messages.push(result.message);
+    }
+  }
+
+  if (blocked) {
+    process.stderr.write(blockMessage);
+    process.exit(2);
+  }
+
+  const output = formatOutput(hookEventName, messages);
+  if (output) {
+    process.stdout.write(output);
+  }
+}
+
+/**
+ * Load custom rules from config and merge with built-in rules
+ * @param {Array<{name: string, rule: Object}>} builtInRules
+ * @param {string[]} customRulePaths - Paths relative to project root
+ * @returns {Promise<Array<{name: string, rule: Object}>>}
+ */
+export async function loadCustomRules(builtInRules, customRulePaths) {
+  if (!customRulePaths || customRulePaths.length === 0) return builtInRules;
+
+  const rules = [...builtInRules];
+  for (const rulePath of customRulePaths) {
+    try {
+      const absPath = join(process.cwd(), rulePath);
+      const mod = await import(absPath);
+      const rule = mod.default || mod[Object.keys(mod)[0]];
+      if (rule && typeof rule.evaluate === 'function') {
+        rules.push({ name: rule.name || rulePath, rule });
+      }
+    } catch {
+      // Skip invalid rules silently — don't break the pipeline
+    }
+  }
+  return rules;
+}
+
+/**
+ * Run pipeline with custom rules support (async)
+ * @param {Array<{name: string, rule: Object}>} builtInRules
+ * @param {string} hookEventName - 'PreToolUse' or 'PostToolUse'
+ */
+export async function runPipelineAsync(builtInRules, hookEventName) {
+  const input = parseInput();
+  if (!input) process.exit(0);
+
+  const fullConfig = loadConfig(process.cwd());
+  const customRulePaths = fullConfig.customRules || [];
+  const rules = await loadCustomRules(builtInRules, customRulePaths);
+
+  const ctx = toContext(input, hookEventName);
+  const stateDir = getStateDir(ctx.sessionId, ctx.agentId);
+
+  const messages = [];
+  let blocked = false;
+  let blockMessage = '';
+
+  for (const { name, rule } of rules) {
+    const hookConfig = fullConfig.hooks?.[name] || { enabled: true };
+    hookConfig.language = fullConfig.language || 'en';
+    hookConfig.sourceExtensions = fullConfig.sourceExtensions;
+    hookConfig.testPatterns = fullConfig.testPatterns;
+
+    if (hookConfig.enabled === false) continue;
+
+    const result = rule.evaluate(ctx, hookConfig, stateDir);
+
+    if (result.type === 'block') {
+      blocked = true;
+      blockMessage = result.message || '🌈 Prism ✋ Action blocked.';
+      break;
+    }
+
+    if (result.message) {
+      messages.push(result.message);
+    }
+  }
+
+  if (blocked) {
+    process.stderr.write(blockMessage);
+    process.exit(2);
+  }
+
+  const output = formatOutput(hookEventName, messages);
+  if (output) {
+    process.stdout.write(output);
+  }
+}

package/lib/session.mjs

@@ -0,0 +1,108 @@
+/**
+ * claude-prism — Session Event Logger
+ * JSONL-based event recording for session analysis
+ */
+
+import { readFileSync, appendFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const SESSION_ROOT = join(tmpdir(), '.prism', 'sessions');
+
+/**
+ * Get session log file path
+ */
+export function getSessionLogPath(sessionId) {
+  mkdirSync(SESSION_ROOT, { recursive: true, mode: 0o700 });
+  return join(SESSION_ROOT, `${sessionId}.jsonl`);
+}
+
+/**
+ * Append an event to the session log
+ */
+export function logEvent(sessionId, event) {
+  const logPath = getSessionLogPath(sessionId);
+  const entry = {
+    ts: Date.now(),
+    ...event
+  };
+  appendFileSync(logPath, JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
+/**
+ * Read all events from a session log
+ */
+export function readSessionLog(sessionId) {
+  const logPath = getSessionLogPath(sessionId);
+  if (!existsSync(logPath)) return [];
+  try {
+    const content = readFileSync(logPath, 'utf8').trim();
+    if (!content) return [];
+    return content.split('\n').map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get session summary from event log
+ */
+export function getSessionSummary(sessionId) {
+  const events = readSessionLog(sessionId);
+  if (events.length === 0) return null;
+
+  const summary = {
+    sessionId,
+    totalEvents: events.length,
+    turns: 0,
+    filesCreated: 0,
+    filesModified: 0,
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    blocks: 0,
+    warnings: 0,
+    startedAt: events[0]?.ts || null,
+    lastEventAt: events[events.length - 1]?.ts || null,
+  };
+
+  for (const event of events) {
+    switch (event.type) {
+      case 'turn':
+        summary.turns++;
+        break;
+      case 'file-edit':
+        summary.filesModified++;
+        break;
+      case 'file-create':
+        summary.filesCreated++;
+        break;
+      case 'test-run':
+        summary.testsRun++;
+        if (event.passed) summary.testsPassed++;
+        else summary.testsFailed++;
+        break;
+      case 'block':
+        summary.blocks++;
+        break;
+      case 'warn':
+        summary.warnings++;
+        break;
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * List all session log files
+ */
+export function listSessions() {
+  if (!existsSync(SESSION_ROOT)) return [];
+  return readdirSync(SESSION_ROOT)
+    .filter(f => f.endsWith('.jsonl'))
+    .map(f => f.replace('.jsonl', ''))
+    .sort();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-prism",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "AI coding problem decomposition tool — Understand, Decompose, Execute, Checkpoint.",
   "type": "module",
   "bin": {
@@ -36,6 +36,14 @@
     "README.md",
     "README.ko.md"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lazysaturday91/claude-prism.git"
+  },
+  "homepage": "https://github.com/lazysaturday91/claude-prism#readme",
+  "bugs": {
+    "url": "https://github.com/lazysaturday91/claude-prism/issues"
+  },
   "author": "lazysaturday91",
   "license": "MIT"
 }

package/templates/runners/post-tool.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { runPipelineAsync } from '../lib/pipeline.mjs';
+import { debugLoop } from '../rules/debug-loop.mjs';
+import { scopeGuard } from '../rules/scope-guard.mjs';
+import { testTracker } from '../rules/test-tracker.mjs';
+import { alignment } from '../rules/alignment.mjs';
+
+await runPipelineAsync([
+  { name: 'debug-loop', rule: debugLoop },
+  { name: 'scope-guard', rule: scopeGuard },
+  { name: 'test-tracker', rule: testTracker },
+  { name: 'alignment', rule: alignment },
+], 'PostToolUse');

package/templates/runners/pre-tool.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runPipelineAsync } from '../lib/pipeline.mjs';
+import { commitGuard } from '../rules/commit-guard.mjs';
+import { alignment } from '../rules/alignment.mjs';
+
+await runPipelineAsync([
+  { name: 'commit-guard', rule: commitGuard },
+  { name: 'alignment', rule: alignment },
+], 'PreToolUse');

package/templates/runners/user-prompt.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runPipelineAsync } from '../lib/pipeline.mjs';
+import { turnReporter } from '../rules/turn-reporter.mjs';
+
+await runPipelineAsync([
+  { name: 'turn-reporter', rule: turnReporter },
+], 'UserPromptSubmit');

package/templates/settings.json

@@ -6,40 +6,31 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/commit-guard.mjs",
-            "timeout": 5
+            "command": "node .claude/hooks/pre-tool.mjs",
+            "timeout": 5000
           }
         ]
       }
     ],
     "PostToolUse": [
       {
-        "matcher": "Edit|Write",
+        "matcher": "Edit|Write|Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/debug-loop.mjs",
-            "timeout": 5
+            "command": "node .claude/hooks/post-tool.mjs",
+            "timeout": 5000
           }
         ]
-      },
-      {
-        "matcher": "Edit|Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node .claude/hooks/scope-guard.mjs",
-            "timeout": 5
-          }
-        ]
-      },
+      }
+    ],
+    "UserPromptSubmit": [
       {
-        "matcher": "Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/test-tracker.mjs",
-            "timeout": 5
+            "command": "node .claude/hooks/user-prompt.mjs",
+            "timeout": 5000
           }
         ]
       }