# Get changed file list
git status --short

# Get diff statistics
git diff --stat HEAD

# Get detailed diff
git diff HEAD

# Get file paths only
git diff --name-only HEAD

# Check for potential secrets
git diff HEAD | grep -iE "(password|secret|api[_-]?key|token|stripe[_-]?key|jwt[_-]?secret|database[_-]?url).*=.*['\"]" | grep -v "process\.env"

# Check for actual secret patterns (32+ character strings)
git diff HEAD | grep -E "^[+].*['\"][a-zA-Z0-9_-]{32,}['\"]"

# Check for .env files (should never be committed)
git diff --name-only HEAD | grep -E "^\.env"

Found: const API_KEY = "sk_live_xxxxx"
Fix:
1. Add to .env.local: API_KEY=sk_live_xxxxx
2. Replace with: const API_KEY = process.env.API_KEY
3. Add validation: if (!API_KEY) throw new Error('API_KEY is required')

# Check for template literal variables in SQL queries (dangerous)
git diff HEAD -- 'app/api/**/*.ts' 'lib/**/*.ts' | grep -E "\`.*\$\{.*\}.*\`" | grep -iE "select|insert|update|delete|where"

# Check for string concatenation in queries
git diff HEAD -- 'app/api/**/*.ts' 'lib/**/*.ts' | grep -E "query\(.*\+|sql\(.*\+"

# Check for non-parameterized queries
git diff HEAD -- 'app/api/**/*.ts' 'lib/**/*.ts' | grep -E "query\(|queryOne\(|sql\(" -A 2 | grep -E "^[+]" | grep -v "\$[0-9]"

Found: query(`SELECT * FROM users WHERE id = ${userId}`)
Fix:   query('SELECT * FROM users WHERE id = $1', [userId])

Found: query('SELECT * FROM users WHERE email = ' + email)
Fix:   query('SELECT * FROM users WHERE email = $1', [email])

# Check for dangerouslySetInnerHTML
git diff HEAD -- 'src/**/*.tsx' | grep -E "dangerouslySetInnerHTML|innerHTML"

# Check for unescaped user input rendering
git diff HEAD -- 'src/**/*.tsx' | grep -E "\{[^}]*input[^}]*\}|\{[^}]*value[^}]*\}" | grep -v "type=|placeholder=|value=|onChange="

# Check API routes for missing Zod schemas
git diff HEAD -- 'app/api/**/*.ts' | grep -E "export const (POST|PATCH)" -A 20 | grep -L "z\.object"

# Check for request.json() without validation
git diff HEAD -- 'app/api/**/*.ts' | grep "request\.json()" -A 3 | grep -v "safeParse\|parse"

# Check for missing withAuth wrapper
git diff HEAD -- 'app/api/**/route.ts' | grep -E "export const (GET|POST|PATCH|DELETE)" -B 1 | grep -v "withAuth\|withAdmin"

Found: const body = await request.json()
Fix:
1. Define schema:
   const createSchema = z.object({
     title: z.string().min(1).max(500),
     description: z.string().optional()
   });

2. Validate:
   const body = await request.json();
   const validation = createSchema.safeParse(body);
   if (!validation.success) {
     return errorResponse(validation.error.errors[0].message);
   }

3. Use validated data:
   const data = validation.data;

# Check auth routes for rate limiting
git diff HEAD -- 'app/api/auth/**/*.ts' | grep "export const POST" -A 15 | grep -v "withRateLimit"

# Check admin routes for rate limiting
git diff HEAD -- 'app/api/admin/**/*.ts' | grep "export const (POST|PATCH|DELETE)" -A 15 | grep -v "withRateLimit"

# Check new API routes generally
git diff HEAD -- 'app/api/**/*.ts' | grep "export const POST" -A 10 | grep -v "withRateLimit"

# Find console statements
git diff HEAD | grep -nE "console\.(log|warn|error|info|debug)" | grep -v "^-" | grep -v "// console"

# Find TODO/FIXME comments
git diff HEAD | grep -niE "^[+].*(//)?\s*(todo|fixme|xxx|hack)" | grep -v "TodoWrite"

# Find commented-out code blocks (3+ consecutive lines)
git diff HEAD | grep -E "^[+]\s*//\s*[a-zA-Z]" -A 2 | grep -E "^[+]\s*//"

# Remove console statements
git diff --name-only HEAD | while read file; do
  sed -i '/console\.\(log\|warn\|error\|info\|debug\)/d' "$file"
done

# Find 'any' types
git diff HEAD -- '*.ts' '*.tsx' | grep -nE ":\s*any[^a-zA-Z]" | grep -v "// "

# Find @ts-ignore or @ts-nocheck
git diff HEAD | grep -nE "@ts-(ignore|nocheck|expect-error)"

# Find excessive type assertions
git diff HEAD | grep -nE "as any|as unknown" | grep -v "^\-"

Found: const data: any = await response.json()
Fix:
1. Define interface:
   interface ResponseData {
     items: Item[];
     total: number;
   }

2. Use proper type:
   const data = await response.json() as ResponseData;
   // OR
   const data: ResponseData = await response.json();

# Check for empty catch blocks
git diff HEAD -- 'app/api/**/*.ts' | grep -E "catch.*\{" -A 5 | grep -E "^[+]\s*\}" | grep -v "errorResponse\|console\.error"

# Check for try-catch without error response
git diff HEAD -- 'app/api/**/*.ts' | grep -E "catch.*\{" -A 8 | grep -v "errorResponse\|return.*Response"

# Check for unhandled promise rejections (await outside try-catch in API routes)
git diff HEAD -- 'app/api/**/*.ts' | grep "await " | grep -v "try\|catch"

# Check for hooks outside components
git diff HEAD -- 'src/**/*.tsx' | grep -B 5 "use(State|Effect|Memo|Callback|Context)" | grep -E "^[+]export (function|const) [a-z]"

# Check for useEffect without dependency array
git diff HEAD -- 'src/**/*.tsx' | grep "useEffect" -A 2 | grep -E "^\+.*\}\)" | grep -v ", \["

# Check for missing dependencies
git diff HEAD -- 'src/**/*.tsx' | grep -E "useEffect|useCallback|useMemo" -A 5 | grep "\[\]" -B 3 | grep -E "const|let|var"

# Check for inline arrow functions in props
git diff HEAD -- 'src/**/*.tsx' | grep -E "onClick=\{.*=>|onChange=\{.*=>|onSubmit=\{.*=>"

# Check for inline object/array literals in props
git diff HEAD -- 'src/**/*.tsx' | grep -E "style=\{\{|className=\{\[|data=\{\{"

# Check for potentially unused imports (added but not referenced in diff)
git diff HEAD | grep "^+import" | cut -d' ' -f2 | cut -d',' -f1 | while read import; do
  git diff HEAD | grep -v "^+import" | grep -q "$import" || echo "Unused: $import"
done

# Find large files (500+ lines) in changed files
git diff --name-only HEAD | while read file; do
  if [ -f "$file" ]; then
    lines=$(wc -l < "$file" 2>/dev/null || echo 0)
    if [ "$lines" -gt 500 ]; then
      echo "LARGE FILE ($lines lines): $file"
    fi
  fi
done

# Find very large files (800+ lines) - high priority
git diff --name-only HEAD | while read file; do
  if [ -f "$file" ]; then
    lines=$(wc -l < "$file" 2>/dev/null || echo 0)
    if [ "$lines" -gt 800 ]; then
      echo "VERY LARGE FILE ($lines lines): $file"
    fi
  fi
done

# Find large React components (check for component files over 300 lines)
git diff --name-only HEAD | grep -E "\.tsx$" | while read file; do
  if [ -f "$file" ]; then
    lines=$(wc -l < "$file" 2>/dev/null || echo 0)
    if [ "$lines" -gt 300 ]; then
      echo "LARGE COMPONENT ($lines lines): $file"
    fi
  fi
done

# Find files with many functions (potential for extraction)
git diff --name-only HEAD | grep -E "\.(ts|tsx)$" | while read file; do
  if [ -f "$file" ]; then
    funcs=$(grep -cE "^(export )?(async )?(function |const \w+ = (\(|async \())" "$file" 2>/dev/null || echo 0)
    if [ "$funcs" -gt 10 ]; then
      echo "MANY FUNCTIONS ($funcs functions): $file"
    fi
  fi
done

Found: src/components/Dashboard.tsx (450 lines)

Recommendations:
1. Extract logical sections into sub-components:
   - DashboardHeader.tsx
   - DashboardStats.tsx
   - DashboardActions.tsx

2. Extract hooks to separate files:
   - useDashboardData.ts
   - useDashboardFilters.ts

3. Extract utility functions:
   - src/utils/dashboardHelpers.ts

Found: app/api/projects/[id]/data/route.ts (380 lines)

Recommendations:
1. Extract data transformation logic:
   - lib/transformers/projectTransformers.ts

2. Extract query builders:
   - lib/queries/projectQueries.ts

3. Keep route handler thin:
   - Validate input
   - Call service functions
   - Return response

Found: src/utils/dateUtils.ts (12 functions)

Recommendations:
1. Group related functions:
   - src/utils/date/formatting.ts (formatDate, formatTime, etc.)
   - src/utils/date/comparison.ts (isToday, isBefore, etc.)
   - src/utils/date/parsing.ts (parseDate, parseISO, etc.)

2. Create barrel export:
   - src/utils/date/index.ts

# Queries inside loops (major performance killer)
git diff HEAD -- 'app/api/**/*.ts' | grep -nE "for\s*\(|while\s*\(|\.forEach\(|\.map\(" -A 10 | grep -E "await.*query|await.*queryOne"

# Async array methods with database calls
git diff HEAD -- 'app/api/**/*.ts' | grep -nE "\.map\(async|\.forEach\(async" -A 5 | grep -E "query|queryOne"

Found: items.forEach(async (item) => { await query('SELECT...', [item.id]) })

Fix: Batch query with ANY:
     const ids = items.map(i => i.id);
     const results = await query('SELECT... WHERE id = ANY($1)', [ids]);

# SELECT without LIMIT or ID filter (can return unlimited rows)
git diff HEAD -- 'app/api/**/*.ts' | grep -nE "SELECT.*FROM" | grep -v "LIMIT|WHERE.*id\s*=|RETURNING|COUNT\(|EXISTS\(|MAX\(|MIN\("

# Leading wildcard LIKE (cannot use index, causes full table scan)
git diff HEAD -- 'app/api/**/*.ts' | grep -nE "LIKE\s*['\"]%"

# Excessive OR chains
git diff HEAD -- 'app/api/**/*.ts' | grep -nE "WHERE.*OR.*OR.*OR"

# Check if any API routes were modified
git diff --name-only HEAD | grep -E "app/api/.*route\.ts$"

# Run performance test suite
npm test tests/performance/ -- --reporter=verbose

Found: GET /api/global/data - 892ms (target: <400ms) - REGRESSION!
       Baseline: 250ms | Current: 892ms | +256% slower

Fix options:
1. Optimize queries (add indexes, reduce joins, use LIMIT)
2. Add caching (server-side or HTTP Cache-Control headers)
3. Reduce data payload (return only what's needed)
4. Use parallel queries with Promise.all()
5. If regression is intentional, update baseline with justification

Baseline location: tests/performance/baselines.ts

# Check for inline styles instead of CSS Modules
git diff HEAD -- 'src/**/*.tsx' | grep -E "style=\{\{"

# Check for new components without .module.css
git diff --name-only HEAD | grep "src/components/.*\.tsx$" | while read file; do
  module_file="${file%.tsx}.module.css"
  [ ! -f "$module_file" ] && echo "Missing: $module_file for $file"
done

# Check CSS imports (should be .module.css)
git diff HEAD -- 'src/**/*.tsx' | grep "import.*\.css" | grep -v "\.module\.css"

# Check for missing withAuth/withAdmin wrappers
git diff HEAD -- 'app/api/**/*.ts' | grep -E "export const (GET|POST|PATCH|DELETE)" -B 1 | grep -v "withAuth\|withAdmin\|export"

# Check for direct NextResponse instead of helpers
git diff HEAD -- 'app/api/**/*.ts' | grep "NextResponse\.json" | grep -v "jsonResponse\|errorResponse\|import"

# Check for missing project ownership verification
git diff HEAD -- 'app/api/projects/\[id\]/**/*.ts' | grep "export const" -A 10 | grep -v "user_id = \$2\|projects WHERE.*user_id"

export const POST = withAuth(async (request, { user, params }) => {
  const body = await request.json();
  const validation = createSchema.safeParse(body);
  if (!validation.success) {
    return errorResponse(validation.error.errors[0].message);
  }
  // ... implementation
  return jsonResponse({ item }, 201);
});

# Check for raw pg Pool usage instead of query helpers
git diff HEAD -- 'app/api/**/*.ts' 'lib/**/*.ts' | grep -E "Pool|Client|pg\." | grep -v "import|from"

# Check for non-parameterized queries
git diff HEAD -- 'app/api/**/*.ts' 'lib/**/*.ts' | grep -E "query\(|queryOne\(" -A 1 | grep -E "^[+]" | grep -v "\$[0-9]"

# Check for snake_case conversion issues
git diff HEAD -- 'app/api/**/*.ts' | grep -E "user_id|project_id|created_at|updated_at" | grep -v "SELECT|WHERE|FROM|INSERT"

# Check component files are PascalCase
git diff --name-only HEAD | grep "src/components/.*\.tsx$" | grep -v "^[A-Z]" | grep -v "/[A-Z]"

# Check for orphaned CSS Modules
git diff --name-only HEAD | grep "\.module\.css$" | while read css; do
  component="${css%.module.css}.tsx"
  [ ! -f "$component" ] && echo "Orphaned CSS Module: $css (no matching .tsx)"
done

# Find components that are never imported anywhere else in the codebase
# For each .tsx file in src/components/, check if it's imported elsewhere

find src/components -name "*.tsx" -type f | while read component; do
  # Get the component name (filename without extension)
  name=$(basename "$component" .tsx)

  # Skip index files and test files
  if [[ "$name" == "index" ]] || [[ "$name" == *.test* ]] || [[ "$name" == *.spec* ]]; then
    continue
  fi

  # Search for imports of this component (excluding its own file)
  imports=$(grep -r "from.*['\"].*$name['\"]" --include="*.tsx" --include="*.ts" . 2>/dev/null | grep -v "$component" | grep -v "node_modules" | wc -l)

  # Also check for named imports
  named_imports=$(grep -r "import.*{.*$name.*}" --include="*.tsx" --include="*.ts" . 2>/dev/null | grep -v "$component" | grep -v "node_modules" | wc -l)

  total=$((imports + named_imports))

  if [ "$total" -eq 0 ]; then
    echo "UNUSED: $component"
  fi
done

Found: src/components/common/UnusedWidget.tsx (never imported)

Options:
1. DELETE if truly unused: rm src/components/common/UnusedWidget.tsx src/components/common/UnusedWidget.module.css
2. KEEP if planned for future use (add TODO comment explaining intent)
3. INTEGRATE if it should be used somewhere

# Find new page.tsx files without tracking imports
git diff --name-only HEAD | grep -E "app/.*page\.tsx$" | while read file; do
  if ! grep -q "trackFeatureUse\|useAnalytics\|useDemoAnalytics\|usePublicAnalytics" "$file" 2>/dev/null; then
    echo "MISSING TRACKING: $file"
  fi
done

# Check lite components for demo analytics
git diff --name-only HEAD | grep -E "src/components/lite/.*\.tsx$" | while read file; do
  if ! grep -q "useDemoAnalytics\|trackFeatureUse" "$file" 2>/dev/null; then
    echo "MISSING DEMO TRACKING: $file"
  fi
done

# Check if AnalyticsFeatures has entries not in FEATURE_CATEGORIES
# Get feature IDs from useAnalytics.ts and compare with EngagementChart.tsx

# Get feature IDs from useAnalytics.ts (values like 'quick_capture')
grep -E ":\s*'[a-z_]+'" hooks/useAnalytics.ts | sed "s/.*'\([^']*\)'.*/\1/" | sort > /tmp/analytics_features.txt

# Get feature IDs from EngagementChart.tsx
grep -E "^\s+[a-z_]+:\s*\{" src/components/admin/analytics/EngagementChart.tsx | sed "s/^\s*\([a-z_]*\):.*/\1/" | sort > /tmp/engagement_features.txt

# Find features missing from display config
comm -23 /tmp/analytics_features.txt /tmp/engagement_features.txt

# Check marketing/public pages for analytics
git diff --name-only HEAD | grep -E "app/(marketing|features|pricing|changelog)/.*\.tsx$" | while read file; do
  if ! grep -q "usePublicAnalytics\|useDemoAnalytics\|trackFeatureUse" "$file" 2>/dev/null; then
    echo "MISSING PUBLIC ANALYTICS: $file"
  fi
done

Found: New page app/features/new-feature/page.tsx without tracking

Fix for authenticated pages:
  import { useAnalytics, AnalyticsFeatures, AnalyticsActions } from '@/hooks/useAnalytics';
  const { trackFeatureUse } = useAnalytics();
  useEffect(() => { trackFeatureUse(AnalyticsFeatures.MY_FEATURE, AnalyticsActions.VIEWED); }, []);

Fix for public/marketing pages:
  import { useDemoAnalytics, DemoFeatures, DemoActions } from '@/hooks/useDemoAnalytics';
  const { trackDemoEvent } = useDemoAnalytics();
  useEffect(() => { trackDemoEvent(DemoFeatures.MARKETING_FEATURES, DemoActions.VIEWED); }, []);

Don't forget to add display config to EngagementChart.tsx:
  my_feature: { label: 'My Feature', color: '#6366f1' },

## 🔍 Verification Results

### 🔒 Security Issues [BLOCKING] - X found
- [ ] ❌ **Hardcoded Secret** in app/config.ts:23
  Found: `DATABASE_URL="postgres://user:pass@host/db"`
  Fix: Move to .env.local and use process.env.DATABASE_URL
  Auto-fix: ❌ Not available

- [ ] ❌ **SQL Injection Risk** in app/api/users/route.ts:45
  Found: query(\`SELECT * FROM users WHERE email = ${email}\`)
  Fix: query('SELECT * FROM users WHERE email = $1', [email])
  Auto-fix: ❌ Not available

- [ ] ❌ **Missing Rate Limit** in app/api/auth/login/route.ts:15
  POST /api/auth/login has no rate limiting
  Fix: Add withRateLimit(request, rateLimits.strict, 'login')
  Auto-fix: ✅ Available

### ⚠️ Best Practices [BLOCKING] - Y found
- [ ] ⚠️ **Debug Code** - 3 console.log found
  - src/components/Dashboard.tsx:45
  - src/components/Dashboard.tsx:78
  - src/components/build/BuildPanel.tsx:123
  Auto-fix: ✅ Available - will remove all

- [ ] ⚠️ **TypeScript** - 2 `: any` types found
  - src/hooks/useApi.ts:34 - Consider defining proper interface
  - app/api/projects/[id]/route.ts:67 - Define type for params
  Auto-fix: ❌ Not available

### 💡 Efficiency [OPTIMIZATION] - Z found
- [ ] 💡 **React Hook** - Inline function in onClick
  src/components/objectives/ObjectiveCard.tsx:45
  Recommendation: Extract to useCallback to prevent re-renders
  Auto-fix: ❌ Not available

### 🔧 Refactor Candidates [REFACTOR] - R found
- [ ] 🔧 **Large Component** (487 lines): src/components/Dashboard.tsx
  Recommendation: Extract sub-components (DashboardStats, DashboardActions)
  Auto-fix: ❌ Not available

- [ ] 🔧 **Very Large File** (892 lines): src/context/AppContext.tsx
  Recommendation: Extract entity hooks to separate files (useInitiatives.ts, etc.)
  Priority: HIGH
  Auto-fix: ❌ Not available

- [ ] 🔧 **Many Functions** (14 functions): lib/api-utils.ts
  Recommendation: Group related functions into sub-modules
  Auto-fix: ❌ Not available

### 📝 Code Standards [BLOCKING] - W found
- [ ] 📝 **CSS Modules** - Inline style found
  src/components/common/Badge.tsx:12
  Found: style={{ backgroundColor: color }}
  Fix: Move to Badge.module.css
  Auto-fix: ✅ Available

- [ ] 📝 **API Pattern** - Missing Zod validation
  app/api/initiatives/[id]/route.ts:23
  POST route has no input validation
  Fix: Define updateSchema with z.object()
  Auto-fix: ❌ Not available (schema needs manual definition)

---

**Summary:**
- 🚨 3 Security Issues (BLOCKING)
- ⚠️ 5 Best Practice Issues (BLOCKING)
- 💡 1 Efficiency Issue (optimization only)
- 🔧 3 Refactor Candidates (1 HIGH priority)
- 📝 2 Code Standard Issues (BLOCKING)

**Total Blocking Issues: 10** - Must be resolved to proceed with commit
**Refactor Candidates: 3** - Not blocking, but recommended for maintainability

**Auto-fix Available:**
- ✅ Remove 3 console.logs
- ✅ Add rate limiting to auth route
- ✅ Convert inline style to CSS Module

**Actions:**
1. Type 'fix all' - Auto-fix all available issues (5 issues)
2. Type 'fix N' - Fix specific issue number N
3. Type 'show fix N' - Preview fix for issue N without applying
4. Fix blocking issues manually, then type 'verify' to re-run
5. Type 'approve override' - Override and proceed (NOT RECOMMENDED for security issues)

# Get list of files with console.logs
files=$(git diff --name-only HEAD)

# Remove console statements from each file
for file in $files; do
  if [ -f "$file" ]; then
    # Remove console.log, console.warn, console.error, console.info, console.debug
    sed -i.bak '/^\s*console\.\(log\|warn\|error\|info\|debug\)/d' "$file"

    # Remove inline console calls on same line as other code
    sed -i.bak 's/;\s*console\.\(log\|warn\|error\|info\|debug\)([^)]*);/;/g' "$file"

    # Clean up backup
    rm -f "$file.bak"
  fi
done

echo "✅ Removed all console statements"

files=$(git diff --name-only HEAD)

for file in $files; do
  if [ -f "$file" ]; then
    # Remove standalone TODO/FIXME comment lines
    sed -i.bak '/^\s*\/\/\s*\(TODO\|FIXME\|XXX\|HACK\)/d' "$file"
    rm -f "$file.bak"
  fi
done

echo "✅ Removed TODO/FIXME comments"

# Note: Only remove obvious commented code blocks (3+ lines)
# Manual review recommended for complex cases

echo "⚠️ Commented code removal requires manual review"
echo "Review and manually delete commented code blocks"

// This requires programmatic code analysis and transformation
// Not suitable for bash script - would need Edit tool with careful analysis

// Example transformation:
// Before: <div style={{ padding: '20px', color: 'red' }}>
// After:
//   - Component: <div className={styles.container}>
//   - CSS Module: .container { padding: var(--space-4); color: var(--color-danger); }

echo "⚠️ Inline style conversion requires Edit tool"
echo "Will be applied via Edit tool for each occurrence"

// Add import
import { withRateLimit, rateLimits } from '@/lib/rate-limit';

// Add check at start of route handler
export const POST = withAuth(async (request, { user }) => {
  const rateLimitResponse = withRateLimit(request, rateLimits.strict, 'unique-key');
  if (rateLimitResponse) return rateLimitResponse;

  // ... rest of handler
});

User: /verify-work

Claude: I'll verify all your changes for security, best practices, efficiency, and code standards.

[Runs Phase 1: Analyze Changed Files]

Found 8 changed files:
- 3 API routes (app/api/*)
- 4 components (src/components/*)
- 1 type definition (src/types/index.ts)

[Runs Phases 2-5: All Checks in parallel]

[Presents Phase 6: Findings Report]

## 🔍 Verification Results

### 🔒 Security Issues [BLOCKING] - 1 found
- [ ] ❌ **Missing Rate Limit** in app/api/auth/login/route.ts:15
  Auto-fix: ✅ Available

### ⚠️ Best Practices [BLOCKING] - 2 found
- [ ] ⚠️ **Debug Code** - 2 console.logs
  Auto-fix: ✅ Available

### 💡 Efficiency [OPTIMIZATION] - 0 found
✅ All hooks properly configured
✅ No obvious re-render issues

### 📝 Code Standards [BLOCKING] - 0 found
✅ All components use CSS Modules
✅ All API routes follow project patterns

---

**Summary:** 1 security + 2 best practice = 3 blocking issues

**Actions:**
1. Type 'fix all' to auto-fix all 3 issues
2. Type 'verify' to re-run after manual fixes
3. All issues have auto-fix available!

User: fix all

Claude: Applying auto-fixes...

✅ Added rate limiting to app/api/auth/login/route.ts
✅ Removed 2 console.log statements from src/components/Dashboard.tsx

All issues resolved! Re-running verification...

[Phase 6: Re-verify]

## 🔍 Verification Results

✅ **All checks passed!**

- 🔒 Security: No issues
- ⚠️ Best Practices: No issues
- 💡 Efficiency: No issues
- 📝 Code Standards: No issues

Ready to proceed with `/ship`!