agileflow 2.99.8 → 3.0.1

package/scripts/lib/configure-detect.js

@@ -6,8 +6,51 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 const { c, log, header, readJSON } = require('./configure-utils');
+const { tryOptional } = require('../../lib/errors');
+const { FEATURES } = require('./configure-features');
+
+// ============================================================================
+// CONTENT HASH HELPERS
+// ============================================================================
+
+/**
+ * Hash a file's content using SHA-256 (first 16 hex chars)
+ * @param {string} filePath - Path to the file
+ * @returns {string|null} 16-char hex hash, or null if file can't be read
+ */
+function hashFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find the directory containing package source scripts.
+ * Checks require.resolve first, then common fallback locations.
+ * @returns {string|null} Path to the scripts directory, or null
+ */
+function findPackageScriptDir() {
+  try {
+    const pkgPath = require.resolve('agileflow/package.json');
+    return path.join(path.dirname(pkgPath), 'scripts');
+  } catch {
+    // Fallback: check common locations
+    const candidates = [
+      path.join(process.cwd(), 'node_modules', 'agileflow', 'scripts'),
+      path.join(process.cwd(), 'packages', 'cli', 'scripts'), // monorepo dev
+    ];
+    for (const dir of candidates) {
+      if (fs.existsSync(dir)) return dir;
+    }
+    return null;
+  }
+}
 
 // ============================================================================
 // DETECTION
@@ -64,12 +107,10 @@ function detectConfig(version) {
   // Git detection
   if (fs.existsSync('.git')) {
     status.git.initialized = true;
-    try {
-      status.git.remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-    } catch {}
+    status.git.remote = tryOptional(() => execFileSync('git', ['remote', 'get-url', 'origin'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim(), 'git remote') ?? null;
   }
 
   // Settings file detection
@@ -257,17 +298,51 @@ function detectMetadata(status, version) {
     status.features.tmuxautospawn.enabled = true; // Default enabled
   }
 
-  // Read feature versions and check if outdated
+  // Read feature versions and check if outdated (content-based)
   if (meta.features) {
     const featureKeyMap = { askUserQuestion: 'askuserquestion', tmuxAutoSpawn: 'tmuxautospawn' };
+    const packageScriptDir = findPackageScriptDir();
+
     Object.entries(meta.features).forEach(([feature, data]) => {
       const statusKey = featureKeyMap[feature] || feature.toLowerCase();
       if (status.features[statusKey] && data.version) {
         status.features[statusKey].version = data.version;
-        if (data.version !== version && status.features[statusKey].enabled) {
-          status.features[statusKey].outdated = true;
-          status.hasOutdated = true;
+
+        if (!status.features[statusKey].enabled) return;
+
+        // Content-based outdated detection
+        const featureConfig = FEATURES[statusKey];
+        const scriptsToCheck = featureConfig?.scripts
+          || (featureConfig?.script ? [featureConfig.script] : []);
+
+        if (scriptsToCheck.length > 0 && packageScriptDir) {
+          // Compare installed scripts against package source
+          let isOutdated = false;
+          for (const scriptName of scriptsToCheck) {
+            const packageScript = path.join(packageScriptDir, scriptName);
+            const installedScript = path.join(
+              process.cwd(), '.agileflow', 'scripts', scriptName
+            );
+            const packageHash = hashFile(packageScript);
+            const installedHash = hashFile(installedScript);
+
+            if (packageHash && installedHash && packageHash !== installedHash) {
+              isOutdated = true;
+              break;
+            }
+          }
+          if (isOutdated) {
+            status.features[statusKey].outdated = true;
+            status.hasOutdated = true;
+          }
+        } else if (featureConfig?.metadataOnly) {
+          // Metadata-only features: use version comparison (no scripts to hash)
+          if (data.version !== version) {
+            status.features[statusKey].outdated = true;
+            status.hasOutdated = true;
+          }
         }
+        // If no package source found or no scripts, don't mark outdated (fail open)
       }
     });
   }
@@ -403,4 +478,6 @@ module.exports = {
   detectPreToolUseHooks,
   detectStatusLine,
   detectMetadata,
+  hashFile,
+  findPackageScriptDir,
 };

package/scripts/lib/configure-features.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const os = require('os');
 const {
   c,
@@ -53,8 +54,12 @@ const FEATURES = {
     description: 'Auto-kill duplicate Claude processes in same directory to prevent freezing',
   },
   claudeflags: {
-    metadataOnly: true,
-    description: 'Default flags for Claude CLI (e.g., --dangerously-skip-permissions)',
+    metadataOnly: false,
+    description: 'Default flags for Claude CLI (sets permissions.defaultMode in .claude/settings.json)',
+  },
+  agentteams: {
+    metadataOnly: false,
+    description: 'Enable Claude Code native Agent Teams (sets env var in .claude/settings.json)',
   },
 };
 
@@ -148,6 +153,20 @@ const SCRIPTS_DIR = path.join(process.cwd(), '.agileflow', 'scripts');
 const scriptExists = scriptName => fs.existsSync(path.join(SCRIPTS_DIR, scriptName));
 const getScriptPath = scriptName => `.agileflow/scripts/${scriptName}`;
 
+/**
+ * Hash a file's content using SHA-256 (first 16 hex chars)
+ * @param {string} filePath - Path to the file
+ * @returns {string|null} 16-char hex hash, or null if file can't be read
+ */
+function hashFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
 // ============================================================================
 // METADATA MANAGEMENT
 // ============================================================================
@@ -304,8 +323,24 @@ function enableFeature(feature, options = {}, version) {
   }
 
   // Handle claude flags (e.g., --dangerously-skip-permissions)
+  // Also sets permissions.defaultMode in .claude/settings.json
   if (feature === 'claudeflags') {
     const defaultFlags = options.flags || '--dangerously-skip-permissions';
+
+    // Map CLI flags to settings.json defaultMode values
+    const flagToMode = {
+      '--dangerously-skip-permissions': 'bypassPermissions',
+      '--permission-mode acceptEdits': 'acceptEdits',
+    };
+    const defaultMode = flagToMode[defaultFlags];
+
+    if (defaultMode) {
+      settings.permissions = settings.permissions || {};
+      settings.permissions.defaultMode = defaultMode;
+      writeJSON('.claude/settings.json', settings);
+      info(`Set permissions.defaultMode = "${defaultMode}" in .claude/settings.json`);
+    }
+
     updateMetadata(
       {
         features: {
@@ -321,6 +356,33 @@ function enableFeature(feature, options = {}, version) {
     );
     success(`Default Claude flags configured: ${defaultFlags}`);
     info('These flags will be passed to Claude when launched via "af" or "agileflow"');
+    if (defaultMode) {
+      info('Restart Claude Code for the new default mode to take effect');
+    }
+    return true;
+  }
+
+  // Handle agent teams - set env var in .claude/settings.json
+  if (feature === 'agentteams') {
+    settings.env = settings.env || {};
+    settings.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = '1';
+    writeJSON('.claude/settings.json', settings);
+    updateMetadata(
+      {
+        features: {
+          agentTeams: {
+            enabled: true,
+            version,
+            at: new Date().toISOString(),
+          },
+        },
+      },
+      version
+    );
+    success('Native Agent Teams enabled');
+    info('Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in .claude/settings.json');
+    info('Claude Code will use native TeamCreate/SendMessage tools');
+    info('Fallback: subagent mode (Task/TaskOutput) when native is unavailable');
     return true;
   }
 
@@ -391,9 +453,18 @@ function enableFeature(feature, options = {}, version) {
     return enableDamageControl(settings, options, version);
   }
 
+  const featureConfig = FEATURES[feature];
+  const contentHash = featureConfig?.script
+    ? hashFile(path.join(SCRIPTS_DIR, featureConfig.script))
+    : null;
   writeJSON('.claude/settings.json', settings);
   updateMetadata(
-    { features: { [feature]: { enabled: true, version, at: new Date().toISOString() } } },
+    { features: { [feature]: {
+      enabled: true,
+      version,
+      ...(contentHash ? { contentHash } : {}),
+      at: new Date().toISOString(),
+    } } },
     version
   );
   updateGitignore();
@@ -558,6 +629,7 @@ function enableDamageControl(settings, options, version) {
 
   success('Damage control PreToolUse hooks enabled');
 
+  const primaryHash = hashFile(path.join(SCRIPTS_DIR, 'damage-control-bash.js'));
   updateMetadata(
     {
       features: {
@@ -565,6 +637,7 @@ function enableDamageControl(settings, options, version) {
           enabled: true,
           protectionLevel: level,
           version,
+          ...(primaryHash ? { contentHash: primaryHash } : {}),
           at: new Date().toISOString(),
         },
       },
@@ -710,8 +783,13 @@ function disableFeature(feature, version) {
     return true;
   }
 
-  // Disable claude flags
+  // Disable claude flags - also reset permissions.defaultMode in settings.json
   if (feature === 'claudeflags') {
+    if (settings.permissions?.defaultMode) {
+      delete settings.permissions.defaultMode;
+      writeJSON('.claude/settings.json', settings);
+      info('Removed permissions.defaultMode from .claude/settings.json');
+    }
     updateMetadata(
       {
         features: {
@@ -727,6 +805,34 @@ function disableFeature(feature, version) {
     );
     success('Default Claude flags disabled');
     info('Claude will launch with default permissions (prompts for each action)');
+    info('Restart Claude Code for the change to take effect');
+    return true;
+  }
+
+  // Disable agent teams - remove env var from .claude/settings.json
+  if (feature === 'agentteams') {
+    if (settings.env) {
+      delete settings.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+      if (Object.keys(settings.env).length === 0) {
+        delete settings.env;
+      }
+    }
+    writeJSON('.claude/settings.json', settings);
+    updateMetadata(
+      {
+        features: {
+          agentTeams: {
+            enabled: false,
+            version,
+            at: new Date().toISOString(),
+          },
+        },
+      },
+      version
+    );
+    success('Native Agent Teams disabled');
+    info('Removed CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS from .claude/settings.json');
+    info('AgileFlow will use subagent mode (Task/TaskOutput) for multi-agent orchestration');
     return true;
   }
 

package/scripts/lib/configure-repair.js

@@ -9,6 +9,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 const { feedback } = require('../../lib/feedback');
+const { tryOptional } = require('../../lib/errors');
 const {
   c,
   log,
@@ -115,11 +116,11 @@ function listScripts() {
     // Check if modified
     let isModified = false;
     if (exists && fileIndex?.files?.[`scripts/${script}`]) {
-      try {
+      isModified = tryOptional(() => {
         const currentHash = sha256(fs.readFileSync(scriptPath));
         const indexHash = fileIndex.files[`scripts/${script}`].sha256;
-        isModified = currentHash !== indexHash;
-      } catch {}
+        return currentHash !== indexHash;
+      }, 'hash check') ?? false;
     }
 
     // Print status
@@ -279,9 +280,7 @@ function repairScripts(targetFeature = null) {
       if (fs.existsSync(srcPath)) {
         try {
           fs.copyFileSync(srcPath, destPath);
-          try {
-            fs.chmodSync(destPath, 0o755);
-          } catch {}
+          tryOptional(() => fs.chmodSync(destPath, 0o755), 'chmod');
           success(`Restored ${script}`);
           repaired++;
         } catch (err) {

package/scripts/lib/configure-utils.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { tryOptional } = require('../../lib/errors');
 
 // ============================================================================
 // COLORS & LOGGING
@@ -58,9 +59,7 @@ const copyTemplate = (templateName, destPath) => {
   for (const src of sources) {
     if (fs.existsSync(src)) {
       fs.copyFileSync(src, destPath);
-      try {
-        fs.chmodSync(destPath, '755');
-      } catch {}
+      tryOptional(() => fs.chmodSync(destPath, '755'), 'chmod');
       return true;
     }
   }

package/scripts/lib/context-formatter.js

@@ -321,6 +321,23 @@ function generateSummary(prefetched = null, options = {}) {
 
   summary += divider();
 
+  // Scale indicator (EP-0033)
+  let scaleDetectorSummary;
+  try { scaleDetectorSummary = require('./scale-detector'); } catch { /* not available */ }
+  if (scaleDetectorSummary) {
+    try {
+      const scaleResult = scaleDetectorSummary.detectScale({
+        rootDir: process.cwd(),
+        statusJson: prefetched?.json?.statusJson,
+        sessionState: prefetched?.json?.sessionState,
+      });
+      const label = scaleDetectorSummary.getScaleLabel(scaleResult.scale);
+      summary += row('Scale', label, C.lavender, C.cyan);
+    } catch {
+      // Silently ignore
+    }
+  }
+
   // Key files
   const keyFileChecks = [
     { path: 'CLAUDE.md', label: 'CLAUDE' },
@@ -378,7 +395,7 @@ function generateSummary(prefetched = null, options = {}) {
  * @returns {string} Full content
  */
 function generateFullContent(prefetched = null, options = {}) {
-  const { commandName = null, activeSections = [] } = options;
+  const { commandName = null, activeSections = [], smartDetectResults = null } = options;
 
   let content = '';
 
@@ -437,12 +454,17 @@ function generateFullContent(prefetched = null, options = {}) {
 
   if (askUserQuestionConfig?.enabled) {
     content += `${C.coral}${C.bold}┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓${C.reset}\n`;
-    content += `${C.coral}${C.bold}┃ 🔔 MANDATORY: AskUserQuestion After EVERY Response      ┃${C.reset}\n`;
+    content += `${C.coral}${C.bold}┃ 🔔 SMART AskUserQuestion After EVERY Response           ┃${C.reset}\n`;
     content += `${C.coral}${C.bold}┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛${C.reset}\n`;
     content += `${C.bold}After completing ANY task${C.reset} (implementation, fix, etc.):\n`;
-    content += `${C.mintGreen}→ ALWAYS${C.reset} call ${C.skyBlue}AskUserQuestion${C.reset} tool to offer next steps\n`;
-    content += `${C.coral}→ NEVER${C.reset} end with text like "Done!" or "What's next?"\n\n`;
-    content += `${C.dim}Balance: Use at natural pause points. Don't ask permission for routine work.${C.reset}\n\n`;
+    content += `${C.mintGreen}→ ALWAYS${C.reset} call ${C.skyBlue}AskUserQuestion${C.reset} tool with ${C.bold}SMART, contextual${C.reset} options\n`;
+    content += `${C.coral}→ NEVER${C.reset} generic options like "Continue" or "What next?"\n\n`;
+    content += `${C.bold}Smart Suggestion Principles:${C.reset}\n`;
+    content += `${C.mintGreen}→${C.reset} Always mark one option ${C.bold}"(Recommended)"${C.reset} based on logical next step\n`;
+    content += `${C.mintGreen}→${C.reset} Be specific: ${C.dim}"Run npm test for auth changes"${C.reset} not ${C.dim}"Run tests"${C.reset}\n`;
+    content += `${C.mintGreen}→${C.reset} Include context: ${C.dim}"3 files changed"${C.reset}, story IDs, test results\n`;
+    content += `${C.mintGreen}→${C.reset} Suggest workflow progression: plan → implement → test → commit\n`;
+    content += `${C.mintGreen}→${C.reset} After errors: suggest specific alternative, not ${C.dim}"fix it"${C.reset}\n\n`;
   }
 
   // CONTEXT BUDGET WARNING
@@ -479,6 +501,27 @@ function generateFullContent(prefetched = null, options = {}) {
     content += '\n';
   }
 
+  // SCALE DETECTION (EP-0033)
+  let scaleDetector;
+  try { scaleDetector = require('./scale-detector'); } catch { /* not available */ }
+  if (scaleDetector) {
+    try {
+      const scaleResult = scaleDetector.detectScale({
+        rootDir: process.cwd(),
+        statusJson: prefetched?.json?.statusJson,
+        sessionState: prefetched?.json?.sessionState,
+      });
+      const recs = scaleDetector.getScaleRecommendations(scaleResult.scale);
+      const label = scaleDetector.getScaleLabel(scaleResult.scale);
+      content += `\n${C.cyan}${C.bold}═══ Project Scale: ${label} ═══${C.reset}\n`;
+      content += `${C.dim}Detected: ${scaleResult.metrics.files} files, ${scaleResult.metrics.stories} stories, ${scaleResult.metrics.commits} commits (6mo)${C.reset}\n`;
+      content += `Planning depth: ${C.mintGreen}${recs.planningDepth}${C.reset} | Experts: ${C.mintGreen}${recs.expertCount}${C.reset}\n`;
+      content += `${C.dim}${recs.description}${C.reset}\n`;
+    } catch {
+      // Silently ignore scale detection errors
+    }
+  }
+
   // GIT STATUS
   content += `\n${C.skyBlue}${C.bold}═══ Git Status ═══${C.reset}\n`;
   const branch = prefetched?.git?.branch ?? safeExec('git branch --show-current') ?? 'unknown';
@@ -533,7 +576,7 @@ function generateFullContent(prefetched = null, options = {}) {
     if (Array.isArray(sessionState.active_commands) && sessionState.active_commands.length > 0) {
       const cmdNames = sessionState.active_commands.map(c => c.name).join(', ');
       content += `Active commands: ${C.skyBlue}${cmdNames}${C.reset}\n`;
-    } else if (sessionState.active_command) {
+    } else if (sessionState.active_command && sessionState.active_command.name) {
       content += `Active command: ${C.skyBlue}${sessionState.active_command.name}${C.reset}\n`;
     }
 
@@ -592,7 +635,7 @@ function generateRemainingContent(prefetched, options = {}) {
             const sessionDir = story.claimedBy?.path
               ? path.basename(story.claimedBy.path)
               : 'unknown';
-            content += `  ${C.coral}🔒${C.reset} ${C.lavender}${story.id}${C.reset} "${story.title}" ${C.dim}→ Session ${story.claimedBy?.session_id || '?'} (${sessionDir})${C.reset}\n`;
+            content += `  ${C.coral}🔒${C.reset} ${C.lavender}${story.id ?? '?'}${C.reset} "${story.title ?? 'untitled'}" ${C.dim}→ Session ${story.claimedBy?.session_id ?? '?'} (${sessionDir})${C.reset}\n`;
           });
           content += '\n';
         }
@@ -601,7 +644,7 @@ function generateRemainingContent(prefetched, options = {}) {
         if (myResult.ok && myResult.stories && myResult.stories.length > 0) {
           content += `\n${C.mintGreen}${C.bold}═══ ✓ Your Claimed Stories ═══${C.reset}\n`;
           myResult.stories.forEach(story => {
-            content += `  ${C.mintGreen}✓${C.reset} ${C.lavender}${story.id}${C.reset} "${story.title}"\n`;
+            content += `  ${C.mintGreen}✓${C.reset} ${C.lavender}${story.id ?? '?'}${C.reset} "${story.title ?? 'untitled'}"\n`;
           });
           content += '\n';
         }
@@ -813,6 +856,42 @@ function generateRemainingContent(prefetched, options = {}) {
     }
   }
 
+  // SMART RECOMMENDATIONS (Contextual Feature Router)
+  const smartDetectResults = options.smartDetectResults;
+  if (smartDetectResults && !smartDetectResults.disabled) {
+    const { immediate, available, auto_enabled } = smartDetectResults.recommendations;
+    const hasRecommendations = immediate.length > 0 || available.length > 0;
+
+    if (hasRecommendations) {
+      content += `\n${C.brand}${C.bold}═══ Smart Recommendations ═══${C.reset}\n`;
+      content += `${C.dim}Phase: ${smartDetectResults.lifecycle_phase} (${smartDetectResults.phase_reason})${C.reset}\n`;
+
+      if (immediate.length > 0) {
+        content += `\n${C.coral}${C.bold}Immediate:${C.reset}\n`;
+        immediate.forEach(r => {
+          content += `  ${C.coral}!${C.reset} ${C.bold}${r.feature}${C.reset}: ${r.trigger} ${C.dim}(${r.command})${C.reset}\n`;
+        });
+      }
+
+      if (available.length > 0) {
+        content += `\n${C.skyBlue}Available:${C.reset}\n`;
+        available.slice(0, 5).forEach(r => {
+          content += `  ${C.skyBlue}>${C.reset} ${r.feature}: ${r.trigger} ${C.dim}(${r.command})${C.reset}\n`;
+        });
+        if (available.length > 5) {
+          content += `  ${C.dim}... and ${available.length - 5} more${C.reset}\n`;
+        }
+      }
+    }
+
+    // Show auto-enabled modes
+    const modes = auto_enabled || {};
+    const enabledModes = Object.entries(modes).filter(([, v]) => v).map(([k]) => k.replace('_', ' '));
+    if (enabledModes.length > 0) {
+      content += `\n${C.mintGreen}Auto-enabled:${C.reset} ${enabledModes.join(', ')}\n`;
+    }
+  }
+
   // FOOTER
   content += `\n${C.dim}─────────────────────────────────────────${C.reset}\n`;
   content += `${C.dim}Context gathered in single execution. Claude has full context.${C.reset}\n`;

package/scripts/lib/damage-control-utils.js

@@ -33,6 +33,14 @@ const c = {
   reset: '\x1b[0m',
 };
 
+// Pattern cache: avoids re-reading and re-parsing YAML on every hook invocation.
+// Invalidated when the config file's mtime changes.
+const _patternCache = {
+  /** @type {string|null} */ filePath: null,
+  /** @type {number} */ mtime: 0,
+  /** @type {object|null} */ config: null,
+};
+
 // Shared constants
 const CONFIG_PATHS = [
   '.agileflow/config/damage-control-patterns.yaml',
@@ -70,8 +78,9 @@ function expandPath(p) {
 }
 
 /**
- * Load patterns configuration from YAML file
- * Returns empty config if not found (fail-open)
+ * Load patterns configuration from YAML file with caching.
+ * Returns cached config when the file hasn't changed (mtime check).
+ * Returns empty config if not found (fail-open).
  *
  * @param {string} projectRoot - Project root directory
  * @param {function} parseYAML - Function to parse YAML content
@@ -83,8 +92,23 @@ function loadPatterns(projectRoot, parseYAML, defaultConfig = {}) {
     const fullPath = path.join(projectRoot, configPath);
     if (fs.existsSync(fullPath)) {
       try {
+        // Check mtime for cache invalidation
+        const stat = fs.statSync(fullPath);
+        const mtime = stat.mtimeMs;
+
+        if (_patternCache.filePath === fullPath && _patternCache.mtime === mtime && _patternCache.config) {
+          return _patternCache.config;
+        }
+
         const content = fs.readFileSync(fullPath, 'utf8');
-        return parseYAML(content);
+        const config = parseYAML(content);
+
+        // Store in cache
+        _patternCache.filePath = fullPath;
+        _patternCache.mtime = mtime;
+        _patternCache.config = config;
+
+        return config;
       } catch (e) {
         // Continue to next path
       }
@@ -95,6 +119,15 @@ function loadPatterns(projectRoot, parseYAML, defaultConfig = {}) {
   return defaultConfig;
 }
 
+/**
+ * Clear the pattern cache (for testing or forced reload).
+ */
+function clearPatternCache() {
+  _patternCache.filePath = null;
+  _patternCache.mtime = 0;
+  _patternCache.config = null;
+}
+
 /**
  * Check if a file path matches any of the protected patterns
  *
@@ -559,6 +592,7 @@ module.exports = {
   findProjectRoot,
   expandPath,
   loadPatterns,
+  clearPatternCache,
   pathMatches,
   outputBlocked,
   runDamageControlHook,