claude-git-hooks 2.43.0 → 2.45.0

package/CHANGELOG.md

@@ -5,6 +5,55 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.45.0] - 2026-05-13
+
+### ✨ Added
+- Added centralized config-registry module with local defaults and remote override support (SUE-138)
+- Added lib/defaults.json as the single source of truth for all package default values (SUE-138)
+
+### 🔧 Changed
+- Replaced inline hardcoded constants across modules with config-registry lookups — judge, orchestrator, Linear connector, model aliases, linter tools, and PR analysis categories now read from defaults.json with remote override capability (SUE-138)
+- Updated config merge priority to HARDCODED < remote settings.json < defaults < preset < user overrides (SUE-138)
+- Added config-registry mocks to unit tests for modules consuming centralized defaults (SUE-138)
+
+### 🐛 Fixed
+- Fixed Linear ticket fetch issue (#155)
+
+
+## [2.44.1] - 2026-05-13
+
+### ✨ Added
+- Added unit tests for linear-connector module covering ticket extraction, parsing, token loading, connection testing, and ticket fetching (SUE-154)
+
+### 🐛 Fixed
+- Fixed help command to cap book reads at 5 in Pass 2, preventing oversized prompts when the LLM requests too many library books (SUE-154)
+
+### 🗑️ Removed
+- Removed CLAUDE-MIGRATION.md — migration map no longer needed after library stabilization
+
+
+## [2.44.0] - 2026-05-04
+
+### ✨ Added
+- New `HELP_NAVIGATE.md` prompt template for the first-pass catalog navigation (SUE-152)
+- Auto-discovery of `.library/` catalog files (by-code, by-domain, by-task-type shelves) for AI help context
+
+### 🔧 Changed
+- Rewrote AI help command to use a two-pass librarian approach navigating local `.library/` instead of single-pass CLAUDE.md lookup (SUE-152)
+- Pass 1 sends project catalog to Claude; if deeper detail is needed, Pass 2 reads specific book files from local disk — no GitHub API calls
+- Updated `HELP_QUERY.md` template to accept catalog + book content instead of flat documentation
+- Replaced `NEED_MORE_CONTEXT: file1, file2` protocol with structured `ANSWER:` / `BOOKS:` response format
+- Updated `report-issue` flow to use internal `_readPackageFile()` helper instead of the removed `readClaudeMd()`
+- Updated unit tests to cover two-pass librarian flow, catalog mocking, and book-read scenarios
+
+### 🔒 Security
+- Added path traversal protection when reading LLM-requested book paths — resolved paths are verified against the package root before disk access
+
+### 🗑️ Removed
+- Removed GitHub API dependency (`fetchFileContent`, `parseGitHubRepo`) from AI help flow — all context is now read from local disk
+- Removed `readClaudeMd()` single-file reader in favor of `readLibraryCatalog()` multi-file catalog builder
+
+
 ## [2.43.0] - 2026-04-30
 
 ### ✨ Added

package/README.md

@@ -295,7 +295,7 @@ claude-hooks telemetry clear  # Clear data
 ### Help & Issue Reporting
 
 ```bash
-claude-hooks help "how do presets work?"  # AI-powered help (uses CLAUDE.md)
+claude-hooks help "how do presets work?"  # AI-powered help (navigates .library/)
 claude-hooks help --report-issue          # Interactive GitHub issue creation
 claude-hooks --help                       # Static command reference
 ```
@@ -355,7 +355,7 @@ claude-hooks update   # Update to latest version
 | `debug.js`              | **Debug toggle** - enable/disable verbose logging                 | `runSetDebug()`                                                               |
 | `telemetry-cmd.js`      | **Telemetry commands** - show/clear statistics                    | `runShowTelemetry()`, `runClearTelemetry()`                                   |
 | `diff-batch-info.js`    | **Batch info** - orchestration config + per-model speed telemetry | `runDiffBatchInfo()`                                                          |
-| `help.js`               | **Help, AI help, report-issue**                                   | `runShowHelp()`, `showStaticHelp()`, `runShowVersion()`                       |
+| `help.js`               | **Help, AI librarian, report-issue**                              | `runShowHelp()`, `showStaticHelp()`, `runShowVersion()`                       |
 
 ### Utility Modules (`lib/utils/`)
 

package/lib/commands/analyze-pr.js

@@ -33,6 +33,7 @@ import { promptConfirmation, promptMenu } from '../utils/interactive-ui.js';
 import { CostTracker } from '../utils/cost-tracker.js';
 import { colors, error, fatal, info, warning, checkGitRepo } from './helpers.js';
 import logger from '../utils/logger.js';
+import { resolveSection } from '../utils/config-registry.js';
 import path from 'path';
 
 // ─── JSON Error Helper ────────────────────────────────────────────────────
@@ -380,23 +381,14 @@ export async function runAnalyzePr(args) {
             warning(`Could not load preset "${presetName}" guidelines, using defaults`);
         }
 
-        // Step 7: Build category strings from config
-        const inlineCategories = config.prAnalysis?.inlineCategories || [
-            'bug',
-            'security',
-            'performance',
-            'hotspot'
-        ];
-        const generalCategories = config.prAnalysis?.generalCategories || [
-            'ticket-alignment',
-            'scope',
-            'style',
-            'good-practice',
-            'extensibility',
-            'observability',
-            'documentation',
-            'testing'
-        ];
+        // Step 7: Build category strings from config (remote categories.json > local defaults)
+        // Categories are guaranteed by defaults.json loaded at import time via config-registry.
+        // The || [] fallback guards against unexpected config corruption or a missing section.
+        const resolvedPrAnalysis = await resolveSection('prAnalysis');
+        const inlineCategories = resolvedPrAnalysis?.inlineCategories ||
+            config.prAnalysis?.inlineCategories || [];
+        const generalCategories = resolvedPrAnalysis?.generalCategories ||
+            config.prAnalysis?.generalCategories || [];
         const allCategories = [...inlineCategories, ...generalCategories];
 
         const inlineCategoriesStr = inlineCategories.map((c) => `- \`${c}\``).join('\n');

package/lib/commands/help.js

@@ -4,7 +4,7 @@
  *
  * Features:
  * - Dynamic help from command registry (no args, --help, -h)
- * - AI help: routes questions to Claude with CLAUDE.md as knowledge base
+ * - AI help: two-pass librarian navigating .library/ for answers
  * - Report issue: interactive issue creation guided by Claude
  */
 
@@ -160,59 +160,137 @@ function printAiResponse(response, source) {
     console.log('');
 }
 
+/** Package root directory — resolved once from __dirname */
+const _packageRoot = path.join(__dirname, '..', '..');
+
+/**
+ * Maximum number of books to read in Pass 2.
+ * Why: Matches the "do not request more than 5" instruction in HELP_NAVIGATE.md.
+ * Caps LLM-sourced lists to prevent oversized prompts that would fail the second call.
+ */
+const MAX_BOOKS = 5;
+
 /**
- * Read CLAUDE.md from package root
- * Why: CLAUDE.md is the primary knowledge source shipped with the npm package
+ * Catalog directories within .library/ to auto-discover
+ * Why: These contain index and shelf files that form the navigational catalog.
+ * books/ is excluded — those are fetched on-demand in Pass 2.
+ */
+const _CATALOG_DIRS = ['by-code', 'by-domain', 'by-task-type'];
+
+/**
+ * Read a single file from package root, returning null on failure
  *
- * @returns {Promise<string|null>} CLAUDE.md content or null
+ * @param {string} relativePath - Path relative to package root
+ * @returns {Promise<string|null>} File content or null
  */
-const readClaudeMd = async () => {
-    const claudeMdPath = path.join(__dirname, '..', '..', 'CLAUDE.md');
+const _readPackageFile = async (relativePath) => {
     try {
-        const content = await fs.readFile(claudeMdPath, 'utf8');
-        logger.debug('help - readClaudeMd', 'CLAUDE.md loaded', { length: content.length });
-        return content;
-    } catch (error) {
-        logger.debug('help - readClaudeMd', 'CLAUDE.md not found', {
-            path: claudeMdPath,
-            error: error.message
-        });
+        return await fs.readFile(path.join(_packageRoot, relativePath), 'utf8');
+    } catch {
+        return null;
+    }
+};
+
+/**
+ * Read the project catalog from .library/ and CLAUDE.md
+ * Why: The catalog provides navigational context for the AI librarian (Pass 1).
+ * Auto-discovers index/shelf files so the catalog stays current as .library/ grows.
+ *
+ * Reads:
+ * - CLAUDE.md (global rules)
+ * - .library/index.md (repo identity, capabilities)
+ * - .library/conventions.md (coding standards)
+ * - .library/by-code/*.md (source-path shelves)
+ * - .library/by-domain/*.md (workflow reading lists)
+ * - .library/by-task-type/*.md (task guidance)
+ *
+ * @returns {Promise<string|null>} Concatenated catalog or null if nothing could be read
+ */
+const readLibraryCatalog = async () => {
+    const sections = [];
+
+    // Fixed files: CLAUDE.md + core library files
+    const fixedFiles = [
+        { label: 'CLAUDE.md', path: 'CLAUDE.md' },
+        { label: '.library/index.md', path: '.library/index.md' },
+        { label: '.library/conventions.md', path: '.library/conventions.md' }
+    ];
+
+    for (const file of fixedFiles) {
+        const content = await _readPackageFile(file.path);
+        if (content) {
+            sections.push(`--- ${file.label} ---\n${content}`);
+        }
+    }
+
+    // Auto-discover .md files in each catalog directory
+    for (const dir of _CATALOG_DIRS) {
+        const dirPath = path.join(_packageRoot, '.library', dir);
+        let entries;
+        try {
+            entries = await fs.readdir(dirPath);
+        } catch {
+            logger.debug('help - readLibraryCatalog', `Could not read .library/${dir}/`);
+            continue;
+        }
+
+        const mdFiles = entries.filter((f) => f.endsWith('.md')).sort();
+        for (const file of mdFiles) {
+            const relativePath = `.library/${dir}/${file}`;
+            const content = await _readPackageFile(relativePath);
+            if (content) {
+                sections.push(`--- ${relativePath} ---\n${content}`);
+            }
+        }
+    }
+
+    if (sections.length === 0) {
+        logger.debug('help - readLibraryCatalog', 'No catalog files found');
         return null;
     }
+
+    const catalog = sections.join('\n\n');
+    logger.debug('help - readLibraryCatalog', 'Catalog loaded', {
+        sections: sections.length,
+        length: catalog.length
+    });
+    return catalog;
 };
 
 /**
- * AI-powered help: routes question to Claude with CLAUDE.md context
- * Why: Provides intelligent answers about claude-hooks based on documentation
+ * AI-powered help: two-pass librarian navigating .library/
+ * Why: Provides intelligent answers by reading the project catalog, then
+ * fetching specific books from local disk only when deeper detail is needed.
  *
  * Flow:
- * 1. Read CLAUDE.md from package root
- * 2. Load HELP_QUERY.md template
- * 3. Call Claude with 30s timeout
- * 4. If NEED_MORE_CONTEXT: fetch referenced files from GitHub, re-query
- * 5. Display response
- * 6. On any error: fall back to static help
+ * 1. Read catalog from .library/ (auto-discovered indexes + shelves)
+ * 2. Pass 1: Send catalog to Claude via HELP_NAVIGATE.md
+ * 3. If ANSWER: display directly (1 Claude call)
+ * 4. If BOOKS: read requested books from local disk, send to HELP_QUERY.md (2 Claude calls)
+ * 5. On any error: fall back to static help
  *
  * @param {string} question - User's natural language question
  */
 async function runAiHelp(question) {
     try {
-        const claudeMdContent = await readClaudeMd();
-        if (!claudeMdContent) {
+        const catalog = await readLibraryCatalog();
+        if (!catalog) {
             logger.debug(
                 'help - runAiHelp',
-                'CLAUDE.md not available, falling back to static help'
+                'Catalog not available, falling back to static help'
             );
             showStaticHelp();
             return;
         }
 
-        const prompt = await loadPrompt('HELP_QUERY.md', {
-            DOCUMENTATION: claudeMdContent,
+        const prompt = await loadPrompt('HELP_NAVIGATE.md', {
+            CATALOG: catalog,
             QUESTION: question
         });
 
-        logger.debug('help - runAiHelp', 'Querying Claude', { questionLength: question.length });
+        logger.debug('help - runAiHelp', 'Querying Claude (Pass 1)', {
+            questionLength: question.length
+        });
         console.log('\nSearching documentation...\n');
 
         const pkg = getPackageJson();
@@ -221,95 +299,106 @@ async function runAiHelp(question) {
         const response = await executeClaudeWithRetry(prompt, { timeout: 60000 });
         const trimmedResponse = response.trim();
 
-        // Check for NEED_MORE_CONTEXT second pass
-        const needMoreLine = trimmedResponse
-            .split('\n')
-            .find((l) => l.includes('NEED_MORE_CONTEXT'));
-        if (needMoreLine) {
-            const enrichedResponse = await handleNeedMoreContext(
-                needMoreLine,
+        // Check for BOOKS: second pass
+        const booksLine = trimmedResponse.split('\n').find((l) => l.startsWith('BOOKS:'));
+        if (booksLine) {
+            const enrichedAnswer = await readAndAnswerWithBooks(
+                booksLine,
                 question,
-                claudeMdContent
+                catalog
             );
-            if (enrichedResponse) {
-                printAiResponse(enrichedResponse, `${localVersion} + source`);
-                return;
-            }
-            // Enrichment failed: show first-pass answer with marker line stripped
-            const cleanResponse = trimmedResponse
-                .split('\n')
-                .filter((l) => !l.includes('NEED_MORE_CONTEXT'))
-                .join('\n')
-                .trim();
-            if (cleanResponse) {
-                printAiResponse(cleanResponse, localVersion);
+            if (enrichedAnswer) {
+                printAiResponse(enrichedAnswer, `${localVersion} + source`);
                 return;
             }
+            // Books not readable — avoid surfacing raw BOOKS: line to the user
+            showStaticHelp();
+            return;
         }
 
-        printAiResponse(trimmedResponse, localVersion);
-    } catch (error) {
+        // ANSWER: response or fallback — strip the "ANSWER:" prefix if present
+        const answerLine = trimmedResponse.indexOf('ANSWER:');
+        const answer =
+            answerLine !== -1
+                ? trimmedResponse.substring(answerLine + 'ANSWER:'.length).trim()
+                : trimmedResponse;
+
+        printAiResponse(answer, localVersion);
+    } catch (err) {
         logger.debug('help - runAiHelp', 'AI help failed, falling back to static help', {
-            error: error.message
+            error: err.message
         });
         showStaticHelp();
     }
 }
 
 /**
- * Handle NEED_MORE_CONTEXT response by fetching referenced files from GitHub
+ * Pass 2: Read requested books from local disk and answer with enriched context
  *
- * @param {string} needMoreLine - The line containing NEED_MORE_CONTEXT marker
+ * @param {string} booksLine - The line starting with "BOOKS:" containing comma-separated paths
  * @param {string} question - Original user question
- * @param {string} claudeMdContent - Original CLAUDE.md content
- * @returns {Promise<string|null>} Enriched response or null on failure
+ * @param {string} catalog - The catalog content from Pass 1
+ * @returns {Promise<string|null>} Enriched answer or null on failure
  */
-async function handleNeedMoreContext(needMoreLine, question, claudeMdContent) {
+async function readAndAnswerWithBooks(booksLine, question, catalog) {
     try {
-        // Parse file paths from line: "NEED_MORE_CONTEXT: file1.js, file2.js"
-        const pathsPart = needMoreLine.replace('NEED_MORE_CONTEXT', '').replace(':', '').trim();
-        const filePaths = pathsPart
+        const pathsPart = booksLine.replace('BOOKS:', '').trim();
+        const bookPaths = pathsPart
             .split(',')
             .map((p) => p.trim())
             .filter(Boolean);
 
-        if (filePaths.length === 0) {
-            logger.debug('help - handleNeedMoreContext', 'No file paths in NEED_MORE_CONTEXT');
+        if (bookPaths.length === 0) {
+            logger.debug('help - readAndAnswerWithBooks', 'No book paths in BOOKS line');
             return null;
         }
 
-        logger.debug('help - handleNeedMoreContext', 'Fetching additional files', { filePaths });
-
-        const { owner, repo } = getSourceRepo();
+        if (bookPaths.length > MAX_BOOKS) {
+            logger.debug('help - readAndAnswerWithBooks', 'Capping book list', {
+                requested: bookPaths.length,
+                max: MAX_BOOKS
+            });
+            bookPaths.length = MAX_BOOKS;
+        }
 
-        // Fetch files in parallel (no ref = default branch, avoids 404 on unreleased tags)
-        const fetchResults = await Promise.all(
-            filePaths.map(async (filePath) => {
-                const content = await fetchFileContent(owner, repo, filePath);
-                return { filePath, content };
+        logger.debug('help - readAndAnswerWithBooks', 'Reading books from disk', { bookPaths });
+
+        // Read books from local filesystem in parallel
+        // Contain LLM-sourced paths to the package root to prevent traversal
+        const readResults = await Promise.all(
+            bookPaths.map(async (bookPath) => {
+                const resolvedPath = path.resolve(_packageRoot, bookPath);
+                if (!resolvedPath.startsWith(_packageRoot + path.sep)) {
+                    logger.debug('help - readAndAnswerWithBooks', 'Path traversal blocked', { bookPath });
+                    return { bookPath, content: null };
+                }
+                const content = await _readPackageFile(bookPath);
+                return { bookPath, content };
             })
         );
 
-        // Build enriched documentation
-        const additionalContent = fetchResults
+        const bookContent = readResults
             .filter((r) => r.content !== null)
-            .map((r) => `\n--- Source: ${r.filePath} ---\n${r.content}`)
-            .join('\n');
+            .map((r) => `--- ${r.bookPath} ---\n${r.content}`)
+            .join('\n\n');
 
-        if (!additionalContent) {
-            logger.debug('help - handleNeedMoreContext', 'No additional content fetched');
+        if (!bookContent) {
+            logger.debug('help - readAndAnswerWithBooks', 'No book content read from disk');
             return null;
         }
 
         const enrichedPrompt = await loadPrompt('HELP_QUERY.md', {
-            DOCUMENTATION: `${claudeMdContent}\n\n=== ADDITIONAL SOURCE FILES ===\n${additionalContent}`,
+            CATALOG: catalog,
+            BOOKS: bookContent,
             QUESTION: question
         });
 
         const enrichedResponse = await executeClaudeWithRetry(enrichedPrompt, { timeout: 60000 });
         return enrichedResponse.trim();
-    } catch (error) {
-        logger.debug('help - handleNeedMoreContext', 'Enrichment failed', { error: error.message });
+    } catch (err) {
+        logger.debug('help - readAndAnswerWithBooks', 'Book enrichment failed', {
+            error: err.message
+        });
         return null;
     }
 }
@@ -371,8 +460,8 @@ async function runReportIssue() {
             return;
         }
 
-        // Step 5: Read CLAUDE.md for project context
-        const claudeMdContent = await readClaudeMd();
+        // Step 5: Read CLAUDE.md for project context (report-issue only needs basic context)
+        const claudeMdContent = await _readPackageFile('CLAUDE.md');
 
         // Step 6: Generate questions from template using Claude
         const questionsPrompt = await loadPrompt('HELP_REPORT_ISSUE.md', {

package/lib/config.js

@@ -24,104 +24,23 @@
 import fs from 'fs';
 import path from 'path';
 import logger from './utils/logger.js';
+import { getDefaults, resolveSection } from './utils/config-registry.js';
 
 /**
- * Hardcoded defaults (v3.0.0)
- * These are NOT user-configurable - sensible defaults that work for everyone
+ * Package defaults loaded from lib/defaults.json via config-registry.
+ * These are NOT user-configurable — sensible defaults that work for everyone.
+ * See lib/defaults.json for the full structure and values.
  */
-const HARDCODED = {
-    analysis: {
-        maxFileSize: 1000000, // 1MB - sufficient for most files
-        maxFiles: 30, // Reasonable limit per commit
-        timeout: 360000, // 6 minutes - adequate for Claude API
-        contextLines: 3, // Git default
-        ignoreExtensions: [] // Can be set in advanced config only
-    },
-    commitMessage: {
-        autoKeyword: 'auto', // Standard keyword
-        timeout: 300000, // Use same timeout as analysis
-        taskIdPattern: '([A-Z]{1,3}[-\\s]\\d{3,5})' // Jira/GitHub/Linear pattern
-    },
-    subagents: {
-        enabled: true // Enable by default (faster analysis via orchestration)
-    },
-    templates: {
-        baseDir: '.claude/prompts',
-        analysis: 'CLAUDE_ANALYSIS_PROMPT.md',
-        guidelines: 'CLAUDE_PRE_COMMIT.md',
-        commitMessage: 'COMMIT_MESSAGE.md',
-        analyzeDiff: 'ANALYZE_DIFF.md',
-        resolution: 'CLAUDE_RESOLUTION_PROMPT.md',
-        createGithubPR: 'CREATE_GITHUB_PR.md'
-    },
-    output: {
-        outputDir: '.claude/out',
-        debugFile: '.claude/out/debug-claude-response.json',
-        resolutionFile: '.claude/out/claude_resolution_prompt.md',
-        prAnalysisFile: '.claude/out/pr-analysis.json'
-    },
-    system: {
-        debug: false, // Controlled by --debug flag
-        wslCheckTimeout: 15000 // System behavior
-    },
-    git: {
-        diffFilter: 'ACM' // Standard: Added, Copied, Modified
-    },
-    github: {
-        enabled: true // Always enabled
-    },
-    prAnalysis: {
-        model: 'sonnet',
-        timeout: 300000, // 5 minutes
-        inlineCategories: ['bug', 'security', 'performance', 'hotspot'],
-        generalCategories: [
-            'ticket-alignment',
-            'scope',
-            'style',
-            'good-practice',
-            'extensibility',
-            'observability',
-            'documentation',
-            'testing'
-        ]
-    },
-    linting: {
-        enabled: true, // Run linters before Claude analysis
-        autoFix: true, // Auto-fix and re-stage
-        failOnError: true, // Block commit on linting errors
-        failOnWarning: false, // Do not block on warnings
-        timeout: 30000 // 30s per linter
-    },
-    claude: {
-        defaultModel: 'sonnet' // Fallback model for SDK headless mode
-    }
-};
+const HARDCODED = getDefaults();
 
 /**
  * Default user-configurable values (v2.8.0)
+ * Derived from the github.pr section of HARDCODED.
  * Only these can be overridden in .claude/config.json
  */
 const defaults = {
-    // GitHub PR configuration (user-specific)
     github: {
-        pr: {
-            defaultBase: 'develop', // Project default branch
-            reviewers: [], // Project reviewers
-            labelRules: {
-                // Labels by preset
-                backend: ['backend', 'java'],
-                frontend: ['frontend', 'react'],
-                fullstack: ['fullstack'],
-                database: ['database', 'sql'],
-                ai: ['ai', 'tooling'],
-                default: []
-            },
-            // Auto-push configuration (v2.11.0)
-            autoPush: true, // Auto-push unpublished branches
-            pushConfirm: true, // Prompt for confirmation before push
-            verifyRemote: true, // Verify remote exists before push
-            showCommits: true // Show commit preview before push
-        }
+        pr: structuredClone(HARDCODED.github.pr)
     }
 };
 
@@ -132,7 +51,7 @@ const defaults = {
  * - v2.8.0: { version: "2.8.0", preset: "...", overrides: {...} }
  * - Legacy: { preset: "...", analysis: {...}, ... } (auto-migrates with warning)
  *
- * Merge priority: HARDCODED < defaults < preset config < user overrides
+ * Merge priority: HARDCODED < remote settings.json < defaults < preset config < user overrides
  *
  * @param {string} baseDir - Base directory to search for config (default: cwd)
  * @returns {Promise<Object>} Merged configuration
@@ -194,8 +113,17 @@ const loadUserConfig = async (baseDir = process.cwd()) => {
         }
     }
 
-    // Merge priority: HARDCODED < defaults < preset < user overrides
-    const baseConfig = deepMerge(HARDCODED, defaults);
+    // Fetch remote settings.json overrides for team-policy sections
+    const remoteSettings = {};
+    const settingsSections = ['analysis', 'commitMessage', 'linting'];
+    const sectionResults = await Promise.all(settingsSections.map((s) => resolveSection(s)));
+    settingsSections.forEach((section, i) => {
+        if (sectionResults[i]) remoteSettings[section] = sectionResults[i];
+    });
+
+    // Merge priority: HARDCODED < remote settings.json < defaults < preset < user overrides
+    const withRemote = deepMerge(HARDCODED, remoteSettings);
+    const baseConfig = deepMerge(withRemote, defaults);
     const withPreset = deepMerge(baseConfig, presetConfig);
     const final = deepMerge(withPreset, userOverrides);