ucn 5.5.2 → 5.6.0

package/core/output-budget.js

@@ -3,22 +3,24 @@
 const {
     BROAD_COMMANDS: BROAD_CANONICAL,
     FLAG_APPLICABILITY,
+    paramDefault,
+    paramRange,
     resolveCommand,
-    toMcpName,
 } = require('./registry');
+const { LINES_COMMANDS, budgetLineListing } = require('./output/lines');
 
-const DEFAULT_OUTPUT_CHARS = 10000;
-const BROAD_OUTPUT_CHARS = 3000;
-const MAX_OUTPUT_CHARS = 100000;
-const BROAD_COMMANDS = new Set([
-    ...BROAD_CANONICAL,
-    ...[...BROAD_CANONICAL].map(toMcpName),
-]);
+// The output budget is the parameter table's `maxChars`: its ceiling, its
+// default, and the smaller default of the broad sweep commands.
+const DEFAULT_OUTPUT_CHARS = paramDefault('maxChars');
+const BROAD_OUTPUT_CHARS = paramDefault('maxChars', [...BROAD_CANONICAL][0]);
+const MAX_OUTPUT_CHARS = paramRange('maxChars').max;
 
-const CONTRACT_LINE_RE = /^\s*(?:(?:Summary|ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|VALUE ACCOUNT|TYPE ACCOUNT|Note):|\d+ test-file usage\(s\) hidden\b|Found \d+ (?:definitions|fuzzy matches)\b)/;
+const CONTRACT_LINE_RE = /^\s*(?:(?:Summary|ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|VALUE ACCOUNT|TYPE ACCOUNT|Note):|TRUST: (?:BLOCKED|REVIEW_REQUIRED|READY_FOR_TOOLCHAIN)\b|\d+ test-file usage\(s\) hidden\b|Found \d+ (?:definitions|fuzzy matches)\b)/;
 // Trust lines: the accounting and contract lines that qualify a caller
 // answer. A truncated answer carries every one of them or none of its body.
-const TRUST_LINE_RE = /^(?:ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|VALUE ACCOUNT|TYPE ACCOUNT):/;
+// The pre-commit check's verdict line is one of them (`repo` prints a
+// TRUST level of its own, which is orientation, not a verdict).
+const TRUST_LINE_RE = /^(?:(?:ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|VALUE ACCOUNT|TYPE ACCOUNT):|TRUST: (?:BLOCKED|REVIEW_REQUIRED|READY_FOR_TOOLCHAIN)\b)/;
 const MAX_PRESERVED_CONTRACT_LINES = 24;
 const MAX_PRESERVED_CONTRACT_CHARS = 8000;
 
@@ -139,7 +141,9 @@ function compactNarrowingHint(command, surface, params = {}) {
 // (`CALLERS — CONFIRMED (12, ...)`, `CALLERS — RUNTIME DISPATCH (332 sites`,
 // `UNVERIFIED CALL SITES (627) —`, `CALLEES (3):`, `BY FILE:`).
 const SECTION_HEADER_RE = /^(?:[A-Z][A-Z-]*(?: [A-Z][A-Z-]*)*(?: — [A-Z][A-Z -]*)? \(\d[^)]*\)|[A-Z][A-Z ]+:$)/;
-const SECTION_AWARE_COMMANDS = new Set(['show', 'impact']);
+// `check` groups its items by verdict (`BLOCKED (2) — ...`): a long list of
+// breaks must not push what is ready, or what to review, out of the answer.
+const SECTION_AWARE_COMMANDS = new Set(['show', 'impact', 'check']);
 
 /**
  * Cut a relationship answer to `budget` chars keeping a representative head
@@ -152,7 +156,7 @@ const SECTION_AWARE_COMMANDS = new Set(['show', 'impact']);
  * no sections or its fixed parts alone do not fit (caller falls back to a
  * head cut).
  */
-function sectionAwareCut(text, budget) {
+function sectionAwareCut(text, budget, lineCost = line => line.length) {
     const lines = text.split('\n');
     const blocks = []; // { kind: 'fixed', line } | { kind: 'section', header, body }
     let current = null;
@@ -177,7 +181,7 @@ function sectionAwareCut(text, budget) {
     const gapLine = '  ...';
     let used = 0;
     for (const block of blocks) {
-        used += (block.kind === 'fixed' ? block.line.length : block.header.length) + 1;
+        used += lineCost(block.kind === 'fixed' ? block.line : block.header) + 1;
     }
     // Reserve the worst-case `+N more` line and one gap marker per section.
     for (const section of sections) {
@@ -212,7 +216,7 @@ function sectionAwareCut(text, budget) {
             const state = orders.get(section);
             if (state.next >= state.order.length) continue;
             const index = state.order[state.next];
-            const cost = section.body[index].length + 1;
+            const cost = lineCost(section.body[index]) + 1;
             if (used + cost > budget) { state.next = state.order.length; continue; }
             used += cost;
             state.taken.add(index);
@@ -249,13 +253,31 @@ function applyOutputBudget(text, {
     surface = 'cli',
     params = {},
     trailingChars = 0,
+    peerText,
 } = {}) {
-    const defaultLimit = BROAD_COMMANDS.has(command)
-        ? BROAD_OUTPUT_CHARS
-        : DEFAULT_OUTPUT_CHARS;
+    const defaultLimit = paramDefault('maxChars',
+        resolveCommand(command, 'mcp') || resolveCommand(command, 'cli') || command);
     const requested = maxChars || (all ? MAX_OUTPUT_CHARS : defaultLimit);
     const hardLimit = Math.min(requested, MAX_OUTPUT_CHARS);
-    const limit = Math.max(0, hardLimit - trailingChars);
+    // Native CLI/MCP guidance has different lengths. Both presentations
+    // select the same semantic lines using the larger cost at each source
+    // line, including room for the CLI's terminal newline. Rendered text
+    // keeps its own native guidance and actual full-character count.
+    const paired = typeof peerText === 'string';
+    const costs = new Map();
+    if (paired) {
+        const own = String(text || '').split('\n'), peer = peerText.split('\n');
+        for (let i = 0; i < own.length; i++) {
+            const cost = Math.max(own[i].length, (peer[i] || '').length);
+            costs.set(own[i], Math.max(costs.get(own[i]) || 0, cost));
+            costs.set(own[i].trim(), Math.max(costs.get(own[i].trim()) || 0,
+                Math.max(own[i].trim().length, (peer[i] || '').trim().length)));
+        }
+    }
+    const lineCost = line => costs.get(line) ?? line.length;
+    const textCost = value => value.split('\n').reduce((sum, line) => sum + lineCost(line) + 1, -1);
+    const terminalChars = paired ? Math.max(1, trailingChars) : trailingChars;
+    const limit = Math.max(0, hardLimit - terminalChars);
     if (!text) {
         return {
             text: '(no output)'.slice(0, limit),
@@ -267,7 +289,7 @@ function applyOutputBudget(text, {
         };
     }
 
-    if (text.length <= limit) {
+    if (textCost(text) <= limit) {
         return {
             text,
             truncated: false,
@@ -280,25 +302,53 @@ function applyOutputBudget(text, {
 
     const canonical = resolveCommand(command, surface === 'mcp' ? 'mcp' : 'cli') ||
         command;
+    // A line listing is cut between records: the rows that fit, the
+    // accounting, and one line counting the rows left out.
+    if (params.lines && LINES_COMMANDS.has(canonical)) {
+        const listing = budgetLineListing(text, limit, surface, { allowNoRows: true });
+        if (listing) {
+            return {
+                text: listing.text,
+                truncated: true,
+                fullChars: text.length,
+                requestedLimit: hardLimit,
+                contractMetadata: [],
+                contractMetadataComplete: listing.contractMetadataComplete,
+            };
+        }
+    }
     const supportsAll = FLAG_APPLICABILITY[canonical]?.includes('all') &&
         !(canonical === 'deps' && params.cycles);
-    const allHint = supportsAll
-        ? (surface === 'mcp'
-            ? 'Use all=true or max_chars=<n> (100K maximum).'
-            : 'Use --all or --max-chars=N (100K maximum).')
-        : (surface === 'mcp'
-            ? 'Use max_chars=<n> (100K maximum).'
-            : 'Use --max-chars=N (100K maximum).');
+    const noticesFor = (target, fullChars) => {
+        const allHint = supportsAll
+            ? (target === 'mcp'
+                ? 'Use all=true or max_chars=<n> (100K maximum).'
+                : 'Use --all or --max-chars=N (100K maximum).')
+            : (target === 'mcp'
+                ? 'Use max_chars=<n> (100K maximum).'
+                : 'Use --max-chars=N (100K maximum).');
+        const raiseHint = target === 'mcp' ? 'max_chars=<n>' : '--max-chars=N';
+        const compactScope = compactNarrowingHint(command, target, params);
+        const compactGuidance = compactScope.includes(raiseHint)
+            ? `Raise ${raiseHint}.`
+            : `Narrow with ${compactScope || raiseHint}; raise ${raiseHint}.`;
+        return {
+            longNotice: `... OUTPUT TRUNCATED: ${fullChars} chars total; hard limit ${hardLimit}. ` +
+                `${narrowingHint(command, target, params)} ${allHint}`,
+            compactNotice: `... OUTPUT TRUNCATED (${fullChars}→${hardLimit}). ${compactGuidance}`,
+            shortNotice: `... OUTPUT TRUNCATED. Raise ${raiseHint}.`,
+            raiseHint,
+        };
+    };
+    const ownNotices = noticesFor(surface, text.length);
+    if (paired) {
+        const peerNotices = noticesFor(surface === 'mcp' ? 'cli' : 'mcp', peerText.length);
+        for (const name of ['longNotice', 'compactNotice', 'shortNotice']) {
+            costs.set(ownNotices[name], Math.max(ownNotices[name].length, peerNotices[name].length));
+        }
+    }
+    const { longNotice, compactNotice, shortNotice, raiseHint } = ownNotices;
     const compactBudget = limit < 500;
-    const raiseHint = surface === 'mcp' ? 'max_chars=<n>' : '--max-chars=N';
-    const compactScope = compactNarrowingHint(command, surface, params);
-    const compactGuidance = compactScope.includes(raiseHint)
-        ? `Raise ${raiseHint}.`
-        : `Narrow with ${compactScope || raiseHint}; raise ${raiseHint}.`;
-    const longNotice = `... OUTPUT TRUNCATED: ${text.length} chars total; hard limit ${hardLimit}. ` +
-        `${narrowingHint(command, surface, params)} ${allHint}`;
-    const compactNotice = `... OUTPUT TRUNCATED (${text.length}→${hardLimit}). ${compactGuidance}`;
-    const shortNotice = `... OUTPUT TRUNCATED. Raise ${raiseHint}.`;
 
     // Trust lines (ACCOUNT/CONTRACT/WARNING/...) qualify the answer: room for
     // every one of them is reserved before any body text. Optional
@@ -307,7 +357,7 @@ function applyOutputBudget(text, {
     const trust = candidates.filter(candidate => candidate.priority === 0);
     const optional = candidates.filter(candidate => candidate.priority > 0)
         .sort((a, b) => a.priority - b.priority || a.sourceIndex - b.sourceIndex);
-    const trustChars = trust.reduce((sum, candidate) => sum + candidate.line.length + 1, 0);
+    const trustChars = trust.reduce((sum, candidate) => sum + lineCost(candidate.line) + 1, 0);
     const result = (rendered, appended, complete) => ({
         text: rendered,
         truncated: true,
@@ -321,6 +371,16 @@ function applyOutputBudget(text, {
     // number of complete source lines it holds.
     const headCut = (budget) => {
         if (budget <= 0) return { body: '', keptLines: 0 };
+        if (paired) {
+            const kept = [];
+            let used = -1;
+            for (const line of text.split('\n')) {
+                if (used + lineCost(line) + 1 > budget) break;
+                kept.push(line);
+                used += lineCost(line) + 1;
+            }
+            return { body: kept.join('\n'), keptLines: kept.length };
+        }
         const prefix = text.slice(0, budget);
         const lastNewline = prefix.lastIndexOf('\n');
         const body = lastNewline > budget * 0.8 ? prefix.slice(0, lastNewline) : prefix;
@@ -336,18 +396,18 @@ function applyOutputBudget(text, {
     // to `optionalShare` chars (priority order) before the body; the body
     // takes the rest. Returns null when the notice and the trust lines alone
     // exceed the limit.
-    const costOf = list => list.reduce((sum, candidate) => sum + candidate.line.length + 1, 0);
+    const costOf = list => list.reduce((sum, candidate) => sum + lineCost(candidate.line) + 1, 0);
     const layout = (notice, heading, separator, optionalShare) => {
-        const reserveFor = metadataChars => notice.length + (metadataChars > 0 ? heading.length + metadataChars : 0);
+        const reserveFor = metadataChars => lineCost(notice) + (metadataChars > 0 ? heading.length + metadataChars : 0);
         if (reserveFor(trustChars) > limit) return null;
         const reservedOptional = [];
         let optionalChars = 0;
         const optionalRoom = Math.min(optionalShare, limit - reserveFor(trustChars) - (trustChars > 0 ? 0 : heading.length));
         for (const candidate of optional) {
             if (reservedOptional.length >= MAX_PRESERVED_CONTRACT_LINES) break;
-            if (optionalChars + candidate.line.length + 1 > optionalRoom) continue;
+            if (optionalChars + lineCost(candidate.line) + 1 > optionalRoom) continue;
             reservedOptional.push(candidate);
-            optionalChars += candidate.line.length + 1;
+            optionalChars += lineCost(candidate.line) + 1;
         }
         const reserved = [...trust, ...reservedOptional];
         const pendingOf = cutState => reserved.filter(candidate => candidate.sourceIndex >= cutState.keptLines);
@@ -361,12 +421,12 @@ function applyOutputBudget(text, {
         }
         const metadata = pendingOf(cut);
         let rendered = cut.body ? `${cut.body}${separator}${notice}` : notice;
-        let used = rendered.length + (metadata.length > 0 ? heading.length + costOf(metadata) : 0);
+        let used = textCost(rendered) + (metadata.length > 0 ? heading.length + costOf(metadata) : 0);
         let omitted = 0;
         const taken = new Set(reserved);
         for (const candidate of optional) {
             if (taken.has(candidate) || candidate.sourceIndex < cut.keptLines) continue;
-            const cost = candidate.line.length + 1 + (metadata.length === 0 ? heading.length : 0);
+            const cost = lineCost(candidate.line) + 1 + (metadata.length === 0 ? heading.length : 0);
             if (metadata.length >= trust.length + MAX_PRESERVED_CONTRACT_LINES || used + cost > limit) {
                 omitted++;
                 continue;
@@ -392,28 +452,35 @@ function applyOutputBudget(text, {
     // so with the budget that would carry them.
     const withheld = () => {
         const flag = surface === 'mcp' ? 'max_chars' : '--max-chars';
-        const noticeFor = (shown, needed) => `... OUTPUT TRUNCATED (${text.length}→${hardLimit}): answer withheld; ` +
-            `${shown} of ${trust.length} trust line(s) shown. Raise ${flag} to at least ${needed}.`;
+        const noticeFor = (shown, needed, target = surface, fullChars = text.length) =>
+            `... OUTPUT TRUNCATED (${fullChars}→${hardLimit}): answer withheld; ` +
+            `${shown} of ${trust.length} trust line(s) shown. Raise ${target === 'mcp' ? 'max_chars' : '--max-chars'} to at least ${needed}.`;
         // Smallest budget whose shortest layout carries every trust line.
-        const needed = trailingChars + shortNotice.length + trustChars;
+        const needed = terminalChars + lineCost(shortNotice) + trustChars;
         let shown = 0;
-        let used = noticeFor(trust.length, needed).length;
+        const noticeCost = text => paired ? Math.max(text.length,
+            text.replace(surface === 'mcp' ? 'max_chars' : '--max-chars', surface === 'mcp' ? '--max-chars' : 'max_chars').length) : text.length;
+        // Native full sizes can have different digit widths. Pair the whole
+        // notice before choosing trust lines, just as for ordinary notices.
+        const fullNoticeCost = shown => Math.max(noticeFor(shown, needed).length,
+            paired ? noticeFor(shown, needed, surface === 'mcp' ? 'cli' : 'mcp', peerText.length).length : 0);
+        let used = fullNoticeCost(trust.length);
         const kept = [];
         for (const candidate of trust) {
-            if (used + candidate.line.length + 1 > limit) break;
+            if (used + lineCost(candidate.line) + 1 > limit) break;
             kept.push(candidate.line);
-            used += candidate.line.length + 1;
+            used += lineCost(candidate.line) + 1;
             shown++;
         }
         const notice = noticeFor(shown, needed);
-        if (notice.length > limit) {
+        if (fullNoticeCost(shown) > limit) {
             // Shorter statements of the same fact; a budget number is never
             // cut mid-digit.
             const shorter = [
                 `TRUNCATED: answer withheld; raise ${flag} to at least ${needed}.`,
                 `Answer withheld; ${flag}>=${needed}`,
                 `withheld; >=${needed}`,
-            ].find(text => text.length <= limit);
+            ].find(text => noticeCost(text) <= limit);
             return result(shorter || '', [], false);
         }
         return result([notice, ...kept].join('\n'), kept, false);
@@ -448,26 +515,26 @@ function applyOutputBudget(text, {
         // Sections keep every non-indented line (trust lines included) in
         // place; trust lines inside a cut section body are appended, with
         // their room taken from the sections.
-        let sectionBudget = limit - longNotice.length - 2;
+        let sectionBudget = limit - lineCost(longNotice) - 2;
         for (let attempt = 0; attempt < 2; attempt++) {
-            const sectioned = sectionAwareCut(text, sectionBudget);
+            const sectioned = sectionAwareCut(text, sectionBudget, lineCost);
             if (sectioned === null) break;
             const visible = new Set(sectioned.split('\n').map(line => line.trim()));
             const missing = trust.filter(candidate => !visible.has(candidate.line));
-            const missingChars = missing.reduce((sum, candidate) => sum + candidate.line.length + 1, 0);
+            const missingChars = missing.reduce((sum, candidate) => sum + lineCost(candidate.line) + 1, 0);
             let rendered = `${sectioned}\n\n${longNotice}`;
-            if (rendered.length + missingChars > limit) {
+            if (textCost(rendered) + missingChars > limit) {
                 sectionBudget -= missingChars;
                 continue;
             }
             const appended = missing.map(candidate => candidate.line);
             let omitted = 0;
-            let used = rendered.length + missingChars;
+            let used = textCost(rendered) + missingChars;
             for (const candidate of optional) {
                 if (visible.has(candidate.line)) continue;
-                if (used + candidate.line.length + 1 > limit) { omitted++; continue; }
+                if (used + lineCost(candidate.line) + 1 > limit) { omitted++; continue; }
                 appended.push(candidate.line);
-                used += candidate.line.length + 1;
+                used += lineCost(candidate.line) + 1;
             }
             if (appended.length > 0) rendered += '\n' + appended.join('\n');
             return result(rendered, appended, omitted === 0);

package/core/parallel-build.js

@@ -220,7 +220,7 @@ function parallelBuild(index, files, options = {}) {
     {
         for (const result of collected) {
             if (result.error) {
-                index.failedFiles.add(result.filePath);
+                index._noteFailedFile(result.filePath);
                 if (!options.quiet) {
                     console.error(`  Warning: Could not index ${result.filePath}: ${result.error}`);
                 }
@@ -236,7 +236,7 @@ function parallelBuild(index, files, options = {}) {
                         existing.size = result.sizeUpdate;
                     }
                 }
-                index.failedFiles.delete(result.filePath);
+                index._clearFailedFile(result.filePath);
                 continue;
             }
 
@@ -267,7 +267,7 @@ function parallelBuild(index, files, options = {}) {
                 index.callsCacheDirty = true;
             }
 
-            index.failedFiles.delete(result.filePath);
+            index._clearFailedFile(result.filePath);
             changed++;
         }
     }

package/core/project.js

@@ -9,11 +9,9 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
+const { paramDefault } = require('./registry');
 const { UcnError } = require('./errors');
-const {
-    expandGlob, findProjectRoot, detectProjectPattern, isTestFile,
-    parseGitignore, gitTrackedPaths, gitListing, DEFAULT_IGNORES, compareNames, classifyUnsupportedSourceFile,
-} = require('./discovery');
+const { expandGlob, findProjectRoot, detectProjectPattern, isTestFile, parseGitignore, gitTrackedPaths, gitListing, compareNames, classifyUnsupportedSourceFile, projectDiscoveryOptions } = require('./discovery');
 const { cleanHtmlScriptTags } = require('./parser');
 const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits, PARSE_OPTIONS } = require('../languages');
 const { validateFileIR } = require('./ir');
@@ -102,8 +100,11 @@ class ProjectIndex {
      * Create a new ProjectIndex
      * @param {string} rootDir - Project root directory
      */
-    constructor(rootDir) {
-        this.root = findProjectRoot(rootDir);
+    constructor(rootDir, options = {}) {
+        // `exactRoot`: the directory IS the project root. A tree exported
+        // from the git index has no `.git` to stop the walk toward a marker,
+        // and must not adopt a directory above itself.
+        this.root = options.exactRoot ? path.resolve(rootDir) : findProjectRoot(rootDir);
         this.files = new Map();           // path -> FileEntry
         this.symbols = new Map();         // name -> SymbolEntry[]
         this.importGraph = new Map();     // file -> [imported files]
@@ -128,6 +129,7 @@ class ProjectIndex {
         this.macroExpansionDirty = false;  // persisted C/C++ macro-expansion records (core/macro-expansion.js)
         this._macroExpansionPersisted = null;
         this.failedFiles = new Set();    // files that failed to index (e.g. large minified bundles)
+        this._failedFileStats = new Map(); // failed file -> { size, mtimeMs } AT the failure (see _noteFailedFile)
         this.unsupportedFiles = [];      // common source files skipped by the parser registry
         this.discoveryIssues = [];       // explicit reasons the index may be partial
         this._opContentCache = null;     // per-operation file content cache (Map<filePath, string>)
@@ -151,9 +153,15 @@ class ProjectIndex {
         this._usageResultCache = new Map();
         this._usageResultCacheWeight = 0;
         this.usageCacheDirty = false;
+        // HOT rankings already computed for this index state, by request
+        // (core/hot-summary.js); stored beside the index when dirty.
+        this._hotSummaries = null;
+        this._hotSummarySavedGeneration = null;
+        this.hotSummaryDirty = false;
         // Exact text-ground sets are likewise immutable for one built index.
         // The cache is cleared at every build and bounded in account.js.
         this._groundSetCache = new Map();
+        this._sourceUniverse = null; // non-indexed source classification (core/source-universe.js)
         this._groundSetCacheLines = 0;
         // Bounded cross-operation memo for immutable name-level export
         // ownership. Agent workflows ask show/impact/tests about related
@@ -545,6 +553,29 @@ class ProjectIndex {
         }
     }
 
+    /**
+     * Record a file the parser could not ingest, with what it looked like
+     * when it failed. A failed file is in no index, so its size and mtime
+     * are the only way to tell that it changed and deserves another try;
+     * they must be taken here, at the failure, never at the first later
+     * check (by then a repaired file already looks "unchanged").
+     */
+    _noteFailedFile(filePath) {
+        this.failedFiles.add(filePath);
+        if (!this._failedFileStats) this._failedFileStats = new Map();
+        try {
+            const stat = fs.statSync(filePath);
+            this._failedFileStats.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs });
+        } catch (_) {
+            this._failedFileStats.delete(filePath);
+        }
+    }
+
+    _clearFailedFile(filePath) {
+        this.failedFiles.delete(filePath);
+        if (this._failedFileStats) this._failedFileStats.delete(filePath);
+    }
+
     /**
      * Load .ucn.json config if present (data-only, no code execution)
      */
@@ -574,6 +605,7 @@ class ProjectIndex {
         // a text-universe answer across that boundary. Hash-keyed usage
         // results remain safe and useful for unchanged files.
         this._groundSetCache = new Map();
+        this._sourceUniverse = null; // non-indexed source classification (core/source-universe.js)
         this._groundSetCacheLines = 0;
         this._nameBindingReachCache = new Map();
         this._returnTypeFlowCache = new Map();
@@ -630,17 +662,20 @@ class ProjectIndex {
                 pattern = detectProjectPattern(this.root);
             }
 
-            const globOpts = {
-                root: this.root,
-                maxFiles: options.maxFiles || this.config.maxFiles || 50000,
-                maxDepth: options.maxDepth ?? this.config.maxDepth,
-                maxFileSize: options.maxFileSize ?? this.config.maxFileSize,
+            // Shared with the staleness walk (cache.js): both must read the
+            // project's configuration the same way.
+            const globOpts = projectDiscoveryOptions(this.root, this.config, {
+                maxFiles: options.maxFiles,
+                maxDepth: options.maxDepth,
+                maxFileSize: options.maxFileSize,
                 followSymlinks: options.followSymlinks,
                 includeBundled: this.includeBundled,
-            };
+            });
 
             // Merge .gitignore and .ucn.json exclude into file discovery
-            const listing = gitListing(this.root);
+            // A snapshot exported from the git index is not a repository:
+            // its tracked inventory and ignore files come with it.
+            const listing = options.gitListing !== undefined ? options.gitListing : gitListing(this.root);
             const gitignoreRules = parseGitignore(this.root, listing);
             globOpts.gitignoreRules = gitignoreRules;
             globOpts.trackedPaths = gitTrackedPaths(this.root, listing);
@@ -654,13 +689,6 @@ class ProjectIndex {
                     detail: `${listing.failure.detail}; tracked files that match .gitignore rules could not be identified and are not indexed`,
                 });
             }
-            const configExclude = Array.isArray(this.config.exclude)
-                ? this.config.exclude
-                : (this.config.exclude ? [String(this.config.exclude)] : []);
-            if (configExclude.length > 0) {
-                globOpts.ignores = [...DEFAULT_IGNORES, ...configExclude];
-            }
-            globOpts.disclosureIgnores = configExclude;
             globOpts.onDiscoveryIssue = recordDiscoveryIssue;
 
             if (implicitProjectDiscovery) {
@@ -683,7 +711,7 @@ class ProjectIndex {
         }
 
         // Track if files were truncated by maxFiles limit
-        const maxFiles = options.maxFiles || this.config.maxFiles || 50000;
+        const maxFiles = options.maxFiles || this.config.maxFiles || paramDefault('maxFiles');
         const maxFileIssues = this.discoveryIssues.filter(issue => issue.reason === 'max-files');
         if (!Array.isArray(pattern) && maxFileIssues.length > 0) {
             this.truncated = { indexed: files.length, maxFiles, skipped: maxFileIssues.length };
@@ -727,6 +755,7 @@ class ProjectIndex {
         this._callNameCache = null;
         this._callsGenerationKey = null;
         this._completenessCache = null;
+        require('./hot-summary').reset(this);
         this._attrTypeCache = null;
         this._computedDispatchBlindspots = null;
         this._reflectionPatternIndex = null;
@@ -743,6 +772,7 @@ class ProjectIndex {
         let indexed = 0;
         let changed = 0;
         if (!this.failedFiles) this.failedFiles = new Set();
+        if (!this._failedFileStats) this._failedFileStats = new Map();
 
         // Try parallel build for large projects
         const workersSetting = options.workers;
@@ -862,9 +892,9 @@ class ProjectIndex {
                     try {
                         if (this.indexFile(file)) changed++;
                         indexed++;
-                        this.failedFiles.delete(file); // Succeeded now, remove from failed
+                        this._clearFailedFile(file); // Succeeded now, remove from failed
                     } catch (e) {
-                        this.failedFiles.add(file); // Track files that fail to index
+                        this._noteFailedFile(file); // Track files that fail to index
                         if (!quiet) {
                             console.error(`  Warning: Could not index ${file}: ${e.message}`);
                         }
@@ -1031,6 +1061,7 @@ class ProjectIndex {
         // These query caches depend on project symbols and include closure.
         // A changed file can alter either even before a full rebuild reaches
         // its graph phase, so no prior call-identity verdict may survive.
+        require('./hot-summary').reset(this);
         this._implicitConversionOwners = null;
         this._constructionAliases = null;
         this._cppScope = null;
@@ -1126,6 +1157,52 @@ class ProjectIndex {
         return true;
     }
 
+    /**
+     * Where a file of this index lives in the git repository it describes.
+     * The same path, except for a snapshot exported from the git index
+     * (core/snapshot.js), whose files stand in for the repository's.
+     */
+    repoPathOf(filePath) {
+        if (!this.repoRoot || !filePath) return filePath;
+        const relative = path.relative(this.root, filePath);
+        return relative.startsWith('..') ? filePath : path.join(this.repoRoot, relative);
+    }
+
+    /**
+     * The file entry another revision of a file would have: its symbols,
+     * exports and bindings as the index records them, built from `content`
+     * and attached to nothing. The index is not changed. Used to read a
+     * base revision (a diff's old side) with the same eyes as the current
+     * one. Returns null for a file no language claims or a parse the
+     * adapter rejects.
+     */
+    fileEntryForContent(filePath, content) {
+        const language = detectLanguage(filePath, this.root);
+        if (!language || content == null) return null;
+        try {
+            const adapter = getLanguageAdapter(language);
+            const parser = getParser(language);
+            const externalMacros = this._macroDictionary
+                ? require('./external-macros').contextFor(this._macroDictionary, language) : null;
+            const ir = adapter.analyze(content, parser, filePath,
+                externalMacros ? { externalMacros } : undefined);
+            if (validateFileIR(ir).length > 0) return null;
+            const fileEntry = createFileEntryFromIR({
+                ir,
+                filePath,
+                relativePath: path.relative(this.root, filePath),
+                hash: null,
+                mtime: 0,
+                size: Buffer.byteLength(content),
+                lineCount: content.length === 0 ? 0 : content.split('\n').length,
+            });
+            populateFileEntryFromIR(fileEntry, ir, null);
+            return fileEntry;
+        } catch (_) {
+            return null;
+        }
+    }
+
     /**
      * Remove a file's symbols from the global map
      */
@@ -1133,6 +1210,7 @@ class ProjectIndex {
         const existing = this.files.get(filePath);
         if (!existing) return;
 
+        require('./hot-summary').reset(this);
         this._implicitConversionOwners = null;
         this._constructionAliases = null;
         this._cppScope = null;
@@ -3063,6 +3141,11 @@ class ProjectIndex {
         return indexCache.saveUsageCache(this, cachePath);
     }
 
+    /** Persist the HOT rankings computed for the saved index state. */
+    saveHotSummaries(cachePath = undefined) {
+        return require('./hot-summary').save(this, cachePath);
+    }
+
     /** Return this project's default per-user cache file path. */
     getCachePath() { return indexCache.getProjectCachePath(this.root); }
 

package/core/provenance-type.js

@@ -185,7 +185,11 @@ function constructionDenotes(index, resolver, query, definition, seen = new Set(
     const visited = new Set(seen).add(key);
     const traits = lazyLanguagesModule().langTraits(entry.language);
     if (query.localShadow && !localConstructionBinding(index, query, definition, traits, entry.language)) return false;
-    if (traits.constructorInheritance?.order === 'single' && definition.decorators?.length) return false;
+    // A decorated class may be replaced by its decorator: no proof that its
+    // constructor runs. Which class the name denotes (`identity`) is the
+    // declaration all the same, as the language's own typing reads it.
+    if (!query.identity && traits.constructorInheritance?.order === 'single' && definition.decorators?.length) return false;
+    const identity = query.identity ? { identity: true } : null;
     if (traits.functionalTypeConstruction) {
         const classes = cppConstructionClasses(index, query, resolver);
         return classes.length > 0 && classes.every(def =>
@@ -228,7 +232,7 @@ function constructionDenotes(index, resolver, query, definition, seen = new Set(
         const bindings = (entry.importBindings || []).filter(b => (b.alias || b.name) === qualifier);
         if (bindings.length !== 1) return false;
         const target = moduleFile(`${bindings[0].module}.${bindings[0].name}`) || moduleFile(bindings[0].module);
-        return !!target && constructionDenotes(index, resolver, { file: target, line: 1, name }, definition, visited);
+        return !!target && constructionDenotes(index, resolver, { file: target, line: 1, name, ...identity }, definition, visited);
     }
     const aliases = (entry.moduleValueAliases || []).filter(alias => alias.name === name);
     if (aliases.length) {
@@ -238,11 +242,11 @@ function constructionDenotes(index, resolver, query, definition, seen = new Set(
                 if (alternative.target) {
                     const parts = alternative.target.split('.'), targetName = parts.pop();
                     return constructionDenotes(index, resolver, { file, line: alias.line || line,
-                        name: targetName, qualifier: parts.join('.') || null }, definition, visited);
+                        name: targetName, qualifier: parts.join('.') || null, ...identity }, definition, visited);
                 }
                 const target = moduleFile(alternative.module);
                 return !!target && !!alternative.imported && constructionDenotes(index, resolver,
-                    { file: target, line: 1, name: alternative.imported }, definition, visited);
+                    { file: target, line: 1, name: alternative.imported, ...identity }, definition, visited);
             });
         });
     }
@@ -252,13 +256,16 @@ function constructionDenotes(index, resolver, query, definition, seen = new Set(
             !def.lexicalScopeStartLine && !['class', 'struct', 'interface', 'type'].includes(def.type));
         return !shadows.length && !(entry.moduleAssignedNames || []).includes(name);
     }
+    // A name the module assigns, or a function writes through its module
+    // binding, does not hold its import's value at every use.
+    if ((entry.moduleAssignedNames || []).includes(name)) return false;
     const links = [...(entry.importBindings || []).filter(b => (b.alias || b.name) === name &&
         b.name !== '*' && b.kind !== 'namespace'), ...(entry.exportDetails || []).filter(e =>
         e.type === 're-export' && (e.alias || e.name) === name && e.source)];
     if (links.length !== 1) return false;
     const target = moduleFile(links[0].module || links[0].source);
     return !!target && constructionDenotes(index, resolver, { file: target, line: 1,
-        name: links[0].name }, definition, visited);
+        name: links[0].name, ...identity }, definition, visited);
 }
 
 // A construction through a method's own receiver (fix #434): the class