@webpieces/dev-config 0.2.75 → 0.2.77

package/architecture/executors/validate-modified-methods/executor.ts

@@ -5,10 +5,10 @@
  * This encourages gradual cleanup of legacy long methods - when you touch a method,
  * you must bring it under the limit.
  *
- * Combined with validate-new-methods (30 line limit), this creates a gradual
+ * Combined with validate-new-methods, this creates a gradual
  * transition to cleaner code:
- * - New methods: strict 30 line limit
- * - Modified methods: lenient 80 line limit (cleanup when touched)
+ * - New methods: must be under limit
+ * - Modified methods: must be under limit (cleanup when touched)
  * - Untouched methods: no limit (legacy allowed)
  *
  * Usage:
@@ -25,11 +25,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-export type ValidationMode = 'STRICT' | 'NORMAL' | 'OFF';
+export type MethodMaxLimitMode = 'OFF' | 'NEW_METHODS' | 'NEW_AND_MODIFIED_METHODS' | 'MODIFIED_FILES';
 
 export interface ValidateModifiedMethodsOptions {
-    max?: number;
-    mode?: ValidationMode;
+    limit?: number;
+    mode?: MethodMaxLimitMode;
+    disableAllowed?: boolean;
 }
 
 export interface ExecutorResult {
@@ -52,10 +53,8 @@ const METHODSIZE_DOC_CONTENT = `# Instructions: Method Too Long
 
 ## Requirement
 
-**~50% of the time**, you can stay under the \`newMethodsMaxLines\` limit from nx.json
+**~99% of the time**, you can stay under the \`limit\` from nx.json
 by extracting logical units into well-named methods.
-
-**~99% of the time**, you can stay under the \`modifiedAndNewMethodsMaxLines\` limit from nx.json.
 Nearly all software can be written with methods under this size.
 Take the extra time to refactor - it's worth it for long-term maintainability.
 
@@ -78,8 +77,8 @@ Methods under reasonable limits are:
 ## Gradual Cleanup Strategy
 
 This codebase uses a gradual cleanup approach:
-- **New methods**: Must be under \`newMethodsMaxLines\` from nx.json
-- **Modified methods**: Must be under \`modifiedAndNewMethodsMaxLines\` from nx.json
+- **New methods**: Must be under \`limit\` from nx.json
+- **Modified methods**: Must be under \`limit\` from nx.json
 - **Untouched methods**: No limit (legacy code is allowed until touched)
 
 ## How to Refactor
@@ -557,11 +556,11 @@ function methodHasChanges(method: MethodInfo, changedLineNumbers: Set<number>):
 /**
  * Check a NEW method and return violation if applicable
  */
-function checkNewMethodViolation(file: string, method: MethodInfo, mode: ValidationMode): MethodViolation | null {
+function checkNewMethodViolation(file: string, method: MethodInfo, disableAllowed: boolean): MethodViolation | null {
     const { type: disableType, isExpired, date: disableDate } = method.disableInfo;
 
-    if (mode === 'STRICT') {
-        // When mode is STRICT, skip NEW methods without escape (let validate-new-methods handle)
+    if (!disableAllowed) {
+        // When disableAllowed is false, skip NEW methods without escape (let validate-new-methods handle)
         if (disableType === 'none') return null;
         return { file, methodName: method.name, line: method.line, lines: method.lines };
     }
@@ -580,12 +579,16 @@ function checkNewMethodViolation(file: string, method: MethodInfo, mode: Validat
 /**
  * Check a MODIFIED method and return violation if applicable
  */
-function checkModifiedMethodViolation(file: string, method: MethodInfo, mode: ValidationMode): MethodViolation {
+function checkModifiedMethodViolation(file: string, method: MethodInfo, disableAllowed: boolean): MethodViolation | null {
     const { type: disableType, isExpired, date: disableDate } = method.disableInfo;
 
-    if (mode === 'STRICT') {
+    if (!disableAllowed) {
         return { file, methodName: method.name, line: method.line, lines: method.lines };
     }
+    if (disableType === 'full' && !isExpired) {
+        // Valid escape, no violation
+        return null;
+    }
     if (disableType === 'full' && isExpired) {
         return { file, methodName: method.name, line: method.line, lines: method.lines, expiredDisable: true, expiredDate: disableDate };
     }
@@ -593,15 +596,15 @@ function checkModifiedMethodViolation(file: string, method: MethodInfo, mode: Va
 }
 
 /**
- * Find methods that exceed the 80-line limit.
+ * Find methods that exceed the limit.
  * Checks NEW methods with escape hatches and MODIFIED methods.
  */
 function findViolations(
     workspaceRoot: string,
     changedFiles: string[],
     base: string,
-    maxLines: number,
-    mode: ValidationMode,
+    limit: number,
+    disableAllowed: boolean,
     head?: string
 ): MethodViolation[] {
     const violations: MethodViolation[] = [];
@@ -619,17 +622,18 @@ function findViolations(
         for (const method of methods) {
             const { type: disableType, isExpired } = method.disableInfo;
 
-            // Skip methods with valid, non-expired full escape - unless mode is STRICT
-            if (mode !== 'STRICT' && disableType === 'full' && !isExpired) continue;
-            if (method.lines <= maxLines) continue;
+            // Skip methods with valid, non-expired full escape - unless disableAllowed is false
+            if (disableAllowed && disableType === 'full' && !isExpired) continue;
+            if (method.lines <= limit) continue;
 
             const isNewMethod = newMethodNames.has(method.name);
 
             if (isNewMethod) {
-                const violation = checkNewMethodViolation(file, method, mode);
+                const violation = checkNewMethodViolation(file, method, disableAllowed);
                 if (violation) violations.push(violation);
             } else if (methodHasChanges(method, changedLineNumbers)) {
-                violations.push(checkModifiedMethodViolation(file, method, mode));
+                const violation = checkModifiedMethodViolation(file, method, disableAllowed);
+                if (violation) violations.push(violation);
             }
         }
     }
@@ -673,44 +677,44 @@ function detectBase(workspaceRoot: string): string | null {
  * Report violations to console
  */
 // webpieces-disable max-lines-new-methods -- Error output formatting with multiple message sections
-function reportViolations(violations: MethodViolation[], maxLines: number, mode: ValidationMode): void {
+function reportViolations(violations: MethodViolation[], limit: number, disableAllowed: boolean): void {
     console.error('');
-    console.error('❌ Modified methods exceed ' + maxLines + ' lines!');
+    console.error('\u274c Modified methods exceed ' + limit + ' lines!');
     console.error('');
-    console.error('📚 When you modify a method, you must bring it under ' + maxLines + ' lines.');
+    console.error('\ud83d\udcda When you modify a method, you must bring it under ' + limit + ' lines.');
     console.error('   This rule encourages GRADUAL cleanup so even though you did not cause it,');
     console.error('   you touched it, so you should fix now as part of your PR');
     console.error('   (this is for vibe coding and AI to fix as it touches things).');
     console.error('   You can refactor to stay under the limit 50% of the time. If not feasible, use the escape hatch.');
     console.error('');
     console.error(
-        '⚠️  *** READ tmp/webpieces/webpieces.methodsize.md for detailed guidance on how to fix this easily *** ⚠️'
+        '\u26a0\ufe0f  *** READ tmp/webpieces/webpieces.methodsize.md for detailed guidance on how to fix this easily *** \u26a0\ufe0f'
     );
     console.error('');
 
     for (const v of violations) {
         if (v.expiredDisable) {
-            console.error(`  ❌ ${v.file}:${v.line}`);
-            console.error(`     Method: ${v.methodName} (${v.lines} lines, max: ${maxLines})`);
-            console.error(`     ⏰ EXPIRED DISABLE: Your disable comment dated ${v.expiredDate ?? 'unknown'} has expired (>1 month old).`);
+            console.error(`  \u274c ${v.file}:${v.line}`);
+            console.error(`     Method: ${v.methodName} (${v.lines} lines, max: ${limit})`);
+            console.error(`     \u23f0 EXPIRED DISABLE: Your disable comment dated ${v.expiredDate ?? 'unknown'} has expired (>1 month old).`);
             console.error(`        You must either FIX the method or UPDATE the date to get another month.`);
         } else {
-            console.error(`  ❌ ${v.file}:${v.line}`);
-            console.error(`     Method: ${v.methodName} (${v.lines} lines, max: ${maxLines})`);
+            console.error(`  \u274c ${v.file}:${v.line}`);
+            console.error(`     Method: ${v.methodName} (${v.lines} lines, max: ${limit})`);
         }
     }
     console.error('');
 
-    // Only show escape hatch instructions when mode is not STRICT
-    if (mode !== 'STRICT') {
+    // Only show escape hatch instructions when disableAllowed is true
+    if (disableAllowed) {
         console.error('   You can disable this error, but you will be forced to fix again in 1 month');
-        console.error('   since 99% of methods can be less than ' + maxLines + ' lines of code.');
+        console.error('   since 99% of methods can be less than ' + limit + ' lines of code.');
         console.error('');
         console.error('   Use escape with DATE (expires in 1 month):');
         console.error(`   // webpieces-disable max-lines-modified ${getTodayDateString()} -- [your reason]`);
         console.error('');
     } else {
-        console.error('   ⚠️  validationMode is STRICT - disable comments are NOT allowed.');
+        console.error('   \u26a0\ufe0f  disableAllowed is false - disable comments are NOT allowed.');
         console.error('   You MUST refactor to reduce method size.');
         console.error('');
     }
@@ -721,12 +725,13 @@ export default async function runExecutor(
     context: ExecutorContext
 ): Promise<ExecutorResult> {
     const workspaceRoot = context.root;
-    const maxLines = options.max ?? 80;
-    const mode: ValidationMode = options.mode ?? 'NORMAL';
+    const limit = options.limit ?? 80;
+    const mode: MethodMaxLimitMode = options.mode ?? 'NEW_AND_MODIFIED_METHODS';
+    const disableAllowed = options.disableAllowed ?? true;
 
     // Skip validation entirely if mode is OFF
     if (mode === 'OFF') {
-        console.log('\n⏭️  Skipping modified method validation (validationMode: OFF)');
+        console.log('\n\u23ed\ufe0f  Skipping modified method validation (mode: OFF)');
         console.log('');
         return { success: true };
     }
@@ -739,46 +744,47 @@ export default async function runExecutor(
         base = detectBase(workspaceRoot) ?? undefined;
 
         if (!base) {
-            console.log('\n⏭️  Skipping modified method validation (could not detect base branch)');
+            console.log('\n\u23ed\ufe0f  Skipping modified method validation (could not detect base branch)');
             console.log('   To run explicitly: nx affected --target=validate-modified-methods --base=origin/main');
             console.log('');
             return { success: true };
         }
 
-        console.log('\n📏 Validating Modified Method Sizes (auto-detected base)\n');
+        console.log('\n\ud83d\udccf Validating Modified Method Sizes (auto-detected base)\n');
     } else {
-        console.log('\n📏 Validating Modified Method Sizes\n');
+        console.log('\n\ud83d\udccf Validating Modified Method Sizes\n');
     }
 
     console.log(`   Base: ${base}`);
     console.log(`   Head: ${head ?? 'working tree (includes uncommitted changes)'}`);
-    console.log(`   Max lines for modified methods: ${maxLines}`);
-    console.log(`   Validation mode: ${mode}${mode === 'STRICT' ? ' (disable comments ignored)' : ''}`);
+    console.log(`   Mode: ${mode}`);
+    console.log(`   Limit for modified methods: ${limit}`);
+    console.log(`   Disable allowed: ${disableAllowed}${!disableAllowed ? ' (no escape hatch)' : ''}`);
     console.log('');
 
     try {
         const changedFiles = getChangedTypeScriptFiles(workspaceRoot, base, head);
 
         if (changedFiles.length === 0) {
-            console.log('✅ No TypeScript files changed');
+            console.log('\u2705 No TypeScript files changed');
             return { success: true };
         }
 
-        console.log(`📂 Checking ${changedFiles.length} changed file(s)...`);
+        console.log(`\ud83d\udcc2 Checking ${changedFiles.length} changed file(s)...`);
 
-        const violations = findViolations(workspaceRoot, changedFiles, base, maxLines, mode, head);
+        const violations = findViolations(workspaceRoot, changedFiles, base, limit, disableAllowed, head);
 
         if (violations.length === 0) {
-            console.log('✅ All modified methods are under ' + maxLines + ' lines');
+            console.log('\u2705 All modified methods are under ' + limit + ' lines');
             return { success: true };
         }
 
         writeTmpInstructions(workspaceRoot);
-        reportViolations(violations, maxLines, mode);
+        reportViolations(violations, limit, disableAllowed);
         return { success: false };
     } catch (err: unknown) {
         const error = err instanceof Error ? err : new Error(String(err));
-        console.error('❌ Modified method validation failed:', error.message);
+        console.error('\u274c Modified method validation failed:', error.message);
         return { success: false };
     }
 }

package/architecture/executors/validate-modified-methods/schema.json

@@ -4,16 +4,21 @@
     "description": "Validates that modified methods don't exceed a maximum line count. Encourages gradual cleanup of legacy long methods.",
     "type": "object",
     "properties": {
-        "max": {
+        "limit": {
             "type": "number",
-            "description": "Maximum number of lines allowed for modified methods",
+            "description": "Maximum lines allowed for modified methods",
             "default": 80
         },
         "mode": {
             "type": "string",
-            "enum": ["STRICT", "NORMAL", "OFF"],
-            "description": "STRICT: limits enforced, no disable comments. NORMAL: disable comments work. OFF: skip validation.",
-            "default": "NORMAL"
+            "enum": ["OFF", "NEW_METHODS", "NEW_AND_MODIFIED_METHODS", "MODIFIED_FILES"],
+            "description": "OFF: skip validation. NEW_AND_MODIFIED_METHODS: new methods + methods with changes. MODIFIED_FILES: all methods in modified files.",
+            "default": "NEW_AND_MODIFIED_METHODS"
+        },
+        "disableAllowed": {
+            "type": "boolean",
+            "description": "Whether disable comments work. When false, no escape hatch (like old STRICT mode).",
+            "default": true
         }
     },
     "required": []

package/architecture/executors/validate-new-methods/executor.d.ts

@@ -16,11 +16,11 @@
  * Escape hatch: Add webpieces-disable max-lines-new-methods comment with justification
  */
 import type { ExecutorContext } from '@nx/devkit';
-export type ValidationMode = 'STRICT' | 'NORMAL' | 'OFF';
+export type MethodMaxLimitMode = 'OFF' | 'NEW_METHODS' | 'NEW_AND_MODIFIED_METHODS' | 'MODIFIED_FILES';
 export interface ValidateNewMethodsOptions {
-    max?: number;
-    strictMax?: number;
-    mode?: ValidationMode;
+    limit?: number;
+    mode?: MethodMaxLimitMode;
+    disableAllowed?: boolean;
 }
 export interface ExecutorResult {
     success: boolean;

package/architecture/executors/validate-new-methods/executor.js

@@ -29,10 +29,8 @@ const METHODSIZE_DOC_CONTENT = `# Instructions: New Method Too Long
 
 ## Requirement
 
-**~50% of the time**, you can stay under the \`newMethodsMaxLines\` limit from nx.json
+**~99% of the time**, you can stay under the \`limit\` from nx.json
 by extracting logical units into well-named methods.
-
-**~99% of the time**, you can stay under the \`modifiedAndNewMethodsMaxLines\` limit from nx.json.
 Nearly all software can be written with methods under this size.
 
 ## The "Table of Contents" Principle
@@ -270,8 +268,6 @@ function findNewMethodSignaturesInDiff(diffContent) {
 /**
  * Check if a line contains a webpieces-disable comment that exempts from new method validation.
  * Both max-lines-new-methods AND max-lines-modified are accepted here.
- * - max-lines-new-methods: Exempts from 30-line check, still checked by 80-line validator
- * - max-lines-modified: Exempts from both validators (ultimate escape hatch)
  */
 function hasDisableComment(lines, lineNumber) {
     // Check the line before the method (lineNumber is 1-indexed, array is 0-indexed)
@@ -284,7 +280,7 @@ function hasDisableComment(lines, lineNumber) {
             break;
         }
         if (line.includes('webpieces-disable')) {
-            // Either escape hatch exempts from the 30-line new method check
+            // Either escape hatch exempts from the lowLimit new method check
             if (line.includes('max-lines-new-methods') || line.includes('max-lines-modified')) {
                 return true;
             }
@@ -295,6 +291,7 @@ function hasDisableComment(lines, lineNumber) {
 /**
  * Parse a TypeScript file and find methods with their line counts
  */
+// webpieces-disable max-lines-new-methods -- AST traversal requires inline visitor function
 function findMethodsInFile(filePath, workspaceRoot) {
     const fullPath = path.join(workspaceRoot, filePath);
     if (!fs.existsSync(fullPath))
@@ -347,7 +344,7 @@ function findMethodsInFile(filePath, workspaceRoot) {
 /**
  * Find new methods that exceed the line limit
  */
-function findViolations(workspaceRoot, changedFiles, base, maxLines, strictMaxLines, head) {
+function findViolations(workspaceRoot, changedFiles, base, limit, disableAllowed, head) {
     const violations = [];
     for (const file of changedFiles) {
         // Get the diff to find which methods are NEW (not just modified)
@@ -360,29 +357,29 @@ function findViolations(workspaceRoot, changedFiles, base, maxLines, strictMaxLi
         for (const method of methods) {
             if (!newMethodNames.has(method.name))
                 continue;
-            // Check hard limit first (if defined) - NO escape possible
-            if (strictMaxLines && method.lines > strictMaxLines) {
-                violations.push({
-                    file,
-                    methodName: method.name,
-                    line: method.line,
-                    lines: method.lines,
-                    isNew: true,
-                    isHardLimit: true,
-                    limit: strictMaxLines,
-                });
-            }
-            // Check soft limit - can be escaped with disable comment
-            else if (method.lines > maxLines && !method.hasDisableComment) {
-                violations.push({
-                    file,
-                    methodName: method.name,
-                    line: method.line,
-                    lines: method.lines,
-                    isNew: true,
-                    isHardLimit: false,
-                    limit: maxLines,
-                });
+            if (method.lines > limit) {
+                if (!disableAllowed) {
+                    // No escape possible
+                    violations.push({
+                        file,
+                        methodName: method.name,
+                        line: method.line,
+                        lines: method.lines,
+                        isNew: true,
+                        limit,
+                    });
+                }
+                else if (!method.hasDisableComment) {
+                    // Escape allowed but not present
+                    violations.push({
+                        file,
+                        methodName: method.name,
+                        line: method.line,
+                        lines: method.lines,
+                        isNew: true,
+                        limit,
+                    });
+                }
             }
         }
     }
@@ -425,54 +422,43 @@ function detectBase(workspaceRoot) {
 /**
  * Report violations to the user with helpful instructions
  */
-// webpieces-disable max-lines-new-methods -- Console output formatting requires distinct sections for hard/soft violations
-function reportViolations(violations, maxLines, strictMaxLines) {
-    const hardViolations = violations.filter((v) => v.isHardLimit);
-    const softViolations = violations.filter((v) => !v.isHardLimit);
+function reportViolations(violations, limit, disableAllowed) {
     console.error('');
-    console.error('❌ New methods exceed line limits!');
+    console.error('\u274c New methods exceed ' + limit + ' line limit!');
     console.error('');
-    console.error('📚 Methods should read like a "table of contents" - each method call');
-    console.error('   describes a larger piece of work. You can refactor');
-    console.error('   to stay under ' + maxLines + ' lines 50% of the time.');
+    console.error('\ud83d\udcda Methods should read like a "table of contents" - each method call');
+    console.error('   describes a larger piece of work.');
     console.error('');
-    console.error('⚠️  *** READ tmp/webpieces/webpieces.methodsize.md for detailed guidance on how to fix this easily *** ⚠️');
+    console.error('\u26a0\ufe0f  *** READ tmp/webpieces/webpieces.methodsize.md for detailed guidance on how to fix this easily *** \u26a0\ufe0f');
     console.error('');
-    if (hardViolations.length > 0) {
-        console.error('🚫 HARD LIMIT VIOLATIONS (cannot be bypassed with disable comment):');
-        console.error('');
-        for (const v of hardViolations) {
-            console.error(`  ❌ ${v.file}:${v.line}`);
-            console.error(`     Method: ${v.methodName} (${v.lines} lines, hard max: ${strictMaxLines})`);
-        }
-        console.error('');
-        console.error('   These methods MUST be refactored - no escape hatch available.');
-        console.error('');
+    if (disableAllowed) {
+        console.error('\u26a0\ufe0f  VIOLATIONS (can use escape hatch):');
     }
-    if (softViolations.length > 0) {
-        console.error('⚠️  SOFT LIMIT VIOLATIONS (can be bypassed with disable comment):');
-        console.error('');
-        for (const v of softViolations) {
-            console.error(`  ❌ ${v.file}:${v.line}`);
-            console.error(`     Method: ${v.methodName} (${v.lines} lines, soft max: ${maxLines})`);
-        }
-        console.error('');
-        console.error('   If you REALLY REALLY need more than ' + maxLines + ' lines, this happens 50% of the time,');
-        console.error('   so use escape: // webpieces-disable max-lines-new-methods -- [your reason]');
-        if (strictMaxLines) {
-            console.error(`   NOTE: Even with escape, you cannot exceed the hard limit of ${strictMaxLines} lines.`);
-        }
-        console.error('');
+    else {
+        console.error('\ud83d\udeab VIOLATIONS (cannot be bypassed with disable comment):');
+    }
+    console.error('');
+    for (const v of violations) {
+        console.error(`  \u274c ${v.file}:${v.line}`);
+        console.error(`     Method: ${v.methodName} (${v.lines} lines, limit: ${limit})`);
+    }
+    console.error('');
+    if (disableAllowed) {
+        console.error('   Use escape: // webpieces-disable max-lines-new-methods -- [your reason]');
     }
+    else {
+        console.error('   These methods MUST be refactored - no escape hatch available (disableAllowed=false).');
+    }
+    console.error('');
 }
 async function runExecutor(options, context) {
     const workspaceRoot = context.root;
-    const maxLines = options.max ?? 30;
-    const strictMaxLines = options.strictMax;
-    const mode = options.mode ?? 'NORMAL';
+    const limit = options.limit ?? 80;
+    const mode = options.mode ?? 'NEW_AND_MODIFIED_METHODS';
+    const disableAllowed = options.disableAllowed ?? true;
     // Skip validation entirely if mode is OFF
     if (mode === 'OFF') {
-        console.log('\n⏭️  Skipping new method validation (validationMode: OFF)');
+        console.log('\n\u23ed\ufe0f  Skipping new method validation (mode: OFF)');
         console.log('');
         return { success: true };
     }
@@ -484,48 +470,43 @@ async function runExecutor(options, context) {
         // Try to auto-detect base from git merge-base
         base = detectBase(workspaceRoot) ?? undefined;
         if (!base) {
-            console.log('\n⏭️  Skipping new method validation (could not detect base branch)');
+            console.log('\n\u23ed\ufe0f  Skipping new method validation (could not detect base branch)');
             console.log('   To run explicitly: nx affected --target=validate-new-methods --base=origin/main');
             console.log('');
             return { success: true };
         }
-        console.log('\n📏 Validating New Method Sizes (auto-detected base)\n');
+        console.log('\n\ud83d\udccf Validating New Method Sizes (auto-detected base)\n');
     }
     else {
-        console.log('\n📏 Validating New Method Sizes\n');
+        console.log('\n\ud83d\udccf Validating New Method Sizes\n');
     }
     console.log(`   Base: ${base}`);
     console.log(`   Head: ${head ?? 'working tree (includes uncommitted changes)'}`);
-    console.log(`   Soft limit for new methods: ${maxLines} lines (can escape with disable comment)`);
-    if (strictMaxLines) {
-        console.log(`   Hard limit for new methods: ${strictMaxLines} lines (NO escape possible)`);
-    }
+    console.log(`   Mode: ${mode}`);
+    console.log(`   Limit for new methods: ${limit} lines (${disableAllowed ? 'can escape' : 'NO escape possible'})`);
     console.log('');
     try {
         // Get changed TypeScript files (base to head, or working tree if head not set)
         const changedFiles = getChangedTypeScriptFiles(workspaceRoot, base, head);
         if (changedFiles.length === 0) {
-            console.log('✅ No TypeScript files changed');
+            console.log('\u2705 No TypeScript files changed');
             return { success: true };
         }
-        console.log(`📂 Checking ${changedFiles.length} changed file(s)...`);
+        console.log(`\ud83d\udcc2 Checking ${changedFiles.length} changed file(s)...`);
         // Find violations
-        const violations = findViolations(workspaceRoot, changedFiles, base, maxLines, strictMaxLines, head);
+        const violations = findViolations(workspaceRoot, changedFiles, base, limit, disableAllowed, head);
         if (violations.length === 0) {
-            const limitMsg = strictMaxLines
-                ? `soft limit (${maxLines}) or hard limit (${strictMaxLines})`
-                : `${maxLines} lines`;
-            console.log('✅ All new methods are within ' + limitMsg);
+            console.log('\u2705 All new methods are within ' + limit + ' lines');
             return { success: true };
         }
         // Write instructions file and report violations
         writeTmpInstructions(workspaceRoot);
-        reportViolations(violations, maxLines, strictMaxLines);
+        reportViolations(violations, limit, disableAllowed);
         return { success: false };
     }
     catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
-        console.error('❌ New method validation failed:', error.message);
+        console.error('\u274c New method validation failed:', error.message);
         return { success: false };
     }
 }