thaddeus 1.0.26 → 1.0.28

package/src/utils/claudemd.js

@@ -0,0 +1,1052 @@
+/**
+ * Files are loaded in the following order:
+ *
+ * 1. Managed memory (eg. /etc/thaddeus/CLAUDE.md) - Global instructions for all users
+ * 2. User memory (~/.claude/CLAUDE.md) - Private global instructions for all projects
+ * 3. Project memory (CLAUDE.md, .claude/CLAUDE.md, and .claude/rules/*.md in project roots) - Instructions checked into the codebase
+ * 4. Local memory (CLAUDE.local.md in project roots) - Private project-specific instructions
+ *
+ * Files are loaded in reverse order of priority, i.e. the latest files are highest priority
+ * with the model paying more attention to them.
+ *
+ * File discovery:
+ * - User memory is loaded from the user's home directory
+ * - Project and Local files are discovered by traversing from the current directory up to root
+ * - Files closer to the current directory have higher priority (loaded later)
+ * - CLAUDE.md, .claude/CLAUDE.md, and all .md files in .claude/rules/ are checked in each directory for Project memory
+ *
+ * Memory @include directive:
+ * - Memory files can include other files using @ notation
+ * - Syntax: @path, @./relative/path, @~/home/path, or @/absolute/path
+ * - @path (without prefix) is treated as a relative path (same as @./path)
+ * - Works in leaf text nodes only (not inside code blocks or code strings)
+ * - Included files are added as separate entries before the including file
+ * - Circular references are prevented by tracking processed files
+ * - Non-existent files are silently ignored
+ */
+import { feature } from 'bun:bundle';
+import ignore from 'ignore';
+import memoize from 'lodash-es/memoize.js';
+import { Lexer } from 'marked';
+import { basename, dirname, extname, isAbsolute, join, parse, relative, sep, } from 'path';
+import picomatch from 'picomatch';
+import { logEvent } from 'src/services/analytics/index.js';
+import { getAdditionalDirectoriesForClaudeMd, getOriginalCwd, } from '../bootstrap/state.js';
+import { truncateEntrypointContent } from '../memdir/memdir.js';
+import { getAutoMemEntrypoint, isAutoMemoryEnabled } from '../memdir/paths.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
+import { getCurrentProjectConfig, getManagedClaudeRulesDir, getMemoryPath, getUserClaudeRulesDir, } from './config.js';
+import { logForDebugging } from './debug.js';
+import { logForDiagnosticsNoPII } from './diagLogs.js';
+import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js';
+import { getErrnoCode } from './errors.js';
+import { normalizePathForComparison } from './file.js';
+import { cacheKeys } from './fileStateCache.js';
+import { parseFrontmatter, splitPathInFrontmatter, } from './frontmatterParser.js';
+import { getFsImplementation, safeResolvePath } from './fsOperations.js';
+import { findCanonicalGitRoot, findGitRoot } from './git.js';
+import { executeInstructionsLoadedHooks, hasInstructionsLoadedHook, } from './hooks.js';
+import { expandPath } from './path.js';
+import { pathInWorkingPath } from './permissions/filesystem.js';
+import { isSettingSourceEnabled } from './settings/constants.js';
+import { getInitialSettings } from './settings/settings.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const teamMemPaths = feature('TEAMMEM')
+    ? require('../memdir/teamMemPaths.js')
+    : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+let hasLoggedInitialLoad = false;
+const MEMORY_INSTRUCTION_PROMPT = 'Codebase and user instructions are shown below. Be sure to adhere to these instructions. IMPORTANT: These instructions OVERRIDE any default behavior and you MUST follow them exactly as written.';
+// Recommended max character count for a memory file
+export const MAX_MEMORY_CHARACTER_COUNT = 40000;
+// File extensions that are allowed for @include directives
+// This prevents binary files (images, PDFs, etc.) from being loaded into memory
+const TEXT_FILE_EXTENSIONS = new Set([
+    // Markdown and text
+    '.md',
+    '.txt',
+    '.text',
+    // Data formats
+    '.json',
+    '.yaml',
+    '.yml',
+    '.toml',
+    '.xml',
+    '.csv',
+    // Web
+    '.html',
+    '.htm',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less',
+    // JavaScript/TypeScript
+    '.js',
+    '.ts',
+    '.tsx',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    // Python
+    '.py',
+    '.pyi',
+    '.pyw',
+    // Ruby
+    '.rb',
+    '.erb',
+    '.rake',
+    // Go
+    '.go',
+    // Rust
+    '.rs',
+    // Java/Kotlin/Scala
+    '.java',
+    '.kt',
+    '.kts',
+    '.scala',
+    // C/C++
+    '.c',
+    '.cpp',
+    '.cc',
+    '.cxx',
+    '.h',
+    '.hpp',
+    '.hxx',
+    // C#
+    '.cs',
+    // Swift
+    '.swift',
+    // Shell
+    '.sh',
+    '.bash',
+    '.zsh',
+    '.fish',
+    '.ps1',
+    '.bat',
+    '.cmd',
+    // Config
+    '.env',
+    '.ini',
+    '.cfg',
+    '.conf',
+    '.config',
+    '.properties',
+    // Database
+    '.sql',
+    '.graphql',
+    '.gql',
+    // Protocol
+    '.proto',
+    // Frontend frameworks
+    '.vue',
+    '.svelte',
+    '.astro',
+    // Templating
+    '.ejs',
+    '.hbs',
+    '.pug',
+    '.jade',
+    // Other languages
+    '.php',
+    '.pl',
+    '.pm',
+    '.lua',
+    '.r',
+    '.R',
+    '.dart',
+    '.ex',
+    '.exs',
+    '.erl',
+    '.hrl',
+    '.clj',
+    '.cljs',
+    '.cljc',
+    '.edn',
+    '.hs',
+    '.lhs',
+    '.elm',
+    '.ml',
+    '.mli',
+    '.f',
+    '.f90',
+    '.f95',
+    '.for',
+    // Build files
+    '.cmake',
+    '.make',
+    '.makefile',
+    '.gradle',
+    '.sbt',
+    // Documentation
+    '.rst',
+    '.adoc',
+    '.asciidoc',
+    '.org',
+    '.tex',
+    '.latex',
+    // Lock files (often text-based)
+    '.lock',
+    // Misc
+    '.log',
+    '.diff',
+    '.patch',
+]);
+function pathInOriginalCwd(path) {
+    return pathInWorkingPath(path, getOriginalCwd());
+}
+/**
+ * Parses raw content to extract both content and glob patterns from frontmatter
+ * @param rawContent Raw file content with frontmatter
+ * @returns Object with content and globs (undefined if no paths or match-all pattern)
+ */
+function parseFrontmatterPaths(rawContent) {
+    const { frontmatter, content } = parseFrontmatter(rawContent);
+    if (!frontmatter.paths) {
+        return { content };
+    }
+    const patterns = splitPathInFrontmatter(frontmatter.paths)
+        .map(pattern => {
+        // Remove /** suffix - ignore library treats 'path' as matching both
+        // the path itself and everything inside it
+        return pattern.endsWith('/**') ? pattern.slice(0, -3) : pattern;
+    })
+        .filter((p) => p.length > 0);
+    // If all patterns are ** (match-all), treat as no globs (undefined)
+    // This means the file applies to all paths
+    if (patterns.length === 0 || patterns.every((p) => p === '**')) {
+        return { content };
+    }
+    return { content, paths: patterns };
+}
+/**
+ * Strip block-level HTML comments (<!-- ... -->) from markdown content.
+ *
+ * Uses the marked lexer to identify comments at the block level only, so
+ * comments inside inline code spans and fenced code blocks are preserved.
+ * Inline HTML comments inside a paragraph are also left intact; the intended
+ * use case is authorial notes that occupy their own lines.
+ *
+ * Unclosed comments (`<!--` with no matching `-->`) are left in place so a
+ * typo doesn't silently swallow the rest of the file.
+ */
+export function stripHtmlComments(content) {
+    if (!content.includes('<!--')) {
+        return { content, stripped: false };
+    }
+    // gfm:false is fine here — html-block detection is a CommonMark rule.
+    return stripHtmlCommentsFromTokens(new Lexer({ gfm: false }).lex(content));
+}
+function stripHtmlCommentsFromTokens(tokens) {
+    let result = '';
+    let stripped = false;
+    // A well-formed HTML comment span. Non-greedy so multiple comments on the
+    // same line are matched independently; [\s\S] to span newlines.
+    const commentSpan = /<!--[\s\S]*?-->/g;
+    for (const token of tokens) {
+        if (token.type === 'html') {
+            const trimmed = token.raw.trimStart();
+            if (trimmed.startsWith('<!--') && trimmed.includes('-->')) {
+                // Per CommonMark, a type-2 HTML block ends at the *line* containing
+                // `-->`, so text after `-->` on that line is part of this token.
+                // Strip only the comment spans and keep any residual content.
+                const residue = token.raw.replace(commentSpan, '');
+                stripped = true;
+                if (residue.trim().length > 0) {
+                    // Residual content exists (e.g. `<!-- note --> Use bun`): keep it.
+                    result += residue;
+                }
+                continue;
+            }
+        }
+        result += token.raw;
+    }
+    return { content: result, stripped };
+}
+/**
+ * Parses raw memory file content into a MemoryFileInfo. Pure function — no I/O.
+ *
+ * When includeBasePath is given, @include paths are resolved in the same lex
+ * pass and returned alongside the parsed file (so processMemoryFile doesn't
+ * need to lex the same content a second time).
+ */
+function parseMemoryFileContent(rawContent, filePath, type, includeBasePath) {
+    // Skip non-text files to prevent loading binary data (images, PDFs, etc.) into memory
+    const ext = extname(filePath).toLowerCase();
+    if (ext && !TEXT_FILE_EXTENSIONS.has(ext)) {
+        logForDebugging(`Skipping non-text file in @include: ${filePath}`);
+        return { info: null, includePaths: [] };
+    }
+    const { content: withoutFrontmatter, paths } = parseFrontmatterPaths(rawContent);
+    // Lex once so strip and @include-extract share the same tokens. gfm:false
+    // is required by extract (so ~/path doesn't tokenize as strikethrough) and
+    // doesn't affect strip (html blocks are a CommonMark rule).
+    const hasComment = withoutFrontmatter.includes('<!--');
+    const tokens = hasComment || includeBasePath !== undefined
+        ? new Lexer({ gfm: false }).lex(withoutFrontmatter)
+        : undefined;
+    // Only rebuild via tokens when a comment actually needs stripping —
+    // marked normalises \r\n during lex, so round-tripping a CRLF file
+    // through token.raw would spuriously flip contentDiffersFromDisk.
+    const strippedContent = hasComment && tokens
+        ? stripHtmlCommentsFromTokens(tokens).content
+        : withoutFrontmatter;
+    const includePaths = tokens && includeBasePath !== undefined
+        ? extractIncludePathsFromTokens(tokens, includeBasePath)
+        : [];
+    // Truncate MEMORY.md entrypoints to the line AND byte caps
+    let finalContent = strippedContent;
+    if (type === 'AutoMem' || type === 'TeamMem') {
+        finalContent = truncateEntrypointContent(strippedContent).content;
+    }
+    // Covers frontmatter strip, HTML comment strip, and MEMORY.md truncation
+    const contentDiffersFromDisk = finalContent !== rawContent;
+    return {
+        info: {
+            path: filePath,
+            type,
+            content: finalContent,
+            globs: paths,
+            contentDiffersFromDisk,
+            rawContent: contentDiffersFromDisk ? rawContent : undefined,
+        },
+        includePaths,
+    };
+}
+function handleMemoryFileReadError(error, filePath) {
+    const code = getErrnoCode(error);
+    // ENOENT = file doesn't exist, EISDIR = is a directory — both expected
+    if (code === 'ENOENT' || code === 'EISDIR') {
+        return;
+    }
+    // Log permission errors (EACCES) as they're actionable
+    if (code === 'EACCES') {
+        // Don't log the full file path to avoid PII/security issues
+        logEvent('thaddeus_claude_md_permission_error', {
+            is_access_error: 1,
+            has_home_dir: filePath.includes(getClaudeConfigHomeDir()) ? 1 : 0,
+        });
+    }
+}
+/**
+ * Used by processMemoryFile → getMemoryFiles so the event loop stays
+ * responsive during the directory walk (many readFile attempts, most
+ * ENOENT). When includeBasePath is given, @include paths are resolved in
+ * the same lex pass and returned alongside the parsed file.
+ */
+async function safelyReadMemoryFileAsync(filePath, type, includeBasePath) {
+    try {
+        const fs = getFsImplementation();
+        const rawContent = await fs.readFile(filePath, { encoding: 'utf-8' });
+        return parseMemoryFileContent(rawContent, filePath, type, includeBasePath);
+    }
+    catch (error) {
+        handleMemoryFileReadError(error, filePath);
+        return { info: null, includePaths: [] };
+    }
+}
+// Extract @path include references from pre-lexed tokens and resolve to
+// absolute paths. Skips html tokens so @paths inside block comments are
+// ignored — the caller may pass pre-strip tokens.
+function extractIncludePathsFromTokens(tokens, basePath) {
+    const absolutePaths = new Set();
+    // Extract @paths from a text string and add resolved paths to absolutePaths.
+    function extractPathsFromText(textContent) {
+        const includeRegex = /(?:^|\s)@((?:[^\s\\]|\\ )+)/g;
+        let match;
+        while ((match = includeRegex.exec(textContent)) !== null) {
+            let path = match[1];
+            if (!path)
+                continue;
+            // Strip fragment identifiers (#heading, #section-name, etc.)
+            const hashIndex = path.indexOf('#');
+            if (hashIndex !== -1) {
+                path = path.substring(0, hashIndex);
+            }
+            if (!path)
+                continue;
+            // Unescape the spaces in the path
+            path = path.replace(/\\ /g, ' ');
+            // Accept @path, @./path, @~/path, or @/path
+            if (path) {
+                const isValidPath = path.startsWith('./') ||
+                    path.startsWith('~/') ||
+                    (path.startsWith('/') && path !== '/') ||
+                    (!path.startsWith('@') &&
+                        !path.match(/^[#%^&*()]+/) &&
+                        path.match(/^[a-zA-Z0-9._-]/));
+                if (isValidPath) {
+                    const resolvedPath = expandPath(path, dirname(basePath));
+                    absolutePaths.add(resolvedPath);
+                }
+            }
+        }
+    }
+    // Recursively process elements to find text nodes
+    function processElements(elements) {
+        for (const element of elements) {
+            if (element.type === 'code' || element.type === 'codespan') {
+                continue;
+            }
+            // For html tokens that contain comments, strip the comment spans and
+            // check the residual for @paths (e.g. `<!-- note --> @./file.md`).
+            // Other html tokens (non-comment tags) are skipped entirely.
+            if (element.type === 'html') {
+                const raw = element.raw || '';
+                const trimmed = raw.trimStart();
+                if (trimmed.startsWith('<!--') && trimmed.includes('-->')) {
+                    const commentSpan = /<!--[\s\S]*?-->/g;
+                    const residue = raw.replace(commentSpan, '');
+                    if (residue.trim().length > 0) {
+                        extractPathsFromText(residue);
+                    }
+                }
+                continue;
+            }
+            // Process text nodes
+            if (element.type === 'text') {
+                extractPathsFromText(element.text || '');
+            }
+            // Recurse into children tokens
+            if (element.tokens) {
+                processElements(element.tokens);
+            }
+            // Special handling for list structures
+            if (element.items) {
+                processElements(element.items);
+            }
+        }
+    }
+    processElements(tokens);
+    return [...absolutePaths];
+}
+const MAX_INCLUDE_DEPTH = 5;
+/**
+ * Checks whether a CLAUDE.md file path is excluded by the claudeMdExcludes setting.
+ * Only applies to User, Project, and Local memory types.
+ * Managed, AutoMem, and TeamMem types are never excluded.
+ *
+ * Matches both the original path and the realpath-resolved path to handle symlinks
+ * (e.g., /tmp -> /private/tmp on macOS).
+ */
+function isClaudeMdExcluded(filePath, type) {
+    if (type !== 'User' && type !== 'Project' && type !== 'Local') {
+        return false;
+    }
+    const patterns = getInitialSettings().claudeMdExcludes;
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    const matchOpts = { dot: true };
+    const normalizedPath = filePath.replaceAll('\\', '/');
+    // Build an expanded pattern list that includes realpath-resolved versions of
+    // absolute patterns. This handles symlinks like /tmp -> /private/tmp on macOS:
+    // the user writes "/tmp/project/CLAUDE.md" in their exclude, but the system
+    // resolves the CWD to "/private/tmp/project/...", so the file path uses the
+    // real path. By resolving the patterns too, both sides match.
+    const expandedPatterns = resolveExcludePatterns(patterns).filter(p => p.length > 0);
+    if (expandedPatterns.length === 0) {
+        return false;
+    }
+    return picomatch.isMatch(normalizedPath, expandedPatterns, matchOpts);
+}
+/**
+ * Expands exclude patterns by resolving symlinks in absolute path prefixes.
+ * For each absolute pattern (starting with /), tries to resolve the longest
+ * existing directory prefix via realpathSync and adds the resolved version.
+ * Glob patterns (containing *) have their static prefix resolved.
+ */
+function resolveExcludePatterns(patterns) {
+    const fs = getFsImplementation();
+    const expanded = patterns.map(p => p.replaceAll('\\', '/'));
+    for (const normalized of expanded) {
+        // Only resolve absolute patterns — glob-only patterns like "**/*.md" don't have
+        // a filesystem prefix to resolve
+        if (!normalized.startsWith('/')) {
+            continue;
+        }
+        // Find the static prefix before any glob characters
+        const globStart = normalized.search(/[*?{[]/);
+        const staticPrefix = globStart === -1 ? normalized : normalized.slice(0, globStart);
+        const dirToResolve = dirname(staticPrefix);
+        try {
+            // sync IO: called from sync context (isClaudeMdExcluded -> processMemoryFile -> getMemoryFiles)
+            const resolvedDir = fs.realpathSync(dirToResolve).replaceAll('\\', '/');
+            if (resolvedDir !== dirToResolve) {
+                const resolvedPattern = resolvedDir + normalized.slice(dirToResolve.length);
+                expanded.push(resolvedPattern);
+            }
+        }
+        catch {
+            // Directory doesn't exist; skip resolution for this pattern
+        }
+    }
+    return expanded;
+}
+/**
+ * Recursively processes a memory file and all its @include references
+ * Returns an array of MemoryFileInfo objects with includes first, then main file
+ */
+export async function processMemoryFile(filePath, type, processedPaths, includeExternal, depth = 0, parent) {
+    // Skip if already processed or max depth exceeded.
+    // Normalize paths for comparison to handle Windows drive letter casing
+    // differences (e.g., C:\Users vs c:\Users).
+    const normalizedPath = normalizePathForComparison(filePath);
+    if (processedPaths.has(normalizedPath) || depth >= MAX_INCLUDE_DEPTH) {
+        return [];
+    }
+    // Skip if path is excluded by claudeMdExcludes setting
+    if (isClaudeMdExcluded(filePath, type)) {
+        return [];
+    }
+    // Resolve symlink path early for @import resolution
+    const { resolvedPath, isSymlink } = safeResolvePath(getFsImplementation(), filePath);
+    processedPaths.add(normalizedPath);
+    if (isSymlink) {
+        processedPaths.add(normalizePathForComparison(resolvedPath));
+    }
+    const { info: memoryFile, includePaths: resolvedIncludePaths } = await safelyReadMemoryFileAsync(filePath, type, resolvedPath);
+    if (!memoryFile || !memoryFile.content.trim()) {
+        return [];
+    }
+    // Add parent information
+    if (parent) {
+        memoryFile.parent = parent;
+    }
+    const result = [];
+    // Add the main file first (parent before children)
+    result.push(memoryFile);
+    for (const resolvedIncludePath of resolvedIncludePaths) {
+        const isExternal = !pathInOriginalCwd(resolvedIncludePath);
+        if (isExternal && !includeExternal) {
+            continue;
+        }
+        // Recursively process included files with this file as parent
+        const includedFiles = await processMemoryFile(resolvedIncludePath, type, processedPaths, includeExternal, depth + 1, filePath);
+        result.push(...includedFiles);
+    }
+    return result;
+}
+/**
+ * Processes all .md files in the .claude/rules/ directory and its subdirectories
+ * @param rulesDir The path to the rules directory
+ * @param type Type of memory file (User, Project, Local)
+ * @param processedPaths Set of already processed file paths
+ * @param includeExternal Whether to include external files
+ * @param conditionalRule If true, only include files with frontmatter paths; if false, only include files without frontmatter paths
+ * @param visitedDirs Set of already visited directory real paths (for cycle detection)
+ * @returns Array of MemoryFileInfo objects
+ */
+export async function processMdRules({ rulesDir, type, processedPaths, includeExternal, conditionalRule, visitedDirs = new Set(), }) {
+    if (visitedDirs.has(rulesDir)) {
+        return [];
+    }
+    try {
+        const fs = getFsImplementation();
+        const { resolvedPath: resolvedRulesDir, isSymlink } = safeResolvePath(fs, rulesDir);
+        visitedDirs.add(rulesDir);
+        if (isSymlink) {
+            visitedDirs.add(resolvedRulesDir);
+        }
+        const result = [];
+        let entries;
+        try {
+            entries = await fs.readdir(resolvedRulesDir);
+        }
+        catch (e) {
+            const code = getErrnoCode(e);
+            if (code === 'ENOENT' || code === 'EACCES' || code === 'ENOTDIR') {
+                return [];
+            }
+            throw e;
+        }
+        for (const entry of entries) {
+            const entryPath = join(rulesDir, entry.name);
+            const { resolvedPath: resolvedEntryPath, isSymlink } = safeResolvePath(fs, entryPath);
+            // Use Dirent methods for non-symlinks to avoid extra stat calls.
+            // For symlinks, we need stat to determine what the target is.
+            const stats = isSymlink ? await fs.stat(resolvedEntryPath) : null;
+            const isDirectory = stats ? stats.isDirectory() : entry.isDirectory();
+            const isFile = stats ? stats.isFile() : entry.isFile();
+            if (isDirectory) {
+                result.push(...(await processMdRules({
+                    rulesDir: resolvedEntryPath,
+                    type,
+                    processedPaths,
+                    includeExternal,
+                    conditionalRule,
+                    visitedDirs,
+                })));
+            }
+            else if (isFile && entry.name.endsWith('.md')) {
+                const files = await processMemoryFile(resolvedEntryPath, type, processedPaths, includeExternal);
+                result.push(...files.filter(f => (conditionalRule ? f.globs : !f.globs)));
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('EACCES')) {
+            logEvent('thaddeus_claude_rules_md_permission_error', {
+                is_access_error: 1,
+                has_home_dir: rulesDir.includes(getClaudeConfigHomeDir()) ? 1 : 0,
+            });
+        }
+        return [];
+    }
+}
+export const getMemoryFiles = memoize(async (forceIncludeExternal = false) => {
+    const startTime = Date.now();
+    logForDiagnosticsNoPII('info', 'memory_files_started');
+    const result = [];
+    const processedPaths = new Set();
+    const config = getCurrentProjectConfig();
+    const includeExternal = forceIncludeExternal ||
+        config.hasClaudeMdExternalIncludesApproved ||
+        false;
+    // Process Managed file first (always loaded - policy settings)
+    const managedClaudeMd = getMemoryPath('Managed');
+    result.push(...(await processMemoryFile(managedClaudeMd, 'Managed', processedPaths, includeExternal)));
+    // Process Managed .claude/rules/*.md files
+    const managedClaudeRulesDir = getManagedClaudeRulesDir();
+    result.push(...(await processMdRules({
+        rulesDir: managedClaudeRulesDir,
+        type: 'Managed',
+        processedPaths,
+        includeExternal,
+        conditionalRule: false,
+    })));
+    // Process User file (only if userSettings is enabled)
+    if (isSettingSourceEnabled('userSettings')) {
+        const userClaudeMd = getMemoryPath('User');
+        result.push(...(await processMemoryFile(userClaudeMd, 'User', processedPaths, true)));
+        // Process User ~/.claude/rules/*.md files
+        const userClaudeRulesDir = getUserClaudeRulesDir();
+        result.push(...(await processMdRules({
+            rulesDir: userClaudeRulesDir,
+            type: 'User',
+            processedPaths,
+            includeExternal: true,
+            conditionalRule: false,
+        })));
+    }
+    // Then process Project and Local files
+    const dirs = [];
+    const originalCwd = getOriginalCwd();
+    let currentDir = originalCwd;
+    while (currentDir !== parse(currentDir).root) {
+        dirs.push(currentDir);
+        currentDir = dirname(currentDir);
+    }
+    // When running from a git worktree nested inside its main repo (e.g.,
+    // .claude/worktrees/<name>/ from `claude -w`), the upward walk passes
+    // through both the worktree root and the main repo root. Both contain
+    // checked-in files like CLAUDE.md and .claude/rules/*.md, so the same
+    // content gets loaded twice. Skip Project-type (checked-in) files from
+    // directories above the worktree but within the main repo — the worktree
+    // already has its own checkout. CLAUDE.local.md is gitignored so it only
+    // exists in the main repo and is still loaded.
+    // See: https://github.com/anthropics/claude-code/issues/29599
+    const gitRoot = findGitRoot(originalCwd);
+    const canonicalRoot = findCanonicalGitRoot(originalCwd);
+    const isNestedWorktree = gitRoot !== null &&
+        canonicalRoot !== null &&
+        normalizePathForComparison(gitRoot) !==
+            normalizePathForComparison(canonicalRoot) &&
+        pathInWorkingPath(gitRoot, canonicalRoot);
+    // Process from root downward to CWD
+    for (const dir of dirs.reverse()) {
+        // In a nested worktree, skip checked-in files from the main repo's
+        // working tree (dirs inside canonicalRoot but outside the worktree).
+        const skipProject = isNestedWorktree &&
+            pathInWorkingPath(dir, canonicalRoot) &&
+            !pathInWorkingPath(dir, gitRoot);
+        // Try reading CLAUDE.md (Project) - only if projectSettings is enabled
+        if (isSettingSourceEnabled('projectSettings') && !skipProject) {
+            const projectPath = join(dir, 'THADDEUS.md');
+            result.push(...(await processMemoryFile(projectPath, 'Project', processedPaths, includeExternal)));
+            // Try reading .claude/CLAUDE.md (Project)
+            const dotClaudePath = join(dir, '.claude', 'THADDEUS.md');
+            result.push(...(await processMemoryFile(dotClaudePath, 'Project', processedPaths, includeExternal)));
+            // Try reading .claude/rules/*.md files (Project)
+            const rulesDir = join(dir, '.claude', 'rules');
+            result.push(...(await processMdRules({
+                rulesDir,
+                type: 'Project',
+                processedPaths,
+                includeExternal,
+                conditionalRule: false,
+            })));
+        }
+        // Try reading CLAUDE.local.md (Local) - only if localSettings is enabled
+        if (isSettingSourceEnabled('localSettings')) {
+            const localPath = join(dir, 'THADDEUS.local.md');
+            result.push(...(await processMemoryFile(localPath, 'Local', processedPaths, includeExternal)));
+        }
+    }
+    // Process CLAUDE.md from additional directories (--add-dir) if env var is enabled
+    // This is controlled by THADDEUS_ADDITIONAL_DIRECTORIES_CLAUDE_MD and defaults to off
+    // Note: we don't check isSettingSourceEnabled('projectSettings') here because --add-dir
+    // is an explicit user action and the SDK defaults settingSources to [] when not specified
+    if (isEnvTruthy(process.env.THADDEUS_ADDITIONAL_DIRECTORIES_CLAUDE_MD)) {
+        const additionalDirs = getAdditionalDirectoriesForClaudeMd();
+        for (const dir of additionalDirs) {
+            // Try reading CLAUDE.md from the additional directory
+            const projectPath = join(dir, 'THADDEUS.md');
+            result.push(...(await processMemoryFile(projectPath, 'Project', processedPaths, includeExternal)));
+            // Try reading .claude/CLAUDE.md from the additional directory
+            const dotClaudePath = join(dir, '.claude', 'THADDEUS.md');
+            result.push(...(await processMemoryFile(dotClaudePath, 'Project', processedPaths, includeExternal)));
+            // Try reading .claude/rules/*.md files from the additional directory
+            const rulesDir = join(dir, '.claude', 'rules');
+            result.push(...(await processMdRules({
+                rulesDir,
+                type: 'Project',
+                processedPaths,
+                includeExternal,
+                conditionalRule: false,
+            })));
+        }
+    }
+    // Memdir entrypoint (memory.md) - only if feature is on and file exists
+    if (isAutoMemoryEnabled()) {
+        const { info: memdirEntry } = await safelyReadMemoryFileAsync(getAutoMemEntrypoint(), 'AutoMem');
+        if (memdirEntry) {
+            const normalizedPath = normalizePathForComparison(memdirEntry.path);
+            if (!processedPaths.has(normalizedPath)) {
+                processedPaths.add(normalizedPath);
+                result.push(memdirEntry);
+            }
+        }
+    }
+    // Team memory entrypoint - only if feature is on and file exists
+    if (feature('TEAMMEM') && teamMemPaths.isTeamMemoryEnabled()) {
+        const { info: teamMemEntry } = await safelyReadMemoryFileAsync(teamMemPaths.getTeamMemEntrypoint(), 'TeamMem');
+        if (teamMemEntry) {
+            const normalizedPath = normalizePathForComparison(teamMemEntry.path);
+            if (!processedPaths.has(normalizedPath)) {
+                processedPaths.add(normalizedPath);
+                result.push(teamMemEntry);
+            }
+        }
+    }
+    const totalContentLength = result.reduce((sum, f) => sum + f.content.length, 0);
+    logForDiagnosticsNoPII('info', 'memory_files_completed', {
+        duration_ms: Date.now() - startTime,
+        file_count: result.length,
+        total_content_length: totalContentLength,
+    });
+    const typeCounts = {};
+    for (const f of result) {
+        typeCounts[f.type] = (typeCounts[f.type] ?? 0) + 1;
+    }
+    if (!hasLoggedInitialLoad) {
+        hasLoggedInitialLoad = true;
+        logEvent('thaddeus_claudemd__initial_load', {
+            file_count: result.length,
+            total_content_length: totalContentLength,
+            user_count: typeCounts['User'] ?? 0,
+            project_count: typeCounts['Project'] ?? 0,
+            local_count: typeCounts['Local'] ?? 0,
+            managed_count: typeCounts['Managed'] ?? 0,
+            automem_count: typeCounts['AutoMem'] ?? 0,
+            ...(feature('TEAMMEM')
+                ? { teammem_count: typeCounts['TeamMem'] ?? 0 }
+                : {}),
+            duration_ms: Date.now() - startTime,
+        });
+    }
+    // Fire InstructionsLoaded hook for each instruction file loaded
+    // (fire-and-forget, audit/observability only).
+    // AutoMem/TeamMem are intentionally excluded — they're a separate
+    // memory system, not "instructions" in the CLAUDE.md/rules sense.
+    // Gated on !forceIncludeExternal: the forceIncludeExternal=true variant
+    // is only used by getExternalClaudeMdIncludes() for approval checks, not
+    // for building context — firing the hook there would double-fire on startup.
+    // The one-shot flag is consumed on every !forceIncludeExternal cache miss
+    // (NOT gated on hasInstructionsLoadedHook) so the flag is released even
+    // when no hook is configured — otherwise a mid-session hook registration
+    // followed by a direct .cache.clear() would spuriously fire with a stale
+    // 'session_start' reason.
+    if (!forceIncludeExternal) {
+        const eagerLoadReason = consumeNextEagerLoadReason();
+        if (eagerLoadReason !== undefined && hasInstructionsLoadedHook()) {
+            for (const file of result) {
+                if (!isInstructionsMemoryType(file.type))
+                    continue;
+                const loadReason = file.parent ? 'include' : eagerLoadReason;
+                void executeInstructionsLoadedHooks(file.path, file.type, loadReason, {
+                    globs: file.globs,
+                    parentFilePath: file.parent,
+                });
+            }
+        }
+    }
+    return result;
+});
+function isInstructionsMemoryType(type) {
+    return (type === 'User' ||
+        type === 'Project' ||
+        type === 'Local' ||
+        type === 'Managed');
+}
+// Load reason to report for top-level (non-included) files on the next eager
+// getMemoryFiles() pass. Set to 'compact' by resetGetMemoryFilesCache when
+// compaction clears the cache, so the InstructionsLoaded hook reports the
+// reload correctly instead of misreporting it as 'session_start'. One-shot:
+// reset to 'session_start' after being read.
+let nextEagerLoadReason = 'session_start';
+// Whether the InstructionsLoaded hook should fire on the next cache miss.
+// true initially (for session_start), consumed after firing, re-enabled only
+// by resetGetMemoryFilesCache(). Callers that only need cache invalidation
+// for correctness (e.g. worktree enter/exit, settings sync, /memory dialog)
+// should use clearMemoryFileCaches() instead to avoid spurious hook fires.
+let shouldFireHook = true;
+function consumeNextEagerLoadReason() {
+    if (!shouldFireHook)
+        return undefined;
+    shouldFireHook = false;
+    const reason = nextEagerLoadReason;
+    nextEagerLoadReason = 'session_start';
+    return reason;
+}
+/**
+ * Clears the getMemoryFiles memoize cache
+ * without firing the InstructionsLoaded hook.
+ *
+ * Use this for cache invalidation that is purely for correctness (e.g.
+ * worktree enter/exit, settings sync, /memory dialog). For events that
+ * represent instructions actually being reloaded into context (e.g.
+ * compaction), use resetGetMemoryFilesCache() instead.
+ */
+export function clearMemoryFileCaches() {
+    // ?.cache because tests spyOn this, which replaces the memoize wrapper.
+    getMemoryFiles.cache?.clear?.();
+}
+export function resetGetMemoryFilesCache(reason = 'session_start') {
+    nextEagerLoadReason = reason;
+    shouldFireHook = true;
+    clearMemoryFileCaches();
+}
+export function getLargeMemoryFiles(files) {
+    return files.filter(f => f.content.length > MAX_MEMORY_CHARACTER_COUNT);
+}
+/**
+ * When thaddeus_moth_copse is on, the findRelevantMemories prefetch surfaces
+ * memory files via attachments, so the MEMORY.md index is no longer injected
+ * into the system prompt. Callsites that care about "what's actually in
+ * context" (context builder, /context viz) should filter through this.
+ */
+export function filterInjectedMemoryFiles(files) {
+    const skipMemoryIndex = getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_moth_copse', false);
+    if (!skipMemoryIndex)
+        return files;
+    return files.filter(f => f.type !== 'AutoMem' && f.type !== 'TeamMem');
+}
+export const getClaudeMds = (memoryFiles, filter) => {
+    const memories = [];
+    const skipProjectLevel = getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_paper_halyard', false);
+    for (const file of memoryFiles) {
+        if (filter && !filter(file.type))
+            continue;
+        if (skipProjectLevel && (file.type === 'Project' || file.type === 'Local'))
+            continue;
+        if (file.content) {
+            const description = file.type === 'Project'
+                ? ' (project instructions, checked into the codebase)'
+                : file.type === 'Local'
+                    ? " (user's private project instructions, not checked in)"
+                    : feature('TEAMMEM') && file.type === 'TeamMem'
+                        ? ' (shared team memory, synced across the organization)'
+                        : file.type === 'AutoMem'
+                            ? " (user's auto-memory, persists across conversations)"
+                            : " (user's private global instructions for all projects)";
+            const content = file.content.trim();
+            if (feature('TEAMMEM') && file.type === 'TeamMem') {
+                memories.push(`Contents of ${file.path}${description}:\n\n<team-memory-content source="shared">\n${content}\n</team-memory-content>`);
+            }
+            else {
+                memories.push(`Contents of ${file.path}${description}:\n\n${content}`);
+            }
+        }
+    }
+    if (memories.length === 0) {
+        return '';
+    }
+    return `${MEMORY_INSTRUCTION_PROMPT}\n\n${memories.join('\n\n')}`;
+};
+/**
+ * Gets managed and user conditional rules that match the target path.
+ * This is the first phase of nested memory loading.
+ *
+ * @param targetPath The target file path to match against glob patterns
+ * @param processedPaths Set of already processed file paths (will be mutated)
+ * @returns Array of MemoryFileInfo objects for matching conditional rules
+ */
+export async function getManagedAndUserConditionalRules(targetPath, processedPaths) {
+    const result = [];
+    // Process Managed conditional .claude/rules/*.md files
+    const managedClaudeRulesDir = getManagedClaudeRulesDir();
+    result.push(...(await processConditionedMdRules(targetPath, managedClaudeRulesDir, 'Managed', processedPaths, false)));
+    if (isSettingSourceEnabled('userSettings')) {
+        // Process User conditional .claude/rules/*.md files
+        const userClaudeRulesDir = getUserClaudeRulesDir();
+        result.push(...(await processConditionedMdRules(targetPath, userClaudeRulesDir, 'User', processedPaths, true)));
+    }
+    return result;
+}
+/**
+ * Gets memory files for a single nested directory (between CWD and target).
+ * Loads CLAUDE.md, unconditional rules, and conditional rules for that directory.
+ *
+ * @param dir The directory to process
+ * @param targetPath The target file path (for conditional rule matching)
+ * @param processedPaths Set of already processed file paths (will be mutated)
+ * @returns Array of MemoryFileInfo objects
+ */
+export async function getMemoryFilesForNestedDirectory(dir, targetPath, processedPaths) {
+    const result = [];
+    // Process project memory files (CLAUDE.md and .claude/CLAUDE.md)
+    if (isSettingSourceEnabled('projectSettings')) {
+        const projectPath = join(dir, 'THADDEUS.md');
+        result.push(...(await processMemoryFile(projectPath, 'Project', processedPaths, false)));
+        const dotClaudePath = join(dir, '.claude', 'THADDEUS.md');
+        result.push(...(await processMemoryFile(dotClaudePath, 'Project', processedPaths, false)));
+    }
+    // Process local memory file (CLAUDE.local.md)
+    if (isSettingSourceEnabled('localSettings')) {
+        const localPath = join(dir, 'THADDEUS.local.md');
+        result.push(...(await processMemoryFile(localPath, 'Local', processedPaths, false)));
+    }
+    const rulesDir = join(dir, '.claude', 'rules');
+    // Process project unconditional .claude/rules/*.md files, which were not eagerly loaded
+    // Use a separate processedPaths set to avoid marking conditional rule files as processed
+    const unconditionalProcessedPaths = new Set(processedPaths);
+    result.push(...(await processMdRules({
+        rulesDir,
+        type: 'Project',
+        processedPaths: unconditionalProcessedPaths,
+        includeExternal: false,
+        conditionalRule: false,
+    })));
+    // Process project conditional .claude/rules/*.md files
+    result.push(...(await processConditionedMdRules(targetPath, rulesDir, 'Project', processedPaths, false)));
+    // processedPaths must be seeded with unconditional paths for subsequent directories
+    for (const path of unconditionalProcessedPaths) {
+        processedPaths.add(path);
+    }
+    return result;
+}
+/**
+ * Gets conditional rules for a CWD-level directory (from root up to CWD).
+ * Only processes conditional rules since unconditional rules are already loaded eagerly.
+ *
+ * @param dir The directory to process
+ * @param targetPath The target file path (for conditional rule matching)
+ * @param processedPaths Set of already processed file paths (will be mutated)
+ * @returns Array of MemoryFileInfo objects
+ */
+export async function getConditionalRulesForCwdLevelDirectory(dir, targetPath, processedPaths) {
+    const rulesDir = join(dir, '.claude', 'rules');
+    return processConditionedMdRules(targetPath, rulesDir, 'Project', processedPaths, false);
+}
+/**
+ * Processes all .md files in the .claude/rules/ directory and its subdirectories,
+ * filtering to only include files with frontmatter paths that match the target path
+ * @param targetPath The file path to match against frontmatter glob patterns
+ * @param rulesDir The path to the rules directory
+ * @param type Type of memory file (User, Project, Local)
+ * @param processedPaths Set of already processed file paths
+ * @param includeExternal Whether to include external files
+ * @returns Array of MemoryFileInfo objects that match the target path
+ */
+export async function processConditionedMdRules(targetPath, rulesDir, type, processedPaths, includeExternal) {
+    const conditionedRuleMdFiles = await processMdRules({
+        rulesDir,
+        type,
+        processedPaths,
+        includeExternal,
+        conditionalRule: true,
+    });
+    // Filter to only include files whose globs patterns match the targetPath
+    return conditionedRuleMdFiles.filter(file => {
+        if (!file.globs || file.globs.length === 0) {
+            return false;
+        }
+        // For Project rules: glob patterns are relative to the directory containing .claude
+        // For Managed/User rules: glob patterns are relative to the original CWD
+        const baseDir = type === 'Project'
+            ? dirname(dirname(rulesDir)) // Parent of .claude
+            : getOriginalCwd(); // Project root for managed/user rules
+        const relativePath = isAbsolute(targetPath)
+            ? relative(baseDir, targetPath)
+            : targetPath;
+        // ignore() throws on empty strings, paths escaping the base (../),
+        // and absolute paths (Windows cross-drive relative() returns absolute).
+        // Files outside baseDir can't match baseDir-relative globs anyway.
+        if (!relativePath ||
+            relativePath.startsWith('..') ||
+            isAbsolute(relativePath)) {
+            return false;
+        }
+        return ignore().add(file.globs).ignores(relativePath);
+    });
+}
+export function getExternalClaudeMdIncludes(files) {
+    const externals = [];
+    for (const file of files) {
+        if (file.type !== 'User' && file.parent && !pathInOriginalCwd(file.path)) {
+            externals.push({ path: file.path, parent: file.parent });
+        }
+    }
+    return externals;
+}
+export function hasExternalClaudeMdIncludes(files) {
+    return getExternalClaudeMdIncludes(files).length > 0;
+}
+export async function shouldShowClaudeMdExternalIncludesWarning() {
+    const config = getCurrentProjectConfig();
+    if (config.hasClaudeMdExternalIncludesApproved ||
+        config.hasClaudeMdExternalIncludesWarningShown) {
+        return false;
+    }
+    return hasExternalClaudeMdIncludes(await getMemoryFiles(true));
+}
+/**
+ * Check if a file path is a memory file (CLAUDE.md, CLAUDE.local.md, or .claude/rules/*.md)
+ */
+export function isMemoryFilePath(filePath) {
+    const name = basename(filePath);
+    // CLAUDE.md or CLAUDE.local.md anywhere
+    if (name === 'THADDEUS.md' || name === 'THADDEUS.local.md') {
+        return true;
+    }
+    // .md files in .claude/rules/ directories
+    if (name.endsWith('.md') &&
+        filePath.includes(`${sep}.claude${sep}rules${sep}`)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get all memory file paths from both standard discovery and readFileState.
+ * Combines:
+ * - getMemoryFiles() paths (CWD upward to root)
+ * - readFileState paths matching memory patterns (includes child directories)
+ */
+export function getAllMemoryFilePaths(files, readFileState) {
+    const paths = new Set();
+    for (const file of files) {
+        if (file.content.trim().length > 0) {
+            paths.add(file.path);
+        }
+    }
+    // Add memory files from readFileState (includes child directories)
+    for (const filePath of cacheKeys(readFileState)) {
+        if (isMemoryFilePath(filePath)) {
+            paths.add(filePath);
+        }
+    }
+    return Array.from(paths);
+}