@nexrall/code-core 1.4.71 → 1.4.72

package/dist/agent/nestedInstructions.js

@@ -0,0 +1,696 @@
+"use strict";
+// Discovered instruction files: `<dir>/nexrall.md` and rule files under
+// `.nexrall/rules/` — the instructions half of the same 2.1.x behaviour skills.ts
+// implements for skills.
+//
+// Claude Code loads a subdirectory's CLAUDE.md once it works with files there, and
+// the file then stays in context for the rest of the session. Same shape here, one
+// level per ancestor: as a tool call touches `packages/cli/src/x.ts`, every directory
+// from `packages/cli/src` up to (but excluding) the project root is checked for its
+// own `nexrall.md`/`NEXRALL.md`. The ROOT file is the session brief's job — read by
+// `readNexrallMd` (CLI) / `_readNexrallMd` (VS Code) at session start — so it is
+// deliberately not re-read here.
+//
+// The second tier is `.nexrall/rules/**/*.md` (S18d), Claude Code's `.claude/rules/`
+// shape: standalone instruction files that say what they scope to in frontmatter.
+//
+//   • No `paths:` (or `globs:`) frontmatter → UNCONDITIONAL: the rule applies from
+//     the session's first request. Root-level unconditional rules load once, up
+//     front; an unconditional rule in a subdirectory's `.nexrall/rules/` loads when
+//     that subtree is first touched (the nested-CLAUDE.md timing).
+//   • `paths:` frontmatter → PATH-SCOPED: the rule loads only when a tool call
+//     touches a project-relative path matching one of its globs (shared with CC:
+//     `**`, `*`, `?`, `{a,b}`, `[abc]`; comma string or YAML list). It then stays
+//     for the session like everything in the ledger.
+//   • Frontmatter never reaches the prompt — only the body after the closing `---`.
+//   • Symlinks are never followed: a cloned repo must not be able to point a "rule"
+//     at, say, `~/.ssh/id_rsa` and have it injected as instructions.
+//
+// Two deliberate properties:
+//   • LAZY: only directories the agent has actually worked in are loaded; a repo full
+//     of subtree conventions costs nothing until the subtree is touched.
+//   • A LEDGER: once loaded, a file stays loaded. The host owns the scanner and passes
+//     it to every run of the session, because conventions that silently vanished
+//     between turns would be worse than not having them. `refresh()` re-reads files
+//     from disk (/reload), because content edits have no other way in.
+//
+// Directories are re-checked on every touch (a plain existsSync — the `loaded` map is
+// what makes re-reads impossible), so a nexrall.md or a rules file CREATED mid-session
+// — the agent writing one, /init-style — applies from the request after the write. The
+// ignore policy is skills.ts's `isIgnoredNestedDir`: a dependency checkout is not where
+// the user keeps briefs, and scanning node_modules would turn any dependency touch into
+// a prompt-injection vector. (The ignore gate does not apply to the ROOT `.nexrall/`,
+// which is the project's own configuration dir.)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedInstructionScanner = exports.NESTED_INSTRUCTIONS_TOTAL = exports.NESTED_INSTRUCTIONS_PER_FILE = void 0;
+exports.pathGlobToRegExp = pathGlobToRegExp;
+exports.extractPathGlobs = extractPathGlobs;
+exports.formatNestedInstructions = formatNestedInstructions;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const skills_1 = require("./skills");
+const frontmatter_1 = require("../util/frontmatter");
+/**
+ * Caps: discovered files ride the system prompt on EVERY request of the session, so a
+ * pathological (or hostile, from a cloned repo) subdirectory file must not be able to
+ * crowd out the real project brief. Truncation is visible; the same pattern as the
+ * MCP-instructions caps.
+ */
+exports.NESTED_INSTRUCTIONS_PER_FILE = 4000;
+exports.NESTED_INSTRUCTIONS_TOTAL = 12000;
+/**
+ * Nested candidate names — the root's own `nexrall.md`/`NEXRALL.md` family. The root's
+ * extra candidates (`.nexrall/instructions.md`, `.nexrall/config.md`) are a project-level
+ * indirection and stay out of the nested tier on purpose.
+ */
+const NESTED_MD_CANDIDATES = ['nexrall.md', 'NEXRALL.md'];
+/** The rules directory, relative to the project root or any subdirectory. */
+const RULES_SUBPATH = ['.nexrall', 'rules'];
+/** Parent-first (fewer segments first), then alphabetical — the order the prompt shows. */
+function compareNestedInstructions(a, b) {
+    const da = a.relPath.split('/').length;
+    const db = b.relPath.split('/').length;
+    return da !== db ? da - db : a.relPath.localeCompare(b.relPath);
+}
+function tryReadFile(p) {
+    try {
+        return fs.readFileSync(p, 'utf-8').trim();
+    }
+    catch {
+        return null;
+    }
+}
+function relPosix(workDir, file) {
+    return path.relative(path.resolve(workDir), file).split(path.sep).join('/');
+}
+// ─── `paths:` globs (S18d) ─────────────────────────────────────────────────────
+//
+// The matcher is a real glob compiler, not the segment-and-boundary matcher
+// `/exclude` uses (contextFiles.ts): CC's documented rule patterns look like
+// `src/**/*.{ts,tsx}` / `lib/**/*.ts` / `**/*.test.ts`, so `**` must cross
+// separators, `**/` must collapse to zero-or-more whole segments, and brace
+// alternation and character classes must work. Patterns are anchored to the
+// project root and matched against project-relative POSIX paths.
+const compiledGlobs = new Map();
+const MAX_BRACE_DEPTH = 8;
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Index of the brace matching the `{` at `start`, or -1. Backslash escapes are honoured. */
+function findClosingBrace(s, start) {
+    let depth = 0;
+    for (let i = start; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '\\') {
+            i++;
+            continue;
+        }
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** Split brace alternatives on TOP-LEVEL commas only (`{a,b{c,d}}` → `a`, `b{c,d}`). */
+function splitTopLevelCommas(inner) {
+    const out = [];
+    let depth = 0;
+    let cur = '';
+    for (const ch of inner) {
+        if (ch === '{')
+            depth++;
+        else if (ch === '}')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    out.push(cur);
+    return out;
+}
+function compileGlob(glob, depth) {
+    let re = '';
+    let i = 0;
+    while (i < glob.length) {
+        const ch = glob[i];
+        if (ch === '\\' && i + 1 < glob.length) {
+            re += escapeRe(glob[i + 1]);
+            i += 2;
+            continue;
+        }
+        if (ch === '*') {
+            if (glob[i + 1] === '*') {
+                // `**/` = zero or more whole segments — so `src/**/*.ts` matches `src/a.ts`
+                // too. A trailing/mid `**` not followed by `/` crosses separators as-is.
+                if (glob[i + 2] === '/') {
+                    re += '(?:[^/]+/)*';
+                    i += 3;
+                    continue;
+                }
+                re += '.*';
+                i += 2;
+                continue;
+            }
+            re += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (ch === '?') {
+            re += '[^/]';
+            i += 1;
+            continue;
+        }
+        if (ch === '{' && depth < MAX_BRACE_DEPTH) {
+            const end = findClosingBrace(glob, i);
+            if (end !== -1) {
+                const alts = splitTopLevelCommas(glob.slice(i + 1, end));
+                re += `(?:${alts.map((a) => compileGlob(a, depth + 1)).join('|')})`;
+                i = end + 1;
+                continue;
+            }
+            re += '\\{';
+            i += 1;
+            continue;
+        }
+        if (ch === '[') {
+            // Character class. A `]` may appear literally right after `[` / `[!` / `[^`;
+            // otherwise the class ends at the first `]`. No escapes inside classes —
+            // deliberate simplification (real rule patterns do not use them).
+            let j = i + 1;
+            if (glob[j] === '!' || glob[j] === '^')
+                j++;
+            if (glob[j] === ']')
+                j++;
+            for (; j < glob.length && glob[j] !== ']'; j++) {
+                /* find the end */
+            }
+            if (j < glob.length) {
+                let cls = glob.slice(i + 1, j);
+                let neg = false;
+                if (cls[0] === '!' || cls[0] === '^') {
+                    neg = true;
+                    cls = cls.slice(1);
+                }
+                // `-` is kept for ranges; regex-metacharacters that mean themselves in a
+                // glob class are escaped.
+                cls = cls.replace(/[\\\]^]/g, '\\$&');
+                re += `[${neg ? '^' : ''}${cls}]`;
+                i = j + 1;
+                continue;
+            }
+            re += '\\[';
+            i += 1;
+            continue;
+        }
+        re += escapeRe(ch);
+        i += 1;
+    }
+    return re;
+}
+/**
+ * Compile one `paths:` glob to an anchored RegExp over project-relative POSIX paths,
+ * or null when the pattern is empty / fails to compile (callers treat null as
+ * non-matching). Compiled once per pattern string, cached for the process.
+ */
+function pathGlobToRegExp(pattern) {
+    const cleaned = pattern.trim().replace(/^\.\//, '').replace(/^\/+/, '');
+    if (!cleaned)
+        return null;
+    const cached = compiledGlobs.get(cleaned);
+    if (cached !== undefined)
+        return cached;
+    let rx;
+    try {
+        rx = new RegExp(`^${compileGlob(cleaned, 0)}$`);
+    }
+    catch {
+        rx = null;
+    }
+    compiledGlobs.set(cleaned, rx);
+    return rx;
+}
+/** True when the project-relative path matches any of the rule's globs. */
+function matchesAnyGlob(patterns, rel) {
+    return patterns.some((p) => {
+        const rx = pathGlobToRegExp(p);
+        return rx ? rx.test(rel) : false;
+    });
+}
+function leadingIndent(line) {
+    const m = /^[ \t]*/.exec(line);
+    return m ? m[0].length : 0;
+}
+function unquoteYaml(v) {
+    return v.trim().replace(/^["']|["']$/g, '');
+}
+/**
+ * Read the `paths:` (alias `globs:`) frontmatter of a rule file. Returns null when
+ * there is no frontmatter, the key is absent, or it lists nothing — all of which mean
+ * UNCONDITIONAL. Accepts the three shapes CC's docs and real files use: a block list
+ * (`paths:\n  - glob`), a comma-separated string, and a flow list (`["a", "b"]`).
+ * Only top-level keys count — an indented `paths:` inside a nested map is that map's
+ * field, the same isolation util/frontmatter applies.
+ */
+function extractPathGlobs(raw) {
+    const m = /^\s*---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(raw);
+    if (!m)
+        return null;
+    const lines = m[1].split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        if (leadingIndent(lines[i]) > 0)
+            continue;
+        const kv = /^(paths|globs)\s*:\s*(.*)$/i.exec(lines[i].trim());
+        if (!kv)
+            continue;
+        const inline = kv[2].trim();
+        if (inline)
+            return splitGlobList(inline);
+        const items = [];
+        for (let j = i + 1; j < lines.length; j++) {
+            if (!lines[j].trim())
+                continue;
+            if (leadingIndent(lines[j]) === 0)
+                break; // the next top-level key
+            const li = /^\s*-\s*(.*)$/.exec(lines[j]);
+            if (li) {
+                const v = unquoteYaml(li[1]);
+                if (v)
+                    items.push(v);
+            }
+        }
+        return items.length ? items : null;
+    }
+    return null;
+}
+/** Comma-separated string or flow list → globs. Quoted items keep embedded commas. */
+function splitGlobList(value) {
+    let s = value.trim();
+    if (s.startsWith('[') && s.endsWith(']'))
+        s = s.slice(1, -1);
+    const out = [];
+    let cur = '';
+    let quote = null;
+    for (const ch of s) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === ',') {
+            const v = cur.trim();
+            if (v)
+                out.push(v);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    const last = cur.trim();
+    if (last)
+        out.push(last);
+    return out.length ? out : null;
+}
+/**
+ * Every `.md` file under a rules directory, recursive, sorted, SYMLINKS SKIPPED —
+ * following one would let a cloned repo inject an arbitrary file (say
+ * `~/.aws/credentials`) as "instructions". A directory that does not exist is
+ * empty, not an error.
+ */
+function walkRulesDir(base) {
+    const out = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+            if (e.isSymbolicLink())
+                continue;
+            const p = path.join(dir, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (e.isFile() && e.name.toLowerCase().endsWith('.md'))
+                out.push(p);
+        }
+    };
+    walk(base);
+    return out;
+}
+/**
+ * Discovers `nexrall.md` briefs and `.nexrall/rules` files as the agent works (see the
+ * section comment above). Stateful across calls by design — the loaded set IS the
+ * feature (and the callback dedupe), so the host that owns a session keeps ONE
+ * instance and passes it to every run.
+ */
+class NestedInstructionScanner {
+    constructor(workDir) {
+        this.workDir = workDir;
+        this.loaded = new Map();
+        this.ignored = new Map();
+        /** dir → the real on-disk path of its brief (casing resolved once, on the first hit). */
+        this.resolved = new Map();
+        /** rule file → parsed metadata: globs (null = unconditional) + frontmatter-stripped body. */
+        this.ruleMeta = new Map();
+        /** Root unconditional rules load once per session state; refresh() re-arms. */
+        this.rootInitialized = false;
+    }
+    /**
+     * Load the root's unconditional rules and return them — the HOST calls this at
+     * session start so they are announced with `session_start` alongside the brief and
+     * memory. A host that skips it still gets the rules from the first `list()`; it
+     * just has no announcement to make.
+     */
+    initialRules() {
+        return this.ensureRootRules();
+    }
+    /**
+     * Scan the tool input of one call for filesystem paths and return the instruction
+     * files this call loaded (usually none). A failed tool call still scans: intent
+     * marks the area even when the file itself was missing.
+     */
+    scanInput(input) {
+        const out = [];
+        for (const key of skills_1.NESTED_PATH_INPUT_KEYS) {
+            const v = input[key];
+            if (typeof v !== 'string' || !v || v.length > 4096)
+                continue;
+            out.push(...this.scanPath(v));
+        }
+        return out;
+    }
+    /** Scan the ancestor chain of one touched path; returns the files newly loaded by this call. */
+    scanPath(touched) {
+        let abs;
+        try {
+            abs = path.isAbsolute(touched) ? touched : path.join(this.workDir, touched);
+        }
+        catch {
+            return [];
+        }
+        let base = abs;
+        try {
+            if (!fs.statSync(abs).isDirectory())
+                base = path.dirname(abs);
+        }
+        catch {
+            base = path.dirname(abs); // a path being created: its directory is the claim
+        }
+        const work = path.resolve(this.workDir);
+        const relTouched = relPosix(work, abs);
+        const out = [];
+        let dir = base;
+        for (;;) {
+            const rel = path.relative(work, dir);
+            if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+                break;
+            if (!(0, skills_1.isIgnoredNestedDir)(this.workDir, dir, this.ignored)) {
+                const found = this.checkDir(dir);
+                if (found && !this.loaded.has(found)) {
+                    const content = tryReadFile(found);
+                    if (content !== null) {
+                        const entry = {
+                            filePath: found,
+                            relPath: path.relative(work, found).split(path.sep).join('/'),
+                            content,
+                            kind: 'brief',
+                            loadReason: 'nested_traversal',
+                        };
+                        this.loaded.set(found, entry);
+                        out.push(entry);
+                    }
+                }
+                out.push(...this.scanRulesDir(path.join(dir, ...RULES_SUBPATH), relTouched));
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        // Path-scoped ROOT rules: matched against this touch, regardless of the ancestor
+        // chain (their scope is the glob, not a directory). Unconditional root rules are
+        // ensureRootRules()'s job.
+        if (!relTouched.startsWith('..'))
+            out.push(...this.scanRootRulesFor(relTouched));
+        return out;
+    }
+    /** Everything loaded so far, parent-first — what the prompt renders. */
+    list() {
+        this.ensureRootRules();
+        return [...this.loaded.values()].sort(compareNestedInstructions);
+    }
+    /**
+     * Re-read every loaded file from disk; files that no longer exist are dropped.
+     * The `/reload` escape hatch for content edits — returns how many entries changed
+     * or vanished, so a caller can report it (0 = nothing to say). Root rules are
+     * re-listed, so an unconditional rule file created since the session started (or
+     * one whose frontmatter lost its `paths:`) joins here; new path-scoped files load
+     * on their next matching touch.
+     */
+    refresh() {
+        let changed = 0;
+        this.ruleMeta.clear();
+        this.rootInitialized = false;
+        for (const [file, entry] of [...this.loaded]) {
+            let content;
+            if (entry.kind === 'rule') {
+                const meta = this.ruleMetaOf(file);
+                content = meta && meta.content ? meta.content : null;
+            }
+            else {
+                content = tryReadFile(file);
+            }
+            if (content === null) {
+                this.loaded.delete(file);
+                changed++;
+            }
+            else if (content !== entry.content) {
+                entry.content = content;
+                changed++;
+            }
+        }
+        changed += this.ensureRootRules().length;
+        return changed;
+    }
+    /** Root unconditional rules: root listing once per session state, `session_start`. */
+    ensureRootRules() {
+        const out = [];
+        if (this.rootInitialized)
+            return out;
+        this.rootInitialized = true;
+        for (const file of walkRulesDir(path.join(this.workDir, ...RULES_SUBPATH))) {
+            const entry = this.loadRule(file, 'session_start', null);
+            if (entry)
+                out.push(entry);
+        }
+        return out;
+    }
+    /** Root path-scoped rules matching this touch ('path_glob_match'). */
+    scanRootRulesFor(relTouched) {
+        const out = [];
+        for (const file of walkRulesDir(path.join(this.workDir, ...RULES_SUBPATH))) {
+            if (this.loaded.has(file))
+                continue;
+            const meta = this.ruleMetaOf(file);
+            if (!meta || meta.patterns === null)
+                continue; // unconditional → ensureRootRules
+            const entry = this.loadRule(file, 'path_glob_match', relTouched);
+            if (entry)
+                out.push(entry);
+        }
+        return out;
+    }
+    /**
+     * Rules a directory carries (`<dir>/.nexrall/rules`): unconditional ones load with
+     * the touch (`nested_traversal` — the same timing as that directory's brief);
+     * path-scoped ones load when this touch matches (`path_glob_match`).
+     */
+    scanRulesDir(base, relTouched) {
+        const out = [];
+        for (const file of walkRulesDir(base)) {
+            const entry = this.loadRule(file, 'nested_traversal', relTouched);
+            if (entry)
+                out.push(entry);
+        }
+        return out;
+    }
+    /**
+     * Load one rule file if it should be — dedupe, parse, scope decision. `fallbackReason`
+     * is the reason an UNCONDITIONAL rule loads with; `relTouched` (null = no touch yet)
+     * is what path-scoped globs are tested against. Returns the new entry or null.
+     */
+    loadRule(file, fallbackReason, relTouched) {
+        if (this.loaded.has(file))
+            return null;
+        const meta = this.ruleMetaOf(file);
+        if (!meta || !meta.content)
+            return null; // unreadable or empty body: nothing to inject
+        let reason;
+        if (meta.patterns === null)
+            reason = fallbackReason;
+        else if (relTouched !== null && matchesAnyGlob(meta.patterns, relTouched))
+            reason = 'path_glob_match';
+        else
+            reason = null; // scoped, and this touch (if any) is out of scope
+        if (!reason)
+            return null;
+        const entry = {
+            filePath: file,
+            relPath: relPosix(this.workDir, file),
+            content: meta.content,
+            kind: 'rule',
+            loadReason: reason,
+        };
+        this.loaded.set(file, entry);
+        return entry;
+    }
+    /** Parsed metadata for a rule file, cached until refresh(). */
+    ruleMetaOf(file) {
+        const cached = this.ruleMeta.get(file);
+        if (cached)
+            return cached;
+        let raw;
+        try {
+            raw = fs.readFileSync(file, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+        const parsed = (0, frontmatter_1.parseFrontmatter)(raw);
+        const meta = {
+            patterns: parsed.ok ? extractPathGlobs(raw) : null,
+            content: (parsed.ok ? parsed.body : raw).trim(),
+        };
+        this.ruleMeta.set(file, meta);
+        return meta;
+    }
+    /**
+     * The instruction file a directory carries, or null. A directory WITHOUT one is
+     * re-checked on every touch (see the header), so a file created after the first scan
+     * is still found; a directory WITH one is resolved once — the ledger keeps its
+     * content, and deletion is `refresh()`'s business.
+     */
+    checkDir(dir) {
+        const known = this.resolved.get(dir);
+        if (known)
+            return known;
+        if ((0, skills_1.isIgnoredNestedDir)(this.workDir, dir, this.ignored))
+            return null;
+        for (const name of NESTED_MD_CANDIDATES) {
+            const p = path.join(dir, name);
+            try {
+                if (fs.statSync(p).isFile()) {
+                    const real = resolveRealName(dir, name);
+                    this.resolved.set(dir, real);
+                    return real;
+                }
+            }
+            catch {
+                /* try the next candidate */
+            }
+        }
+        return null;
+    }
+}
+exports.NestedInstructionScanner = NestedInstructionScanner;
+/**
+ * The path to REPORT for a probed candidate. On a case-insensitive filesystem the stat
+ * above can succeed for `NEXRALL.md` through a `nexrall.md` probe (macOS, Windows), and
+ * a ledger labelled with a path that does not exist verbatim is a small lie that breaks
+ * tests on exactly one OS. One readdir on the FIRST hit resolves the real name; exact
+ * spelling wins where both exist (Linux can carry both files).
+ */
+function resolveRealName(dir, probedBase) {
+    try {
+        const entries = fs.readdirSync(dir);
+        const real = entries.includes(probedBase)
+            ? probedBase
+            : entries.find((e) => e.toLowerCase() === probedBase.toLowerCase());
+        return path.join(dir, real ?? probedBase);
+    }
+    catch {
+        return path.join(dir, probedBase);
+    }
+}
+/**
+ * Render the discovered-instructions block, or null when there is nothing to inject —
+ * callers join the result with the project brief, and a null must not leave an empty
+ * section behind. Parent-first order makes a deeper file (the more specific one) read
+ * as the refinement of its ancestors, which is also how Claude Code orders nested
+ * CLAUDE.md context. Rules carry their own label so a file like `.nexrall/rules/x.md`
+ * is not mistaken for a subdirectory brief.
+ */
+function formatNestedInstructions(files) {
+    if (!files.length)
+        return null;
+    const parts = [];
+    const seen = new Set();
+    let used = 0;
+    for (const f of [...files].sort(compareNestedInstructions)) {
+        let text = f.content.trim();
+        if (!text || seen.has(f.relPath))
+            continue;
+        seen.add(f.relPath);
+        if (text.length > exports.NESTED_INSTRUCTIONS_PER_FILE) {
+            text = text.slice(0, exports.NESTED_INSTRUCTIONS_PER_FILE) + '\n[truncated]';
+        }
+        if (used + text.length > exports.NESTED_INSTRUCTIONS_TOTAL) {
+            parts.push(`(more instruction files omitted — the ${exports.NESTED_INSTRUCTIONS_TOTAL}-character budget was reached)`);
+            break;
+        }
+        used += text.length;
+        const label = f.kind === 'rule' ? 'Rule' : 'Subdirectory instructions';
+        parts.push(`[${label} — ${f.relPath}]\n${text}`);
+    }
+    return parts.length ? parts.join('\n\n---\n\n') : null;
+}
+//# sourceMappingURL=nestedInstructions.js.map