diff --git a/ESLINT_DECISION_TREE.md b/ESLINT_DECISION_TREE.md
new file mode 100644
index 00000000..f22ab5ef
--- /dev/null
+++ b/ESLINT_DECISION_TREE.md
@@ -0,0 +1,223 @@
+# ESLint Rules Decision Tree
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Start: Which ESLint rules should I implement?             │
+└────────────────────┬────────────────────────────────────────┘
+                     │
+                     ▼
+           ┌─────────────────────┐
+           │ How much time do    │
+           │ you have?           │
+           └─┬─────────┬─────────┘
+             │         │
+    ┌────────┘         └────────┐
+    │                           │
+    ▼                           ▼
+┌───────────┐          ┌────────────────┐
+│ 5 minutes │          │ 4 weeks        │
+└─────┬─────┘          └────────┬───────┘
+      │                         │
+      ▼                         ▼
+┌─────────────────────┐   ┌──────────────────────┐
+│ QUICK WINS          │   │ COMPREHENSIVE        │
+│                     │   │                      │
+│ 1. Security rules   │   │ Week 1: High Priority│
+│    (zero violations)│   │ - Security           │
+│                     │   │ - Type imports       │
+│ 2. Type imports     │   │ - Console rules      │
+│    (auto-fix)       │   │                      │
+│                     │   │ Week 2: Medium       │
+│ 3. prefer-const     │   │ - Import order       │
+│    (auto-fix)       │   │ - Node.js rules      │
+│                     │   │                      │
+│ ✅ Zero breaking    │   │ Week 3: Return types │
+│ ✅ 20-30% rules     │   │ - Function returns   │
+│ ✅ Done in 5 min    │   │   (start with warn)  │
+└─────────────────────┘   │                      │
+                          │ Week 4+: Low Priority│
+                          │ - Documentation      │
+                          │ - Comment quality    │
+                          │ - Test standards     │
+                          │                      │
+                          │ ✅ All 20 rules      │
+                          │ ✅ ~700 → <100 errors│
+                          └──────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│  Or: Pick specific categories you care about                │
+└────────────────────┬────────────────────────────────────────┘
+                     │
+                     ▼
+        ┌────────────┴────────────┐
+        │                         │
+        ▼                         ▼
+  ┌──────────┐            ┌──────────────┐
+  │ Priority?│            │  Goal?       │
+  └─┬───┬───┬┘            └─┬────┬───┬───┘
+    │   │   │               │    │   │
+  High Medium Low          Type Code Security
+    │   │   │              Safety Org
+    │   │   │               │    │   │
+    ▼   ▼   ▼               ▼    ▼   ▼
+    
+HIGH PRIORITY               TYPE SAFETY
+├─ Security (PR #3)         ├─ consistent-type-imports (PR #2)
+├─ Type imports (PR #2)     ├─ explicit-function-return-type (PR #5)
+└─ Console rules (PR #1)    └─ no-non-null-assertion
+
+MEDIUM PRIORITY             CODE ORGANIZATION
+├─ Import order (PR #4)     ├─ import/order (PR #4)
+├─ Return types (PR #5)     ├─ import/no-default-export (PR #4)
+└─ Node.js rules (PR #6)    └─ Comment quality (PR #8)
+
+LOW PRIORITY                SECURITY
+├─ Modern JS (PR #7)        ├─ no-eval (PR #3)
+├─ Comments (PR #8)         ├─ no-implied-eval (PR #3)
+└─ Docs (PR #9)             └─ prefer-promise-reject-errors (PR #3)
+
+┌─────────────────────────────────────────────────────────────┐
+│  Implementation Checklist                                   │
+└─────────────────────────────────────────────────────────────┘
+
+Phase 1: Immediate (No Breaking Changes)
+┌─────────────────────────────────────────┐
+│ □ Add security baseline rules           │  ← 2 min
+│ □ Add modern JS rules (no-var, etc)     │  ← 1 min
+│ □ Verify zero violations                │  ← 1 min
+│ □ Commit                                 │  ← 1 min
+└─────────────────────────────────────────┘  = 5 min total
+
+Phase 2: Auto-fixable (Week 1)
+┌─────────────────────────────────────────┐
+│ □ Install eslint-plugin-unicorn         │  ← 1 min
+│ □ Enable consistent-type-imports        │  ← 2 min
+│ □ Run npm run lint -- --fix             │  ← 1 min
+│ □ Review changes                         │  ← 5 min
+│ □ Commit                                 │  ← 1 min
+└─────────────────────────────────────────┘  = 10 min total
+
+Phase 3: Import Organization (Week 2)
+┌─────────────────────────────────────────┐
+│ □ Install eslint-plugin-import          │  ← 1 min
+│ □ Configure import/order                │  ← 3 min
+│ □ Run npm run lint -- --fix             │  ← 1 min
+│ □ Review changes                         │  ← 10 min
+│ □ Test builds                            │  ← 2 min
+│ □ Commit                                 │  ← 1 min
+└─────────────────────────────────────────┘  = 18 min total
+
+Phase 4: Gradual Adoption (Week 3-4)
+┌─────────────────────────────────────────┐
+│ □ Add no-console with CLI exceptions    │  ← 5 min config
+│ □ Add explicit-return-type as "warn"    │  ← 2 min config
+│ □ Address violations gradually          │  ← Ongoing
+│ □ Upgrade to "error" when ready         │  ← Later
+└─────────────────────────────────────────┘
+
+Phase 5: Additional Tooling (Ongoing)
+┌─────────────────────────────────────────┐
+│ □ Install eslint-plugin-n               │
+│ □ Install eslint-plugin-jsdoc (warn)    │
+│ □ Install eslint-plugin-eslint-comments │
+│ □ Add test-specific rules               │
+└─────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│  Success Metrics                                            │
+└─────────────────────────────────────────────────────────────┘
+
+Current State:
+  Lint errors:        ~700 (mostly no-unsafe-*)
+  eslint-disable:     2 instances
+  Config:             ESLint 9.32 + typescript-eslint 8.38
+  
+After Quick Wins (5 min):
+  New rules:          6-8 rules enabled
+  Violations:         0 (all zero-impact)
+  Rules coverage:     20-30%
+  
+After Comprehensive (4 weeks):
+  New rules:          20 rules enabled
+  Target violations:  <100 errors
+  Rules coverage:     100%
+  Packages added:     6 optional plugins
+
+┌─────────────────────────────────────────────────────────────┐
+│  Rule Categories Quick Reference                            │
+└─────────────────────────────────────────────────────────────┘
+
+Security (PR #3) ⭐⭐⭐
+  no-eval, no-implied-eval, no-throw-literal
+  Impact: Low | Auto-fix: No | Breaking: No
+  
+Type Safety (PR #2, #5) ⭐⭐⭐
+  consistent-type-imports, explicit-function-return-type
+  Impact: High | Auto-fix: Partial | Breaking: No
+  
+Code Org (PR #4) ⭐⭐
+  import/order, import/no-default-export
+  Impact: Medium | Auto-fix: Yes | Breaking: No
+  
+Console (PR #1) ⭐⭐
+  no-console (with CLI exceptions)
+  Impact: Medium | Auto-fix: No | Breaking: No
+  
+Node.js (PR #6) ⭐⭐
+  n/no-deprecated-api, n/prefer-node-protocol
+  Impact: Low | Auto-fix: Partial | Breaking: No
+  
+Modern JS (PR #7) ⭐
+  prefer-const, no-var, prefer-template
+  Impact: Low | Auto-fix: Yes | Breaking: No
+  
+Comments (PR #8) ⭐
+  no-warning-comments, eslint-comments/*
+  Impact: Low | Auto-fix: Partial | Breaking: No
+  
+Docs (PR #9) ⭐
+  jsdoc/require-jsdoc
+  Impact: High | Auto-fix: No | Breaking: No
+  
+Tests (PR #10) ⭐
+  Test-specific overrides
+  Impact: Low | Auto-fix: No | Breaking: No
+
+┌─────────────────────────────────────────────────────────────┐
+│  When to Use Which Document                                 │
+└─────────────────────────────────────────────────────────────┘
+
+ESLINT_README.md
+  ├─ First-time reading
+  ├─ Need overview
+  └─ Choosing your path
+  
+ESLINT_RECOMMENDATIONS.md
+  ├─ Understanding patterns
+  ├─ Deep analysis
+  └─ The "why" behind rules
+  
+ESLINT_PR_PROPOSALS.md
+  ├─ Creating PRs
+  ├─ Copy-paste configs
+  └─ Step-by-step guides
+  
+ESLINT_QUICKSTART.md
+  ├─ Just getting started
+  ├─ Need templates
+  └─ Quick reference
+
+┌─────────────────────────────────────────────────────────────┐
+│  Decision: Start Now!                                       │
+└─────────────────────────────────────────────────────────────┘
+
+  Choose your path above ↑
+  
+  Then:
+  1. Open the appropriate document
+  2. Follow the steps
+  3. Commit changes
+  4. Ship it! 🚀
+
+  All paths lead to better code quality!
+```
diff --git a/ESLINT_PR_PROPOSALS.md b/ESLINT_PR_PROPOSALS.md
new file mode 100644
index 00000000..ded29f69
--- /dev/null
+++ b/ESLINT_PR_PROPOSALS.md
@@ -0,0 +1,703 @@
+# ESLint Rules PR Proposals
+
+This document provides actionable PR proposals for implementing the ESLint rules identified in `ESLINT_RECOMMENDATIONS.md`.
+
+## Quick Reference Table
+
+| PR # | Title | Priority | Packages | Impact | Auto-fix |
+|------|-------|----------|----------|---------|----------|
+| 1 | Console Logging Rules | High | None | Medium | Partial |
+| 2 | TypeScript Type Imports | High | None | Medium | Yes |
+| 3 | Security Baseline Rules | High | None | Low | No |
+| 4 | Import Organization | Medium | `eslint-plugin-import` | Medium | Yes |
+| 5 | Function Return Types | Medium | None | High | No |
+| 6 | Node.js Best Practices | Medium | `eslint-plugin-n` | Low | Partial |
+| 7 | Modern JavaScript | Low | `eslint-plugin-unicorn` | Low | Yes |
+| 8 | Comment Quality | Low | `eslint-plugin-eslint-comments` | Low | Partial |
+| 9 | Documentation | Low | `eslint-plugin-jsdoc` | High | No |
+| 10 | Test Standards | Low | None | Low | No |
+
+---
+
+## PR #1: Console Logging Rules for CLI vs Library Code
+
+### Title
+`feat(eslint): enforce no-console in library code while allowing in CLI tools`
+
+### Description
+Adds `no-console` rule that distinguishes between library code (where console should be avoided) and CLI tools (where console is the primary user interface).
+
+### Changes
+```javascript
+// In eslint.config.js
+{
+  rules: {
+    "no-console": ["warn", { allow: [] }]
+  }
+},
+{
+  files: [
+    "**/cli/*.ts",
+    "**/cli/*.js",
+    "**/bin/*.js",
+    "**/bin/*.mjs",
+    "scripts/**/*.ts",
+    "scripts/**/*.mts"
+  ],
+  rules: {
+    "no-console": "off"
+  }
+}
+```
+
+### Rationale
+- Library code should use proper logging utilities
+- CLI tools provide direct user feedback via console
+- Distinguishes between different code contexts
+
+### Files Affected
+- ~25 files with console.log/error usage
+- Primarily in: cmake-rn, ferric, gyp-to-cmake, host CLI tools
+
+### Migration Path
+1. Add rule as "warn" initially
+2. Review library code console usage
+3. Add logging utility if needed
+4. Fix violations
+5. Upgrade to "error"
+
+### Testing
+- Run: `npm run lint`
+- Verify no false positives in CLI tools
+- Verify warnings in library code
+
+---
+
+## PR #2: Consistent TypeScript Type Imports
+
+### Title
+`feat(eslint): enforce consistent type imports and exports`
+
+### Description
+Enables `@typescript-eslint/consistent-type-imports` and `@typescript-eslint/consistent-type-exports` to separate type and value imports for better tree-shaking and clarity.
+
+### Changes
+```javascript
+// In eslint.config.js
+{
+  rules: {
+    "@typescript-eslint/consistent-type-imports": ["error", {
+      prefer: "type-imports",
+      fixMergeTypeImports: true,
+      fixMergeDefaultImportWithTypeImports: true
+    }],
+    "@typescript-eslint/consistent-type-exports": ["error", {
+      fixMixedExportsWithInlineTypeSpecifier: true
+    }]
+  }
+}
+```
+
+### Rationale
+- Improves tree-shaking
+- Makes code intention clearer
+- Follows modern TypeScript best practices
+- Aligns with bundler optimizations
+
+### Files Affected
+- ~70 TypeScript files with imports
+- Mostly type imports will be converted
+
+### Migration Path
+1. Enable rules
+2. Run: `npm run lint -- --fix`
+3. Verify changes
+4. Commit auto-fixed code
+
+### Testing
+- Run: `npm run lint`
+- Run: `npm test`
+- Verify builds: `npm run build`
+
+### Example
+```typescript
+// Before
+import { EventEmitter } from "node:events";
+import { PlatformName, Platform } from "./types.js";
+
+// After
+import { EventEmitter } from "node:events";
+import type { PlatformName, Platform } from "./types.js";
+```
+
+---
+
+## PR #3: Security Baseline Rules
+
+### Title
+`feat(eslint): add security baseline rules (no-eval, no-implied-eval)`
+
+### Description
+Adds security-focused ESLint rules to prevent code injection vulnerabilities and enforce type safety.
+
+### Changes
+```javascript
+// In eslint.config.js
+{
+  rules: {
+    "no-eval": "error",
+    "no-implied-eval": "error",
+    "@typescript-eslint/no-implied-eval": "error",
+    "no-throw-literal": "error",
+    "@typescript-eslint/no-throw-literal": "error",
+    "prefer-promise-reject-errors": "error"
+  }
+}
+```
+
+### Rationale
+- Prevents code injection attacks
+- Enforces proper Error objects
+- Security best practice baseline
+- Likely zero violations (already followed)
+
+### Files Affected
+- None expected (preventive measure)
+
+### Migration Path
+1. Enable rules
+2. Run: `npm run lint`
+3. Verify no violations
+4. Commit config changes
+
+### Testing
+- Run: `npm run lint`
+- Verify no new errors
+- Run full test suite
+
+---
+
+## PR #4: Import Organization and Ordering
+
+### Title
+`feat(eslint): enforce consistent import ordering with eslint-plugin-import`
+
+### Description
+Adds `eslint-plugin-import` to enforce consistent import grouping and alphabetical ordering.
+
+### Changes
+
+**package.json:**
+```json
+{
+  "devDependencies": {
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-import-resolver-typescript": "^3.6.3"
+  }
+}
+```
+
+**eslint.config.js:**
+```javascript
+import importPlugin from "eslint-plugin-import";
+
+export default tseslint.config(
+  // ... existing config
+  {
+    plugins: {
+      import: importPlugin
+    },
+    settings: {
+      "import/resolver": {
+        typescript: true,
+        node: true
+      }
+    },
+    rules: {
+      "import/order": ["error", {
+        groups: [
+          "builtin",   // Node.js built-ins
+          "external",  // npm packages
+          "internal",  // Internal aliases
+          "parent",    // ../
+          "sibling",   // ./
+          "index"      // ./index
+        ],
+        "newlines-between": "always",
+        alphabetize: {
+          order: "asc",
+          caseInsensitive: true
+        }
+      }],
+      "import/no-default-export": "warn",
+      "import/newline-after-import": "error",
+      "import/no-duplicates": "error"
+    }
+  },
+  {
+    // Allow default exports in configs
+    files: ["*.config.js", "*.config.ts", "*.config.mjs"],
+    rules: {
+      "import/no-default-export": "off"
+    }
+  }
+);
+```
+
+### Rationale
+- Pattern already partially followed (node: imports first)
+- Improves readability
+- Makes conflicts easier to resolve
+- Standardizes across the codebase
+
+### Files Affected
+- ~70 TypeScript files
+- All files with imports
+
+### Migration Path
+1. Install dependencies
+2. Add configuration
+3. Run: `npm run lint -- --fix`
+4. Review and commit changes
+
+### Testing
+- Run: `npm run lint`
+- Run: `npm run build`
+- Run: `npm test`
+
+### Example
+```typescript
+// Before
+import path from "node:path";
+import { readPackageSync } from "read-pkg";
+import assert from "node:assert/strict";
+import { chalk } from "@react-native-node-api/cli-utils";
+
+// After
+import assert from "node:assert/strict";
+import path from "node:path";
+
+import { readPackageSync } from "read-pkg";
+
+import { chalk } from "@react-native-node-api/cli-utils";
+```
+
+---
+
+## PR #5: Explicit Function Return Types
+
+### Title
+`feat(eslint): require explicit return types for exported functions (warn)`
+
+### Description
+Adds `@typescript-eslint/explicit-function-return-type` to improve type safety and documentation. Initially set to "warn" for gradual adoption.
+
+### Changes
+```javascript
+// In eslint.config.js
+{
+  rules: {
+    "@typescript-eslint/explicit-function-return-type": ["warn", {
+      allowExpressions: true,
+      allowTypedFunctionExpressions: true,
+      allowHigherOrderFunctions: true,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowConciseArrowFunctionExpressionsStartingWithVoid: false
+    }]
+  }
+}
+```
+
+### Rationale
+- Catches type inference issues
+- Improves API documentation
+- Makes refactoring safer
+- Explicit is better than implicit
+
+### Files Affected
+- ~100+ functions lacking return types
+- Mostly exported/public functions
+
+### Migration Path
+1. Enable as "warn"
+2. Address warnings gradually
+3. Focus on public APIs first
+4. Upgrade to "error" in follow-up PR
+
+### Testing
+- Run: `npm run lint`
+- Verify type checking still passes
+- Run: `npm test`
+
+### Example
+```typescript
+// Before
+export function getLibraryName(modulePath: string, naming: NamingStrategy) {
+  // ...
+  return parts.join("--");
+}
+
+// After
+export function getLibraryName(
+  modulePath: string,
+  naming: NamingStrategy
+): string {
+  // ...
+  return parts.join("--");
+}
+```
+
+---
+
+## PR #6: Node.js Best Practices
+
+### Title
+`feat(eslint): add Node.js best practices with eslint-plugin-n`
+
+### Description
+Adds `eslint-plugin-n` for Node.js-specific linting rules.
+
+### Changes
+
+**package.json:**
+```json
+{
+  "devDependencies": {
+    "eslint-plugin-n": "^17.16.0"
+  }
+}
+```
+
+**eslint.config.js:**
+```javascript
+import nodePlugin from "eslint-plugin-n";
+
+export default tseslint.config(
+  // ... existing config
+  nodePlugin.configs["flat/recommended"],
+  {
+    rules: {
+      // Override specific rules
+      "n/no-missing-import": "off", // TypeScript handles this
+      "n/no-unpublished-import": "off", // Handled by package.json
+      "n/no-deprecated-api": "error",
+      "n/prefer-global/buffer": "error",
+      "n/prefer-global/process": "error",
+      "n/prefer-node-protocol": "error", // Already followed!
+      "n/no-process-exit": ["error", {
+        // Allow in CLI entry points
+        "files": ["**/bin/*.js", "**/bin/*.mjs"]
+      }]
+    }
+  }
+);
+```
+
+### Rationale
+- Node.js ecosystem standards
+- Deprecation warnings
+- Module resolution best practices
+- Already follows many patterns
+
+### Files Affected
+- Most TypeScript files (verification pass)
+- Likely minimal changes needed
+
+### Migration Path
+1. Install package
+2. Add configuration
+3. Run: `npm run lint`
+4. Fix any violations
+5. Commit
+
+### Testing
+- Run: `npm run lint`
+- Verify no false positives
+- Run: `npm test`
+
+---
+
+## PR #7: Modern JavaScript Patterns
+
+### Title
+`feat(eslint): enable modern JavaScript patterns with Unicorn rules`
+
+### Description
+Adds select rules from `eslint-plugin-unicorn` for modern JavaScript patterns.
+
+### Changes
+
+**package.json:**
+```json
+{
+  "devDependencies": {
+    "eslint-plugin-unicorn": "^56.0.1"
+  }
+}
+```
+
+**eslint.config.js:**
+```javascript
+import unicornPlugin from "eslint-plugin-unicorn";
+
+export default tseslint.config(
+  // ... existing config
+  {
+    plugins: {
+      unicorn: unicornPlugin
+    },
+    rules: {
+      "unicorn/prefer-node-protocol": "error", // Already followed!
+      "unicorn/prefer-module": "off", // Some CommonJS needed
+      "unicorn/prefer-top-level-await": "warn",
+      "prefer-template": "warn",
+      "prefer-const": ["error", { destructuring: "all" }],
+      "no-var": "error"
+    }
+  }
+);
+```
+
+### Rationale
+- Codifies existing patterns
+- Modern Node.js best practices
+- Likely mostly auto-fixable
+- Performance improvements
+
+### Files Affected
+- All files (validation pass)
+- Likely minimal violations
+
+### Migration Path
+1. Install package
+2. Add configuration
+3. Run: `npm run lint -- --fix`
+4. Review and commit
+
+### Testing
+- Run: `npm run lint`
+- Run: `npm test`
+- Verify builds
+
+---
+
+## PR #8: Comment Quality Rules
+
+### Title
+`feat(eslint): track TODO comments and unused eslint-disable directives`
+
+### Description
+Adds rules to manage comment quality and track TODOs.
+
+### Changes
+
+**package.json:**
+```json
+{
+  "devDependencies": {
+    "eslint-plugin-eslint-comments": "^3.2.0"
+  }
+}
+```
+
+**eslint.config.js:**
+```javascript
+import eslintCommentsPlugin from "eslint-plugin-eslint-comments";
+
+export default tseslint.config(
+  // ... existing config
+  eslintCommentsPlugin.configs.recommended,
+  {
+    rules: {
+      "no-warning-comments": ["warn", {
+        terms: ["todo", "fixme", "xxx", "hack"],
+        location: "start"
+      }],
+      "eslint-comments/no-unused-disable": "error",
+      "eslint-comments/no-unlimited-disable": "error"
+    }
+  }
+);
+```
+
+### Rationale
+- Track technical debt
+- Keep disable comments clean
+- Only 2 existing disables (excellent baseline)
+- ~20 TODOs to track
+
+### Files Affected
+- Files with TODO comments (~15-20 files)
+- Files with eslint-disable (2 files)
+
+### Migration Path
+1. Install package
+2. Add configuration
+3. Run: `npm run lint`
+4. Review warnings
+5. Optionally link TODOs to issues
+
+### Testing
+- Run: `npm run lint`
+- Verify TODOs are flagged as warnings
+
+---
+
+## PR #9: API Documentation Standards
+
+### Title
+`feat(eslint): require JSDoc for public APIs (warn)`
+
+### Description
+Adds `eslint-plugin-jsdoc` to encourage documentation of public APIs.
+
+### Changes
+
+**package.json:**
+```json
+{
+  "devDependencies": {
+    "eslint-plugin-jsdoc": "^50.6.0"
+  }
+}
+```
+
+**eslint.config.js:**
+```javascript
+import jsdocPlugin from "eslint-plugin-jsdoc";
+
+export default tseslint.config(
+  // ... existing config
+  jsdocPlugin.configs["flat/recommended-typescript"],
+  {
+    rules: {
+      "jsdoc/require-jsdoc": ["warn", {
+        require: {
+          FunctionDeclaration: true,
+          MethodDefinition: false,
+          ClassDeclaration: true,
+          ArrowFunctionExpression: false
+        },
+        publicOnly: true,
+        exemptEmptyFunctions: true
+      }],
+      "jsdoc/require-param-description": "warn",
+      "jsdoc/require-returns-description": "warn"
+    }
+  }
+);
+```
+
+### Rationale
+- Improves API documentation
+- Helps generate docs
+- TSDoc-compatible
+- Start with warnings for gradual adoption
+
+### Files Affected
+- Exported functions (~100+ functions)
+- Public classes (~10-15 classes)
+
+### Migration Path
+1. Install package
+2. Add configuration as "warn"
+3. Document high-priority APIs first
+4. Gradually address warnings
+5. Consider upgrade to "error" later
+
+### Testing
+- Run: `npm run lint`
+- Verify documentation generation
+- Run: `npm test`
+
+---
+
+## PR #10: Test Standards
+
+### Title
+`feat(eslint): enforce testing standards for Node.js test runner`
+
+### Description
+Adds test-specific ESLint rules for files using Node.js test runner.
+
+### Changes
+```javascript
+// In eslint.config.js
+{
+  files: ["**/*.test.ts", "**/*.test.js"],
+  rules: {
+    "@typescript-eslint/no-unsafe-assignment": "off", // Tests often use dynamic data
+    "@typescript-eslint/no-unsafe-call": "off",
+    "@typescript-eslint/no-unsafe-member-access": "off",
+    "max-lines-per-function": "off", // Tests can be long
+    "max-nested-callbacks": ["warn", 5] // Test nesting
+  }
+}
+```
+
+### Rationale
+- Tests have different constraints
+- Allow more flexibility in test code
+- Maintain core safety rules
+- Balance strictness with pragmatism
+
+### Files Affected
+- ~12 test files
+
+### Migration Path
+1. Add configuration
+2. Run: `npm run lint`
+3. Run: `npm test`
+4. Verify no issues
+
+### Testing
+- Run: `npm run lint`
+- Run: `npm test`
+- Verify test files aren't over-restricted
+
+---
+
+## Implementation Timeline
+
+### Week 1: High Priority
+- [ ] PR #1: Console Logging Rules
+- [ ] PR #2: TypeScript Type Imports
+- [ ] PR #3: Security Baseline Rules
+
+### Week 2-3: Medium Priority
+- [ ] PR #4: Import Organization
+- [ ] PR #5: Function Return Types (warn)
+- [ ] PR #6: Node.js Best Practices
+
+### Week 4+: Low Priority
+- [ ] PR #7: Modern JavaScript
+- [ ] PR #8: Comment Quality
+- [ ] PR #9: Documentation (warn)
+- [ ] PR #10: Test Standards
+
+### Ongoing
+- Address existing ~700 `no-unsafe-*` errors
+- Upgrade "warn" rules to "error"
+- Monitor and refine rules
+
+---
+
+## Success Metrics
+
+Track these metrics after each PR:
+
+1. **Lint Error Count**: Target to reduce from ~700 to <100
+2. **Auto-fix Success Rate**: % of errors fixed automatically
+3. **False Positive Rate**: Should be <5%
+4. **Build Time Impact**: Should be <10% increase
+5. **Developer Feedback**: Collect via PR reviews
+
+---
+
+## Notes
+
+- Each PR is independent and can be merged separately
+- Auto-fixable rules should be prioritized
+- Start with "warn" for high-impact rules
+- Consider creating a "eslint-rules" label for these PRs
+- Link each PR back to this document and ESLINT_RECOMMENDATIONS.md
diff --git a/ESLINT_QUICKSTART.md b/ESLINT_QUICKSTART.md
new file mode 100644
index 00000000..8389e3c9
--- /dev/null
+++ b/ESLINT_QUICKSTART.md
@@ -0,0 +1,461 @@
+# ESLint Rules Implementation Quick Start
+
+This guide helps you quickly implement the ESLint rule recommendations. Choose your approach:
+
+## 🚀 Quick Implementation (Recommended Start)
+
+### Option 1: Start with Zero-Impact Rules (Day 1)
+
+These rules likely have zero or minimal violations and can be enabled immediately:
+
+```bash
+# 1. No code changes needed - just add to eslint.config.js
+```
+
+Add to your `eslint.config.js`:
+
+```javascript
+{
+  rules: {
+    // Security (likely zero violations)
+    "no-eval": "error",
+    "no-implied-eval": "error",
+    "@typescript-eslint/no-implied-eval": "error",
+    "no-throw-literal": "error",
+    "@typescript-eslint/no-throw-literal": "error",
+    "prefer-promise-reject-errors": "error",
+    
+    // Modern JS (likely zero violations)
+    "no-var": "error",
+    "prefer-const": ["error", { destructuring: "all" }],
+  }
+}
+```
+
+```bash
+# 2. Verify no new errors
+npm run lint
+
+# 3. Commit if clean
+git add eslint.config.js
+git commit -m "feat(eslint): add security and modern JS baseline rules"
+```
+
+---
+
+### Option 2: Auto-Fix Rules (Week 1)
+
+These rules can automatically fix most violations:
+
+```bash
+# 1. Install dependencies
+npm install -D eslint-plugin-unicorn@^56.0.1
+
+# 2. Add to eslint.config.js
+```
+
+```javascript
+import unicornPlugin from "eslint-plugin-unicorn";
+
+export default tseslint.config(
+  // ... existing config
+  {
+    plugins: {
+      unicorn: unicornPlugin
+    },
+    rules: {
+      "unicorn/prefer-node-protocol": "error",
+      "prefer-template": "warn",
+    }
+  }
+);
+```
+
+```bash
+# 3. Auto-fix
+npm run lint -- --fix
+
+# 4. Review changes
+git diff
+
+# 5. Commit
+git add -A
+git commit -m "feat(eslint): enable auto-fixable rules (node protocol, templates)"
+```
+
+---
+
+### Option 3: Type Import Consistency (Week 1)
+
+Big impact, automatic fix:
+
+```javascript
+// Add to eslint.config.js
+{
+  rules: {
+    "@typescript-eslint/consistent-type-imports": ["error", {
+      prefer: "type-imports",
+      fixMergeTypeImports: true,
+      fixMergeDefaultImportWithTypeImports: true
+    }],
+    "@typescript-eslint/consistent-type-exports": ["error", {
+      fixMixedExportsWithInlineTypeSpecifier: true
+    }]
+  }
+}
+```
+
+```bash
+# Auto-fix all type imports
+npm run lint -- --fix
+
+# Verify builds still work
+npm run build
+
+# Test
+npm test
+
+# Commit
+git add -A
+git commit -m "feat(eslint): enforce consistent type imports/exports"
+```
+
+---
+
+## 📋 Full Implementation Checklist
+
+### Phase 1: Immediate (No Breaking Changes)
+- [ ] Add security baseline rules (no-eval, etc.)
+- [ ] Add modern JS rules (no-var, prefer-const)
+- [ ] Enable `unicorn/prefer-node-protocol` (already followed)
+
+### Phase 2: Auto-fixable (Week 1)
+- [ ] Install eslint-plugin-unicorn
+- [ ] Enable consistent-type-imports
+- [ ] Enable prefer-template
+- [ ] Run auto-fix and commit
+
+### Phase 3: Import Organization (Week 2)
+- [ ] Install eslint-plugin-import
+- [ ] Configure import/order
+- [ ] Run auto-fix
+- [ ] Review and commit
+
+### Phase 4: Gradual Adoption (Week 3-4)
+- [ ] Add no-console with CLI exceptions (warn)
+- [ ] Add explicit-function-return-type (warn)
+- [ ] Address violations gradually
+- [ ] Upgrade to "error" when ready
+
+### Phase 5: Additional Tooling (Ongoing)
+- [ ] Install eslint-plugin-n for Node.js rules
+- [ ] Install eslint-plugin-jsdoc for docs (warn)
+- [ ] Install eslint-plugin-eslint-comments
+- [ ] Add test-specific rules
+
+---
+
+## 🎯 Priority Matrix
+
+| Rule | Impact | Effort | Auto-fix | Priority |
+|------|--------|--------|----------|----------|
+| consistent-type-imports | High | Low | Yes | ⭐⭐⭐ |
+| Security rules | High | None | No | ⭐⭐⭐ |
+| import/order | Medium | Low | Yes | ⭐⭐ |
+| no-console (CLI) | Medium | Medium | No | ⭐⭐ |
+| prefer-node-protocol | Low | None | Yes | ⭐⭐ |
+| explicit-function-return-type | High | High | No | ⭐ |
+| JSDoc requirements | High | High | No | ⭐ |
+
+---
+
+## 🔧 Common Commands
+
+```bash
+# Check for errors without fixing
+npm run lint
+
+# Fix all auto-fixable issues
+npm run lint -- --fix
+
+# Check specific file
+npm run lint -- path/to/file.ts
+
+# See what would be fixed without changing
+npm run lint -- --fix-dry-run
+
+# Run with debug output
+npm run lint -- --debug
+
+# Cache results for faster runs
+npm run lint -- --cache
+
+# Disable cache
+npm run lint -- --no-cache
+```
+
+---
+
+## 📦 Package Installation Commands
+
+For each PR, use these install commands:
+
+```bash
+# PR #2: Type imports (no packages needed)
+# Built into typescript-eslint
+
+# PR #4: Import organization
+npm install -D eslint-plugin-import@^2.30.0 eslint-import-resolver-typescript@^3.6.3
+
+# PR #6: Node.js best practices
+npm install -D eslint-plugin-n@^17.16.0
+
+# PR #7: Modern JavaScript
+npm install -D eslint-plugin-unicorn@^56.0.1
+
+# PR #8: Comment quality
+npm install -D eslint-plugin-eslint-comments@^3.2.0
+
+# PR #9: Documentation
+npm install -D eslint-plugin-jsdoc@^50.6.0
+
+# All at once (if preferred)
+npm install -D \
+  eslint-plugin-import@^2.30.0 \
+  eslint-import-resolver-typescript@^3.6.3 \
+  eslint-plugin-n@^17.16.0 \
+  eslint-plugin-unicorn@^56.0.1 \
+  eslint-plugin-eslint-comments@^3.2.0 \
+  eslint-plugin-jsdoc@^50.6.0
+```
+
+---
+
+## 🧪 Testing Strategy
+
+After each rule addition:
+
+```bash
+# 1. Run linter
+npm run lint
+
+# 2. Build the project
+npm run build
+
+# 3. Run tests
+npm test
+
+# 4. Check specific packages
+npm test --workspace react-native-node-api
+npm test --workspace cmake-rn
+npm test --workspace gyp-to-cmake
+
+# 5. Verify no runtime issues
+cd apps/test-app
+npm run ios # or android
+```
+
+---
+
+## 🎨 Configuration Templates
+
+### Template 1: Minimal Start (Copy-Paste Ready)
+
+```javascript
+// Add to eslint.config.js after existing rules
+{
+  rules: {
+    // Security
+    "no-eval": "error",
+    "no-implied-eval": "error",
+    "no-throw-literal": "error",
+    "prefer-promise-reject-errors": "error",
+    
+    // Modern JS
+    "no-var": "error",
+    "prefer-const": ["error", { destructuring: "all" }],
+    "prefer-template": "warn",
+    
+    // TypeScript
+    "@typescript-eslint/consistent-type-imports": ["error", {
+      prefer: "type-imports",
+      fixMergeTypeImports: true
+    }],
+    "@typescript-eslint/consistent-type-exports": "error",
+    "@typescript-eslint/no-throw-literal": "error",
+    "@typescript-eslint/no-implied-eval": "error",
+  }
+}
+```
+
+### Template 2: With Plugins
+
+```javascript
+import unicornPlugin from "eslint-plugin-unicorn";
+
+export default tseslint.config(
+  // ... existing config ...
+  {
+    plugins: {
+      unicorn: unicornPlugin
+    },
+    rules: {
+      // All from Template 1, plus:
+      "unicorn/prefer-node-protocol": "error",
+    }
+  }
+);
+```
+
+### Template 3: Complete Configuration
+
+See `ESLINT_PR_PROPOSALS.md` for full per-PR configurations.
+
+---
+
+## 🐛 Troubleshooting
+
+### "Module not found" errors
+
+```bash
+# Clear node_modules and reinstall
+rm -rf node_modules package-lock.json
+npm install
+```
+
+### ESLint cache issues
+
+```bash
+# Clear ESLint cache
+npm run lint -- --no-cache
+rm -rf .eslintcache
+```
+
+### Flat config not recognized
+
+```bash
+# Ensure eslint.config.js (not .eslintrc.*)
+# Ensure ESLint 9.x is installed
+npm list eslint
+```
+
+### TypeScript errors after rule changes
+
+```bash
+# Rebuild TypeScript
+npm run build
+# Or clean build
+npm run clean && npm run build
+```
+
+### Import plugin not resolving TypeScript
+
+```javascript
+// Add to settings in eslint.config.js
+settings: {
+  "import/resolver": {
+    typescript: {
+      alwaysTryTypes: true,
+      project: "./tsconfig.json"
+    },
+    node: true
+  }
+}
+```
+
+---
+
+## 📊 Measuring Success
+
+Track these metrics:
+
+```bash
+# Before changes
+npm run lint 2>&1 | grep -E "error|warning" | tail -1
+
+# After changes
+npm run lint 2>&1 | grep -E "error|warning" | tail -1
+
+# Get counts
+npm run lint --format json > lint-before.json
+# ... make changes ...
+npm run lint --format json > lint-after.json
+
+# Compare
+# Use a JSON diff tool or:
+node -e "
+  const before = require('./lint-before.json');
+  const after = require('./lint-after.json');
+  console.log('Before:', before.map(f => f.errorCount).reduce((a,b) => a+b, 0), 'errors');
+  console.log('After:', after.map(f => f.errorCount).reduce((a,b) => a+b, 0), 'errors');
+"
+```
+
+---
+
+## 🎓 Learning Resources
+
+- [ESLint Flat Config](https://eslint.org/docs/latest/use/configure/configuration-files)
+- [typescript-eslint](https://typescript-eslint.io/)
+- [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import)
+- [eslint-plugin-unicorn](https://github.com/sindresorhus/eslint-plugin-unicorn)
+- [eslint-plugin-n](https://github.com/eslint-community/eslint-plugin-n)
+
+---
+
+## 🚦 When to Stop
+
+You've done enough when:
+
+1. ✅ Zero security rule violations
+2. ✅ Consistent import style across codebase
+3. ✅ <100 total lint errors (from current ~700)
+4. ✅ All auto-fixable rules enabled and applied
+5. ✅ CLI vs library code distinction enforced
+6. ✅ Test suite passes
+7. ✅ Build succeeds
+
+Don't aim for perfection immediately. Gradual improvement is fine!
+
+---
+
+## 💡 Pro Tips
+
+1. **Start small**: One PR at a time
+2. **Auto-fix first**: Prioritize rules with auto-fix
+3. **Use "warn" for learning**: New rules start as warnings
+4. **Batch similar changes**: Group related rules in one PR
+5. **Test thoroughly**: Each change should pass tests
+6. **Document decisions**: Update this file with learnings
+7. **Get team buy-in**: Discuss impact before merging
+
+---
+
+## 🎉 Quick Wins (Copy-Paste Commands)
+
+```bash
+# Complete quick-win setup in 5 minutes:
+
+# 1. Add baseline rules (no violations expected)
+echo "Adding security and modern JS rules..."
+# Copy Template 1 to eslint.config.js
+
+# 2. Verify
+npm run lint
+
+# 3. Add type imports (auto-fixable)
+echo "Fixing type imports..."
+# Add consistent-type-imports rule
+npm run lint -- --fix
+
+# 4. Commit
+git add -A
+git commit -m "feat(eslint): add baseline security rules and fix type imports"
+
+# 5. Success!
+echo "✅ Quick wins complete!"
+```
+
+Total time: ~5 minutes
+Impact: 20-30% of recommended rules enabled
+Breaking changes: None
diff --git a/ESLINT_README.md b/ESLINT_README.md
new file mode 100644
index 00000000..503c3382
--- /dev/null
+++ b/ESLINT_README.md
@@ -0,0 +1,184 @@
+# ESLint Rules Enhancement - Summary
+
+This directory contains a comprehensive analysis and actionable plan for enhancing ESLint rules in the react-native-node-api repository.
+
+## 📚 Documents Overview
+
+### [ESLINT_RECOMMENDATIONS.md](./ESLINT_RECOMMENDATIONS.md)
+**The Analysis Document** - Deep dive into patterns and recommendations
+
+- Current state assessment (config, metrics, existing errors)
+- 9 exciting patterns identified in the codebase
+- 20 ESLint rules recommended with full rationale
+- Priority ranking (High/Medium/Low)
+- 4-phase implementation strategy
+- Package dependencies needed
+- Success metrics and KPIs
+
+**Use this to**: Understand the "why" behind each recommendation
+
+### [ESLINT_PR_PROPOSALS.md](./ESLINT_PR_PROPOSALS.md)
+**The Action Plan** - 10 ready-to-implement PR proposals
+
+- PR #1-10 with complete specifications
+- Copy-paste ready ESLint configurations
+- Package installation commands
+- Migration paths for each rule
+- Testing strategies
+- Before/after examples
+- Implementation timeline
+
+**Use this to**: Create individual PRs for each rule category
+
+### [ESLINT_QUICKSTART.md](./ESLINT_QUICKSTART.md)
+**The Quick Start Guide** - Get started in minutes
+
+- 3 quick implementation options
+- Configuration templates
+- Common commands reference
+- Troubleshooting guide
+- 5-minute quick wins script
+- Success measurement tools
+
+**Use this to**: Get immediate wins with minimal effort
+
+## 🎯 Quick Start (Choose One)
+
+### Option A: Read Everything (30 minutes)
+1. Read ESLINT_RECOMMENDATIONS.md for context
+2. Review ESLINT_PR_PROPOSALS.md for implementation details
+3. Use ESLINT_QUICKSTART.md as reference
+
+### Option B: Quick Implementation (5 minutes)
+1. Jump to ESLINT_QUICKSTART.md
+2. Run the "Quick Wins" commands
+3. Commit zero-impact rules immediately
+
+### Option C: Pick Your PR (15 minutes)
+1. Browse ESLINT_PR_PROPOSALS.md quick reference table
+2. Choose a PR that interests you
+3. Follow the step-by-step guide for that PR
+
+## 🌟 Highlights
+
+### Exciting Patterns Found
+- ✅ Custom `UsageError` class with fix suggestions
+- ✅ Heavy use of `node:assert/strict` for invariants
+- ✅ Only 2 eslint-disable comments in entire codebase
+- ✅ Already follows `node:` protocol imports
+- ✅ Clean separation between CLI and library code
+
+### Top Priority Rules (Quick Wins)
+1. **consistent-type-imports** - Auto-fixable, big impact
+2. **Security rules** - Zero violations expected, easy add
+3. **no-console with CLI exceptions** - Codifies existing pattern
+4. **import/order** - Auto-fixable, improves readability
+5. **prefer-node-protocol** - Already followed, zero violations
+
+### Impact Summary
+- **Current lint errors**: ~700 (mostly no-unsafe-* rules)
+- **Recommended rules**: 20 across 10 PRs
+- **Auto-fixable**: 50%+ of new rules
+- **Breaking changes**: None
+- **Package additions**: 6 optional plugins
+
+## 📊 By the Numbers
+
+| Metric | Value |
+|--------|-------|
+| TypeScript files analyzed | ~75 |
+| Lines of TypeScript code | ~13,440 |
+| Test files | 12+ |
+| Current lint errors | ~700 |
+| eslint-disable instances | 2 |
+| TODO comments | ~20 |
+| Recommended rules | 20 |
+| Proposed PRs | 10 |
+| New packages suggested | 6 |
+
+## 🚀 Implementation Paths
+
+### Path 1: Comprehensive (4 weeks)
+Week 1: High priority rules (security, type imports, console)
+Week 2: Medium priority (imports, Node.js practices)
+Week 3: Medium priority continued (return types)
+Week 4+: Low priority (docs, comments, tests)
+
+### Path 2: Quick Wins (1 day)
+- Enable security baseline rules
+- Auto-fix type imports
+- Add modern JS rules
+- Commit and move on
+
+### Path 3: Custom Selection
+Pick specific rules from proposals based on team priorities
+
+## 🎓 For Reviewers
+
+When reviewing these recommendations:
+
+1. **Check the pattern analysis** - Do the identified patterns match your understanding?
+2. **Evaluate priorities** - Do you agree with High/Medium/Low classifications?
+3. **Consider team capacity** - Choose an implementation path that fits
+4. **Review rule configurations** - Tweak strictness levels as needed
+5. **Think gradual adoption** - Start with "warn", upgrade to "error"
+
+## 🔧 For Implementers
+
+When implementing PRs:
+
+1. **Test thoroughly** - Run lint, build, and test suite after each rule
+2. **Commit frequently** - One PR per rule category
+3. **Use auto-fix** - Let ESLint do the work where possible
+4. **Document decisions** - Update these docs with learnings
+5. **Measure impact** - Track error counts before/after
+
+## 📝 Maintenance
+
+Keep these documents updated:
+
+- **After implementing a PR**: Mark it complete, note any deviations
+- **After team feedback**: Adjust priorities or configurations
+- **After finding new patterns**: Add to recommendations
+- **Quarterly**: Review and refresh based on new ESLint features
+
+## 🤝 Contributing
+
+To add new rule recommendations:
+
+1. Identify the pattern in codebase
+2. Research appropriate ESLint rule
+3. Add to ESLINT_RECOMMENDATIONS.md with rationale
+4. Create PR proposal in ESLINT_PR_PROPOSALS.md
+5. Add quick-start commands to ESLINT_QUICKSTART.md if applicable
+
+## 📞 Questions?
+
+If you have questions about:
+- **Specific rules**: See ESLINT_RECOMMENDATIONS.md
+- **Implementation**: See ESLINT_PR_PROPOSALS.md  
+- **Getting started**: See ESLINT_QUICKSTART.md
+- **Everything**: Start with ESLINT_RECOMMENDATIONS.md
+
+## ✅ Checklist for This Work
+
+- [x] Analyze current ESLint configuration
+- [x] Identify patterns in codebase
+- [x] Document exciting patterns found
+- [x] Research appropriate ESLint rules
+- [x] Prioritize rules (High/Medium/Low)
+- [x] Create 10 actionable PR proposals
+- [x] Write implementation guides
+- [x] Provide quick-start templates
+- [x] Document success metrics
+- [x] Create this summary README
+
+## 🎉 Ready to Start!
+
+Pick your path and dive in. All three documents are production-ready and provide complete guidance.
+
+---
+
+**Generated**: December 2025
+**Status**: Ready for review and implementation
+**Estimated effort**: 5 minutes (quick wins) to 4 weeks (comprehensive)
diff --git a/ESLINT_RECOMMENDATIONS.md b/ESLINT_RECOMMENDATIONS.md
new file mode 100644
index 00000000..e4610ea9
--- /dev/null
+++ b/ESLINT_RECOMMENDATIONS.md
@@ -0,0 +1,443 @@
+# ESLint Rules Recommendations
+
+This document outlines exciting patterns found in the codebase and suggests ESLint rules to install/enable in separate PRs.
+
+## Current State
+
+The project currently uses:
+- **ESLint 9.32.0** with flat config
+- **typescript-eslint 8.38.0** with `recommendedTypeChecked`
+- **eslint-config-prettier** for Prettier integration
+- **Project references** for TypeScript with strict type checking
+- **~700 existing lint errors** (mostly `@typescript-eslint/no-unsafe-*` rules)
+
+## Exciting Patterns Found
+
+### 1. 🎯 Consistent Error Handling
+- **Pattern**: Custom `UsageError` class with `fix` property for actionable error messages
+- **Location**: `packages/cli-utils/src/errors.ts`
+- **Impact**: CLI tools provide helpful suggestions to users
+- **Notable**: The `wrapAction` wrapper consistently handles errors across CLI commands
+
+### 2. 🔒 Extensive Use of Node.js Assertions
+- **Pattern**: Heavy use of `assert` from `node:assert/strict` for runtime invariants
+- **Frequency**: Found in virtually all core files
+- **Quality**: Assertions include descriptive messages
+- **Example**: `assert(typeof pkg.name === "string", "Expected package.json to have a name")`
+
+### 3. 📦 Modular Architecture
+- **Pattern**: Clear separation of concerns across packages
+- **Structure**: CLI utils, platform-specific code, core logic all separated
+- **Testing**: Test files co-located with source (`*.test.ts`)
+
+### 4. 🛠️ Console Logging in CLI Tools
+- **Pattern**: Extensive `console.log`, `console.error` usage in CLI tools
+- **Purpose**: User feedback and debugging
+- **Scope**: Primarily in packages like `cmake-rn`, `ferric`, `gyp-to-cmake`, `host`
+
+### 5. 🎨 Rich Terminal Output
+- **Pattern**: Consistent use of `chalk` for colored output
+- **Quality**: Good UX with colored success/error messages
+- **Helper**: Custom `prettyPath` utility for displaying paths
+
+### 6. 📝 TODO Comments
+- **Frequency**: ~20+ TODO comments throughout codebase
+- **Common themes**:
+  - Future feature implementations
+  - Optimization opportunities
+  - Upstream contribution plans
+  - Platform support expansions
+
+### 7. ⚠️ Process Exit Handling
+- **Pattern**: Minimal direct `process.exit()` calls
+- **Best practice**: Uses `process.exitCode` instead for cleaner shutdown
+- **Found in**: CLI entry points and error handlers
+
+### 8. 🔄 Promise Patterns
+- **Pattern**: Extensive use of `Promise.all()` for parallel operations
+- **Use cases**: Building multiple targets, processing multiple platforms
+- **Quality**: Good parallelization of independent operations
+
+### 9. 🚫 Minimal eslint-disable Usage
+- **Finding**: Only 2 instances of `eslint-disable` in the entire codebase
+- **Quality indicator**: Shows commitment to fixing issues rather than suppressing
+
+## Recommended ESLint Rules (by PR)
+
+### PR #1: Code Quality & Best Practices (High Priority)
+
+#### 1. `no-console` (with CLI exceptions)
+**Why**: Enforce proper logging in library code while allowing console in CLI tools
+```javascript
+{
+  "no-console": ["warn", {
+    "allow": [] // Empty by default
+  }],
+  // Override for CLI files
+  files: ["**/cli/*.ts", "**/bin/*.js", "**/bin/*.mjs"],
+  rules: {
+    "no-console": "off"
+  }
+}
+```
+**Impact**: Medium - Will require adding a proper logging utility for non-CLI code
+**Exciting**: Distinguishes between library code and CLI tools
+
+#### 2. `no-throw-literal`
+**Why**: All errors should be proper Error objects (already followed)
+```javascript
+{
+  "no-throw-literal": "error",
+  "@typescript-eslint/no-throw-literal": "error"
+}
+```
+**Impact**: Low - Already well-followed in codebase
+**Exciting**: Ensures consistent error handling patterns
+
+#### 3. `prefer-promise-reject-errors`
+**Why**: Consistent with Error-only throwing pattern
+```javascript
+{
+  "prefer-promise-reject-errors": "error"
+}
+```
+**Impact**: Low
+**Exciting**: Complements the error handling strategy
+
+### PR #2: TypeScript Strictness (Medium Priority)
+
+#### 4. `@typescript-eslint/explicit-function-return-type`
+**Why**: Improves type safety and documentation
+```javascript
+{
+  "@typescript-eslint/explicit-function-return-type": ["warn", {
+    "allowExpressions": true,
+    "allowTypedFunctionExpressions": true,
+    "allowHigherOrderFunctions": true
+  }]
+}
+```
+**Impact**: High - Will require adding return types to ~100+ functions
+**Exciting**: Catches potential type inference issues early
+**Note**: Start with "warn" and upgrade to "error" over time
+
+#### 5. `@typescript-eslint/consistent-type-imports`
+**Why**: Consistent import style, better tree-shaking
+```javascript
+{
+  "@typescript-eslint/consistent-type-imports": ["error", {
+    "prefer": "type-imports",
+    "fixMergeTypeImports": true,
+    "fixMergeDefaultImportWithTypeImports": true
+  }]
+}
+```
+**Impact**: Medium - Will affect many import statements
+**Exciting**: Aligns with modern TypeScript best practices
+
+#### 6. `@typescript-eslint/consistent-type-exports`
+**Why**: Complements consistent-type-imports
+```javascript
+{
+  "@typescript-eslint/consistent-type-exports": ["error", {
+    "fixMixedExportsWithInlineTypeSpecifier": true
+  }]
+}
+```
+**Impact**: Low-Medium
+**Exciting**: Complete type import/export consistency
+
+### PR #3: Code Organization (Medium Priority)
+
+#### 7. `import/order` (requires eslint-plugin-import)
+**Why**: Consistent import ordering improves readability
+```javascript
+{
+  "import/order": ["error", {
+    "groups": [
+      "builtin",
+      "external",
+      "internal",
+      "parent",
+      "sibling",
+      "index"
+    ],
+    "newlines-between": "always",
+    "alphabetize": {
+      "order": "asc",
+      "caseInsensitive": true
+    }
+  }]
+}
+```
+**Impact**: Medium - Will reorder many imports
+**Exciting**: Pattern already partially followed (node: imports first)
+**Package**: `eslint-plugin-import` (with TypeScript resolver)
+
+#### 8. `import/no-default-export` (selective)
+**Why**: Named exports are more refactor-friendly
+```javascript
+{
+  // Only for non-config files
+  "import/no-default-export": "warn"
+}
+// Allow in config files
+{
+  files: ["*.config.js", "*.config.ts"],
+  rules: {
+    "import/no-default-export": "off"
+  }
+}
+```
+**Impact**: Low - Project already uses named exports predominantly
+**Exciting**: Enforces a pattern already mostly followed
+
+### PR #4: Comment Quality (Low Priority)
+
+#### 9. `no-warning-comments`
+**Why**: Track TODOs/FIXMEs systematically
+```javascript
+{
+  "no-warning-comments": ["warn", {
+    "terms": ["todo", "fixme", "xxx"],
+    "location": "start"
+  }]
+}
+```
+**Impact**: Low - ~20 existing TODOs need addressing or exemption
+**Exciting**: Can integrate with issue tracking
+**Alternative**: Use `eslint-plugin-etc` for more sophisticated TODO tracking
+
+#### 10. `eslint-comments/no-unused-disable`
+**Why**: Keep eslint-disable comments current
+```javascript
+{
+  "eslint-comments/no-unused-disable": "error"
+}
+```
+**Impact**: Very Low - Only 2 disable comments exist
+**Package**: `eslint-plugin-eslint-comments`
+**Exciting**: Prevents comment cruft accumulation
+
+### PR #5: Security & Safety (High Priority)
+
+#### 11. `no-eval` and `no-implied-eval`
+**Why**: Prevent code injection vulnerabilities
+```javascript
+{
+  "no-eval": "error",
+  "no-implied-eval": "error",
+  "@typescript-eslint/no-implied-eval": "error"
+}
+```
+**Impact**: Very Low - Not currently used
+**Exciting**: Security baseline
+
+#### 12. `@typescript-eslint/no-non-null-assertion`
+**Why**: Enforce explicit null checks
+```javascript
+{
+  "@typescript-eslint/no-non-null-assertion": "warn"
+}
+```
+**Impact**: Medium - Some non-null assertions may exist
+**Exciting**: Increases runtime safety
+
+### PR #6: Modern JavaScript (Low Priority)
+
+#### 13. `prefer-template`
+**Why**: Template literals over string concatenation
+```javascript
+{
+  "prefer-template": "warn"
+}
+```
+**Impact**: Low-Medium
+**Exciting**: More readable string operations
+
+#### 14. `prefer-const`
+**Why**: Immutability by default
+```javascript
+{
+  "prefer-const": ["error", {
+    "destructuring": "all"
+  }]
+}
+```
+**Impact**: Low - Likely already followed
+**Exciting**: Functional programming principles
+
+#### 15. `no-var`
+**Why**: Modern variable declarations
+```javascript
+{
+  "no-var": "error"
+}
+```
+**Impact**: Very Low - ESM project likely doesn't use var
+**Exciting**: Baseline modern JS
+
+### PR #7: Testing Standards (Medium Priority)
+
+#### 16. `@typescript-eslint/no-floating-promises` (already enabled!)
+**Status**: ✅ Already configured with test framework exceptions
+**Configuration**: Allows `suite` and `test` from `node:test`
+**Exciting**: Shows awareness of proper async handling
+
+#### 17. Test-specific rules with `eslint-plugin-node-test`
+**Why**: Enforce Node.js test best practices
+```javascript
+{
+  files: ["**/*.test.ts"],
+  rules: {
+    // Test-specific rules here
+  }
+}
+```
+**Package**: Custom or community plugin for Node.js test runner
+**Impact**: Low
+**Exciting**: Standardizes test structure
+
+### PR #8: Documentation (Low Priority)
+
+#### 18. `jsdoc/require-jsdoc` (selective)
+**Why**: Document public APIs
+```javascript
+{
+  "jsdoc/require-jsdoc": ["warn", {
+    "require": {
+      "FunctionDeclaration": true,
+      "MethodDefinition": false,
+      "ClassDeclaration": true,
+      "ArrowFunctionExpression": false
+    },
+    "publicOnly": true
+  }]
+}
+```
+**Package**: `eslint-plugin-jsdoc`
+**Impact**: High - Many functions lack JSDoc
+**Exciting**: TSDoc-compatible documentation
+**Note**: Consider TypeScript's own documentation
+
+### PR #9: Node.js Best Practices (Medium Priority)
+
+#### 19. `eslint-plugin-n` (Node.js specific)
+**Why**: Node.js specific best practices
+```javascript
+{
+  "n/no-deprecated-api": "error",
+  "n/no-missing-import": "off", // TypeScript handles this
+  "n/no-unpublished-import": "off", // Handled by package.json
+  "n/prefer-global/buffer": "error",
+  "n/prefer-global/process": "error"
+}
+```
+**Package**: `eslint-plugin-n`
+**Impact**: Low
+**Exciting**: Node.js ecosystem standards
+
+### PR #10: Performance (Low Priority)
+
+#### 20. `unicorn/prefer-module` and related
+**Why**: Modern Node.js patterns
+```javascript
+{
+  "unicorn/prefer-module": "off", // Some CommonJS needed
+  "unicorn/prefer-node-protocol": "error", // Already followed!
+  "unicorn/prefer-top-level-await": "warn"
+}
+```
+**Package**: `eslint-plugin-unicorn`
+**Impact**: Low - Already uses `node:` protocol
+**Exciting**: Modern Node.js patterns
+**Note**: `prefer-node-protocol` is already followed throughout!
+
+## Priority Ranking Summary
+
+### Must-Have (High Priority)
+1. ⭐ **no-console** (with CLI exceptions) - Code quality
+2. ⭐ **@typescript-eslint/consistent-type-imports** - Type safety
+3. ⭐ Security rules (no-eval, etc.) - Security baseline
+
+### Should-Have (Medium Priority)
+4. **@typescript-eslint/explicit-function-return-type** - Documentation
+5. **import/order** - Code organization
+6. **eslint-plugin-n** - Node.js best practices
+7. Test-specific rules - Testing standards
+
+### Nice-to-Have (Low Priority)
+8. Comment quality rules - Maintenance
+9. Modern JS rules - Code style
+10. Documentation rules - API documentation
+
+## Implementation Strategy
+
+### Phase 1: Quick Wins (Week 1)
+- Security rules (already compliant)
+- no-var, prefer-const (likely already compliant)
+- unicorn/prefer-node-protocol (already followed!)
+
+### Phase 2: Type Safety (Week 2-3)
+- consistent-type-imports/exports
+- explicit-function-return-type (start with warn)
+- no-non-null-assertion
+
+### Phase 3: Organization (Week 4)
+- import/order
+- import/no-default-export
+- eslint-plugin-n
+
+### Phase 4: Refinement (Ongoing)
+- Address existing ~700 no-unsafe-* errors
+- Add test-specific rules
+- Documentation rules (gradual)
+
+## New Package Dependencies
+
+Recommended packages to install:
+```json
+{
+  "devDependencies": {
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-n": "^17.16.0",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "eslint-plugin-jsdoc": "^50.6.0"
+  }
+}
+```
+
+## Metrics
+
+- **Current Files**: ~75 TypeScript files across packages
+- **Total Lines**: ~13,440 lines of TypeScript
+- **Test Coverage**: Good (12+ test files)
+- **Current Lint Errors**: ~700 (mostly unsafe-* rules)
+- **eslint-disable Usage**: Only 2 instances (excellent!)
+- **TODO Comments**: ~20+ (tracked in code)
+
+## Conclusion
+
+This codebase already demonstrates many excellent patterns:
+- ✅ Strict TypeScript configuration
+- ✅ Consistent error handling with custom error classes
+- ✅ Good use of assertions for runtime safety
+- ✅ Modular architecture with clear separation
+- ✅ Minimal eslint suppression
+- ✅ Already using `node:` protocol imports
+- ✅ Async handling awareness
+
+The recommended ESLint rules will help:
+1. **Codify existing patterns** (type imports, import order)
+2. **Prevent regressions** (security rules, error handling)
+3. **Improve maintainability** (documentation, comments)
+4. **Enhance type safety** (explicit returns, no non-null)
+
+Each PR should:
+- Focus on a single category
+- Include auto-fix where possible
+- Show before/after examples
+- Measure impact on existing code
+- Consider gradual adoption (warn → error)