ucn 5.5.3 → 5.6.1

package/core/output/tracing.js

@@ -8,6 +8,7 @@
  * conservation) lines close the arithmetic.
  */
 
+const { testCountText } = require('../test-units');
 const { unverifiedReasonLabel } = require('./shared');
 const { codeUnitCompare } = require('../shared');
 const { formatAccountLines } = require('./analysis');
@@ -562,23 +563,49 @@ function formatAffectedTests(result, options = {}) {
         lines.push('No confirmed static test links found for any affected function.');
     } else {
         const MAX_TEST_FILES = options.all ? Infinity : 30;
-        const displayFiles = result.testFiles.slice(0, MAX_TEST_FILES);
-        const truncatedFiles = result.testFiles.length - displayFiles.length;
-        lines.push(`Test files to run (${summary.totalTestFiles}):`);
+        const runnable = result.testFiles.filter(tf => tf.role !== 'support');
+        const support = result.testFiles.filter(tf => tf.role === 'support');
+        const displayFiles = runnable.slice(0, MAX_TEST_FILES);
+        const truncatedFiles = runnable.length - displayFiles.length;
+        // A count is exact only where every test of the files is listed:
+        // "at least" says a file holds tests that are not.
+        const total = testCountText(summary.totalTests, summary.moreTests, summary.conditionalTests);
+        lines.push(`Test files to run (${runnable.length})${total ? `, ${total}` : ''}:`);
         lines.push('');
         for (const tf of displayFiles) {
-            lines.push(`  ${tf.file} (links: ${linkList(tf.linkedFunctions, options)})`);
+            const counted = testCountText(tf.testCount, tf.moreTests, tf.conditionalTests);
+            const count = counted ? ` · ${counted}` : '';
+            const refusal = tf.runWithheld ? ` · no command: ${tf.runWithheld}` : '';
+            lines.push(`  ${tf.file} (links: ${linkList(tf.linkedFunctions, options)})${count}${refusal}`);
             // Show up to 5 key matches per file
             const keyMatches = tf.matches
-                .filter(m => m.matchType === 'call' || m.matchType === 'test-case')
+                .filter(m => m.matchType === 'call' || m.matchType === 'test-case' || m.matchType === 'inherited-test')
                 .slice(0, 5);
             for (const m of keyMatches) {
-                lines.push(`    L${m.line}: ${m.content}  [${m.matchType}]`);
+                const origin = m.matchType === 'inherited-test' ? `  ${m.name} (from ${m.from})` : '';
+                lines.push(`    L${m.line}: ${m.content}${origin}  [${m.matchType}]`);
             }
         }
         if (truncatedFiles > 0) {
             lines.push(`\n  ... ${truncatedFiles} more test files (use file= and exclude= to narrow scope)`);
         }
+        if (support.length > 0) {
+            lines.push('');
+            lines.push(`Test support code reached (${support.length}) — declares no test, runs with the tests that load it:`);
+            for (const tf of support.slice(0, options.all ? Infinity : 10)) {
+                lines.push(`  ${tf.file} (links: ${linkList(tf.linkedFunctions, options)})`);
+            }
+        }
+        const commands = result.commands || [];
+        if (commands.length > 0) {
+            lines.push('');
+            lines.push('Run:');
+            const MAX_COMMANDS = options.all ? Infinity : 5;
+            for (const line of commands.slice(0, MAX_COMMANDS)) lines.push(`  ${line}`);
+            if (commands.length > MAX_COMMANDS) {
+                lines.push(`  ... ${commands.length - MAX_COMMANDS} more (${options.allHint || 'use --all'})`);
+            }
+        }
     }
 
     // Possible band: functions reachable only through unverified chains.
@@ -592,7 +619,7 @@ function formatAffectedTests(result, options = {}) {
         }
         const pat = result.possiblyAffectedTests || [];
         if (pat.length > 0) {
-            lines.push(`  Additional test files (${pat.length}):`);
+            lines.push(`  Test files with possible links (${pat.length}):`);
             const MAX_POSSIBLE = options.all ? Infinity : 10;
             for (const tf of pat.slice(0, MAX_POSSIBLE)) {
                 lines.push(`    ${tf.file} (links: ${linkList(tf.linkedFunctions, options)})`);
@@ -614,7 +641,8 @@ function formatAffectedTests(result, options = {}) {
     const pct = summary.totalAffected > 0
         ? Math.round(summary.staticallyLinkedFunctions / summary.totalAffected * 100)
         : 0;
-    let summaryLine = `Summary: ${summary.totalAffected} affected → ${summary.totalTestFiles} statically linked test files, ${summary.staticallyLinkedFunctions}/${summary.totalAffected} functions linked (${pct}%)`;
+    const totalTests = testCountText(summary.totalTests, summary.moreTests, summary.conditionalTests);
+    let summaryLine = `Summary: ${summary.totalAffected} affected → ${summary.totalTestFiles} statically linked test files${totalTests ? ` (${totalTests})` : ''}, ${summary.staticallyLinkedFunctions}/${summary.totalAffected} functions linked (${pct}%)`;
     if (summary.possiblyAffected > 0) {
         summaryLine += ` · ${summary.possiblyAffected} possibly affected (unverified chains)`;
     }

package/core/output-budget.js

@@ -3,22 +3,27 @@
 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)/;
+// A count or deletion verdict is the answer the warnings qualify. Preserve
+// it with those warnings, or explicitly withhold the answer when both cannot fit.
+const RESULT_LINE_RE = /^(?:Dead code: \d+ unused symbol\(s\)|No dead code found\.|VERDICT: (?:no-static-dependents|has-static-dependents|review)\b)/;
 const MAX_PRESERVED_CONTRACT_LINES = 24;
 const MAX_PRESERVED_CONTRACT_CHARS = 8000;
 
@@ -43,10 +48,10 @@ function contractCandidates(fullText) {
         // Shell-shaped MCP/interactive results prefix disclosures with '# '.
         // Match their contents but retain the prefix in the preserved text.
         const evidenceLine = contractLine.replace(/^\s*# /, '').trim();
-        if (!CONTRACT_LINE_RE.test(evidenceLine)) continue;
+        if (!CONTRACT_LINE_RE.test(evidenceLine) && !RESULT_LINE_RE.test(evidenceLine)) continue;
         const line = contractLine.trim();
         if (!line) continue;
-        const priority = TRUST_LINE_RE.test(evidenceLine)
+        const priority = TRUST_LINE_RE.test(evidenceLine) || RESULT_LINE_RE.test(evidenceLine)
             ? 0
             : /^\d+ test-file usage\(s\) hidden\b/.test(evidenceLine) ? 1 : 2;
         candidates.push({ line, priority, sourceIndex });
@@ -139,7 +144,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 +159,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 +184,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 +219,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 +256,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 +292,7 @@ function applyOutputBudget(text, {
         };
     }
 
-    if (text.length <= limit) {
+    if (textCost(text) <= limit) {
         return {
             text,
             truncated: false,
@@ -280,25 +305,56 @@ 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, budget = hardLimit) => {
+        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 ${budget}. ` +
+                `${narrowingHint(command, target, params)} ${allHint}`,
+            compactNotice: `... OUTPUT TRUNCATED (${fullChars}→${budget}). ${compactGuidance}`,
+            shortNotice: `... OUTPUT TRUNCATED (${fullChars}→${budget}). Raise ${raiseHint}.`,
+            // At the tightest budgets, disclosures outrank the repeated
+            // raise-budget guidance; retain the full size and limit.
+            minimalNotice: `... OUTPUT TRUNCATED (${fullChars}→${budget}).`,
+            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', 'minimalNotice']) {
+            costs.set(ownNotices[name], Math.max(ownNotices[name].length, peerNotices[name].length));
+        }
+    }
+    const { longNotice, compactNotice, shortNotice, minimalNotice, 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 +363,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 +377,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 +402,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 +427,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 +458,44 @@ 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;
+        let needed = terminalChars + lineCost(minimalNotice) + trustChars;
+        // Raising the limit can add a digit to the notice itself. Compute
+        // the advertised budget using that budget's notice, for both peers.
+        for (;;) {
+            const noticeChars = Math.max(noticesFor(surface, text.length, needed).minimalNotice.length,
+                paired ? noticesFor(surface === 'mcp' ? 'cli' : 'mcp', peerText.length, needed).minimalNotice.length : 0);
+            const required = terminalChars + noticeChars + trustChars;
+            if (required <= needed) break;
+            needed = required;
+        }
         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);
@@ -440,7 +522,9 @@ function applyOutputBudget(text, {
 
     if (compactBudget) {
         // Tiny transports: every disclosure outranks body detail.
-        return pick(() => layout(compactNotice, '', '\n', limit), () => layout(shortNotice, '', '\n', limit)) ||
+        return pick(() => layout(compactNotice, '', '\n', limit),
+            () => layout(shortNotice, '', '\n', limit),
+            () => layout(minimalNotice, '', '\n', limit)) ||
             (trust.length > 0 ? withheld() : bare());
     }
 
@@ -448,26 +532,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);
@@ -480,7 +564,8 @@ function applyOutputBudget(text, {
     const optionalShare = Math.max(0, Math.min(MAX_PRESERVED_CONTRACT_CHARS, Math.floor(limit * 0.5)) - trustChars);
     return pick(() => layout(longNotice, heading, '\n\n', optionalShare),
         () => layout(compactNotice, '', '\n', optionalShare),
-        () => layout(shortNotice, '', '\n', optionalShare)) ||
+        () => layout(shortNotice, '', '\n', optionalShare),
+        () => layout(minimalNotice, '', '\n', optionalShare)) ||
         (trust.length > 0 ? withheld() : bare());
 }
 

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++;
         }
     }