causantic 0.10.0 → 0.10.2

package/dist/retrieval/search-assembler.js

@@ -17,9 +17,13 @@ import { KeywordStore } from '../storage/keyword-store.js';
 import { fuseRRF } from './rrf.js';
 import { expandViaClusters } from './cluster-expander.js';
 import { reorderWithMMR } from './mmr.js';
+import { extractEntities } from '../utils/entity-extractor.js';
+import { findEntitiesByAlias, getChunkIdsForEntity } from '../storage/entity-store.js';
 import { createLogger } from '../utils/logger.js';
 import { formatSearchChunk } from './formatting.js';
 const log = createLogger('search-assembler');
+/** RRF weight for entity-boosted results. */
+const ENTITY_RRF_BOOST = 1.5;
 /**
  * Shared embedder instance.
  */
@@ -50,243 +54,258 @@ function getKeywordStore() {
     }
     return sharedKeywordStore;
 }
+// ── Extracted pipeline stages ────────────────────────────────────────────────
 /**
- * Run the search pipeline.
+ * Filter items by agent when agent filtering is active but project filtering is not.
  *
- * Keyword-primary mode: keyword → [optional vector enrichment] → recency → MMR → budget
- * Hybrid mode:          embed → [vector, keyword] → RRF → cluster expand → recency → MMR → budget
+ * When projectFilter is set, agent filtering is handled by the storage layer.
+ * This function handles the post-filter case where no project scope was provided.
  */
-export async function searchContext(request) {
-    const startTime = Date.now();
-    const externalConfig = loadConfig();
-    const config = toRuntimeConfig(externalConfig);
-    const { query, currentSessionId, projectFilter, maxTokens = config.mcpMaxResponseTokens, vectorSearchLimit = 20, skipClusters = false, agentFilter, } = request;
-    const { hybridSearch, clusterExpansion, mmrReranking, embeddingModel } = config;
-    const retrievalMode = config.retrievalPrimary;
-    let fusedResults;
-    let queryEmbedding = [];
-    let useIndexSearch = false;
-    if (retrievalMode === 'keyword') {
-        // ── Keyword-primary search path ──────────────────────────────────────
-        // No embedding needed unless vector enrichment is enabled.
-        let keywordResults = [];
-        try {
-            const keywordStore = getKeywordStore();
-            keywordResults = projectFilter
-                ? keywordStore.searchByProject(query, projectFilter, hybridSearch.keywordSearchLimit, agentFilter)
-                : keywordStore.search(query, hybridSearch.keywordSearchLimit);
-        }
-        catch (error) {
-            log.warn('Keyword search failed', { error: error.message });
-        }
-        // Post-filter by agent when no project filter was used
-        if (agentFilter && !projectFilter) {
-            keywordResults = keywordResults.filter((r) => {
-                const chunk = getChunkById(r.id);
-                return chunk?.agentId === agentFilter;
-            });
-        }
-        fusedResults = keywordResults.map((r) => ({
-            chunkId: r.id,
-            score: r.score,
-            source: 'keyword',
-        }));
-        // Optional vector enrichment: merge vector results via RRF
-        if (config.vectorEnrichment) {
-            try {
-                vectorStore.setModelId(embeddingModel);
-                const embedder = await getEmbedder(embeddingModel);
-                const queryResult = await embedder.embed(query, true);
-                queryEmbedding = queryResult.embedding;
-                let vectorResults = await (projectFilter
-                    ? vectorStore.searchByProject(queryResult.embedding, projectFilter, vectorSearchLimit, agentFilter)
-                    : vectorStore.search(queryResult.embedding, vectorSearchLimit));
-                if (agentFilter && !projectFilter) {
-                    vectorResults = vectorResults.filter((s) => {
-                        const chunk = getChunkById(s.id);
-                        return chunk?.agentId === agentFilter;
-                    });
-                }
-                if (vectorResults.length > 0) {
-                    const vectorItems = vectorResults.map((s) => ({
-                        chunkId: s.id,
-                        score: Math.max(0, 1 - s.distance),
-                        source: 'vector',
-                    }));
-                    fusedResults = fuseRRF([
-                        { items: fusedResults, weight: hybridSearch.keywordWeight },
-                        { items: vectorItems, weight: hybridSearch.vectorWeight },
-                    ], hybridSearch.rrfK);
-                }
-            }
-            catch (error) {
-                log.warn('Vector enrichment failed, using keyword results only', {
-                    error: error.message,
-                });
+function filterByAgent(items, agentFilter, projectFilter, getAgent) {
+    if (!agentFilter || projectFilter)
+        return items;
+    return items.filter((item) => getAgent(item.id) === agentFilter);
+}
+/**
+ * Extract entity mentions from the query and find matching chunks.
+ * Returns ranked items suitable for RRF fusion.
+ */
+function getEntityResults(query, projectFilter) {
+    const mentions = extractEntities(query);
+    if (mentions.length === 0)
+        return [];
+    const project = typeof projectFilter === 'string' ? projectFilter : undefined;
+    if (!project)
+        return []; // entity lookup requires project scope
+    const chunkIds = new Set();
+    for (const mention of mentions) {
+        const entities = findEntitiesByAlias(mention.normalizedName, mention.entityType, project);
+        for (const entity of entities) {
+            for (const cid of getChunkIdsForEntity(entity.id, 100)) {
+                chunkIds.add(cid);
             }
         }
-        if (fusedResults.length === 0) {
-            return {
-                text: '',
-                tokenCount: 0,
-                chunks: [],
-                totalConsidered: 0,
-                durationMs: Date.now() - startTime,
-                queryEmbedding,
-                seedIds: [],
-            };
+    }
+    return [...chunkIds].map((id, i) => ({
+        chunkId: id,
+        score: 1.0 / (i + 1),
+        source: 'entity',
+    }));
+}
+/**
+ * Merge entity-boosted results into fused results via RRF.
+ */
+function applyEntityBoost(fusedResults, query, projectFilter, rrfK) {
+    try {
+        const entityItems = getEntityResults(query, projectFilter);
+        if (entityItems.length > 0) {
+            return fuseRRF([
+                { items: fusedResults, weight: 1.0 },
+                { items: entityItems, weight: ENTITY_RRF_BOOST },
+            ], rrfK);
         }
-        // Skip cluster expansion for keyword-primary mode
     }
-    else {
-        // ── Hybrid/vector search path ────────────────────────────────────────
-        // Configure vector store for current model
-        vectorStore.setModelId(embeddingModel);
-        // 1. Embed query
-        const embedder = await getEmbedder(embeddingModel);
-        const queryResult = await embedder.embed(query, true);
-        queryEmbedding = queryResult.embedding;
-        // Determine whether to use index-based search
-        useIndexSearch = config.semanticIndex.useForSearch && getIndexEntryCount() > 0;
-        if (useIndexSearch) {
-            // ── Index-based search path ──────────────────────────────────────
-            indexVectorStore.setModelId(embeddingModel);
-            const entryCount = getIndexEntryCount();
-            const indexedChunks = getIndexedChunkCount();
-            const entriesPerChunk = indexedChunks > 0 ? entryCount / indexedChunks : 1;
-            const indexSearchLimit = Math.ceil(vectorSearchLimit * entriesPerChunk);
-            const indexVectorPromise = projectFilter
-                ? indexVectorStore.searchByProject(queryResult.embedding, projectFilter, indexSearchLimit, agentFilter)
-                : indexVectorStore.search(queryResult.embedding, indexSearchLimit);
-            let indexKeywordResults = [];
-            try {
-                indexKeywordResults = searchIndexEntriesByKeyword(query, hybridSearch.keywordSearchLimit, projectFilter, agentFilter);
-            }
-            catch (error) {
-                log.warn('Index keyword search unavailable', {
-                    error: error.message,
-                });
-            }
-            let indexSimilar = await indexVectorPromise;
-            if (agentFilter && !projectFilter) {
-                indexSimilar = indexSimilar.filter((s) => {
-                    const agent = indexVectorStore.getChunkAgent(s.id);
-                    return agent === agentFilter;
-                });
-                indexKeywordResults = indexKeywordResults.filter((r) => {
-                    const agent = indexVectorStore.getChunkAgent(r.id);
-                    return agent === agentFilter;
-                });
-            }
-            if (indexSimilar.length === 0 && indexKeywordResults.length === 0) {
-                return {
-                    text: '',
-                    tokenCount: 0,
-                    chunks: [],
-                    totalConsidered: 0,
-                    durationMs: Date.now() - startTime,
-                    queryEmbedding,
-                    seedIds: [],
-                };
-            }
-            const indexVectorItems = indexSimilar.map((s) => ({
-                chunkId: s.id,
-                score: Math.max(0, 1 - s.distance),
-                source: 'vector',
-            }));
-            const indexKeywordItems = indexKeywordResults.map((r) => ({
-                chunkId: r.id,
-                score: r.score,
-                source: 'keyword',
-            }));
-            const indexFused = fuseRRF([
-                { items: indexVectorItems, weight: hybridSearch.vectorWeight },
-                ...(indexKeywordItems.length > 0
-                    ? [{ items: indexKeywordItems, weight: hybridSearch.keywordWeight }]
-                    : []),
-            ], hybridSearch.rrfK);
-            const indexEntryIds = indexFused.map((r) => r.chunkId);
-            const chunkIds = dereferenceToChunkIds(indexEntryIds);
-            const chunkScoreMap = new Map();
-            for (const item of indexFused) {
-                const entryChunkIds = dereferenceToChunkIds([item.chunkId]);
-                for (const cid of entryChunkIds) {
-                    const existing = chunkScoreMap.get(cid);
-                    if (!existing || item.score > existing.score) {
-                        chunkScoreMap.set(cid, { score: item.score, source: item.source });
-                    }
-                }
+    catch (error) {
+        log.warn('Entity search failed', { error: error.message });
+    }
+    return fusedResults;
+}
+/**
+ * Keyword-primary retrieval path.
+ *
+ * keyword → [optional vector enrichment] → entity boost
+ * No cluster expansion.
+ */
+async function keywordPrimarySearch(query, projectFilter, agentFilter, vectorSearchLimit, config) {
+    const { hybridSearch, embeddingModel } = config;
+    let queryEmbedding = [];
+    let keywordResults = [];
+    try {
+        const keywordStore = getKeywordStore();
+        keywordResults = projectFilter
+            ? keywordStore.searchByProject(query, projectFilter, hybridSearch.keywordSearchLimit, agentFilter)
+            : keywordStore.search(query, hybridSearch.keywordSearchLimit);
+    }
+    catch (error) {
+        log.warn('Keyword search failed', { error: error.message });
+    }
+    // Post-filter by agent when no project filter was used
+    keywordResults = filterByAgent(keywordResults, agentFilter, projectFilter, (id) => {
+        const chunk = getChunkById(id);
+        return chunk?.agentId;
+    });
+    let fusedResults = keywordResults.map((r) => ({
+        chunkId: r.id,
+        score: r.score,
+        source: 'keyword',
+    }));
+    // Optional vector enrichment: merge vector results via RRF
+    if (config.vectorEnrichment) {
+        try {
+            vectorStore.setModelId(embeddingModel);
+            const embedder = await getEmbedder(embeddingModel);
+            const queryResult = await embedder.embed(query, true);
+            queryEmbedding = queryResult.embedding;
+            let vectorResults = await (projectFilter
+                ? vectorStore.searchByProject(queryResult.embedding, projectFilter, vectorSearchLimit, agentFilter)
+                : vectorStore.search(queryResult.embedding, vectorSearchLimit));
+            vectorResults = filterByAgent(vectorResults, agentFilter, projectFilter, (id) => {
+                const chunk = getChunkById(id);
+                return chunk?.agentId;
+            });
+            if (vectorResults.length > 0) {
+                const vectorItems = vectorResults.map((s) => ({
+                    chunkId: s.id,
+                    score: Math.max(0, 1 - s.distance),
+                    source: 'vector',
+                }));
+                fusedResults = fuseRRF([
+                    { items: fusedResults, weight: hybridSearch.keywordWeight },
+                    { items: vectorItems, weight: hybridSearch.vectorWeight },
+                ], hybridSearch.rrfK);
             }
-            fusedResults = chunkIds.map((cid) => {
-                const entry = chunkScoreMap.get(cid);
-                return {
-                    chunkId: cid,
-                    score: entry?.score ?? 0,
-                    source: entry?.source,
-                };
+        }
+        catch (error) {
+            log.warn('Vector enrichment failed, using keyword results only', {
+                error: error.message,
             });
         }
-        else {
-            // ── Chunk-based search path (fallback) ─────────────────────────────
-            const vectorSearchPromise = projectFilter
-                ? vectorStore.searchByProject(queryResult.embedding, projectFilter, vectorSearchLimit, agentFilter)
-                : vectorStore.search(queryResult.embedding, vectorSearchLimit);
-            let keywordResults = [];
-            try {
-                const keywordStore = getKeywordStore();
-                keywordResults = projectFilter
-                    ? keywordStore.searchByProject(query, projectFilter, hybridSearch.keywordSearchLimit, agentFilter)
-                    : keywordStore.search(query, hybridSearch.keywordSearchLimit);
-            }
-            catch (error) {
-                log.warn('Keyword search unavailable, falling back to vector-only', {
-                    error: error.message,
-                });
-            }
-            let similar = await vectorSearchPromise;
-            if (agentFilter && !projectFilter) {
-                similar = similar.filter((s) => {
-                    const chunk = getChunkById(s.id);
-                    return chunk?.agentId === agentFilter;
-                });
-                keywordResults = keywordResults.filter((r) => {
-                    const chunk = getChunkById(r.id);
-                    return chunk?.agentId === agentFilter;
-                });
-            }
-            if (similar.length === 0 && keywordResults.length === 0) {
-                return {
-                    text: '',
-                    tokenCount: 0,
-                    chunks: [],
-                    totalConsidered: 0,
-                    durationMs: Date.now() - startTime,
-                    queryEmbedding,
-                    seedIds: [],
-                };
+    }
+    // Entity boost
+    fusedResults = applyEntityBoost(fusedResults, query, projectFilter, hybridSearch.rrfK);
+    if (fusedResults.length === 0) {
+        return null;
+    }
+    return { fusedResults, queryEmbedding, useIndexSearch: false };
+}
+/**
+ * Index-based hybrid retrieval path.
+ *
+ * Uses semantic index entries (vector + keyword) → RRF → dereference to chunks.
+ */
+async function indexBasedSearch(queryEmbedding, query, projectFilter, agentFilter, vectorSearchLimit, config) {
+    const { hybridSearch, embeddingModel } = config;
+    indexVectorStore.setModelId(embeddingModel);
+    const entryCount = getIndexEntryCount();
+    const indexedChunks = getIndexedChunkCount();
+    const entriesPerChunk = indexedChunks > 0 ? entryCount / indexedChunks : 1;
+    const indexSearchLimit = Math.ceil(vectorSearchLimit * entriesPerChunk);
+    const indexVectorPromise = projectFilter
+        ? indexVectorStore.searchByProject(queryEmbedding, projectFilter, indexSearchLimit, agentFilter)
+        : indexVectorStore.search(queryEmbedding, indexSearchLimit);
+    let indexKeywordResults = [];
+    try {
+        indexKeywordResults = searchIndexEntriesByKeyword(query, hybridSearch.keywordSearchLimit, projectFilter, agentFilter);
+    }
+    catch (error) {
+        log.warn('Index keyword search unavailable', {
+            error: error.message,
+        });
+    }
+    let indexSimilar = await indexVectorPromise;
+    indexSimilar = filterByAgent(indexSimilar, agentFilter, projectFilter, (id) => indexVectorStore.getChunkAgent(id));
+    indexKeywordResults = filterByAgent(indexKeywordResults, agentFilter, projectFilter, (id) => indexVectorStore.getChunkAgent(id));
+    if (indexSimilar.length === 0 && indexKeywordResults.length === 0) {
+        return null;
+    }
+    const indexVectorItems = indexSimilar.map((s) => ({
+        chunkId: s.id,
+        score: Math.max(0, 1 - s.distance),
+        source: 'vector',
+    }));
+    const indexKeywordItems = indexKeywordResults.map((r) => ({
+        chunkId: r.id,
+        score: r.score,
+        source: 'keyword',
+    }));
+    const indexFused = fuseRRF([
+        { items: indexVectorItems, weight: hybridSearch.vectorWeight },
+        ...(indexKeywordItems.length > 0
+            ? [{ items: indexKeywordItems, weight: hybridSearch.keywordWeight }]
+            : []),
+    ], hybridSearch.rrfK);
+    const indexEntryIds = indexFused.map((r) => r.chunkId);
+    const chunkIds = dereferenceToChunkIds(indexEntryIds);
+    const chunkScoreMap = new Map();
+    for (const item of indexFused) {
+        const entryChunkIds = dereferenceToChunkIds([item.chunkId]);
+        for (const cid of entryChunkIds) {
+            const existing = chunkScoreMap.get(cid);
+            if (!existing || item.score > existing.score) {
+                chunkScoreMap.set(cid, { score: item.score, source: item.source });
             }
-            const vectorItems = similar.map((s) => ({
-                chunkId: s.id,
-                score: Math.max(0, 1 - s.distance),
-                source: 'vector',
-            }));
-            const keywordItems = keywordResults.map((r) => ({
-                chunkId: r.id,
-                score: r.score,
-                source: 'keyword',
-            }));
-            fusedResults = fuseRRF([
-                { items: vectorItems, weight: hybridSearch.vectorWeight },
-                ...(keywordItems.length > 0
-                    ? [{ items: keywordItems, weight: hybridSearch.keywordWeight }]
-                    : []),
-            ], hybridSearch.rrfK);
-        }
-        // Cluster expansion (hybrid/vector path only)
-        if (!skipClusters) {
-            fusedResults = expandViaClusters(fusedResults, clusterExpansion, projectFilter, agentFilter, config.feedbackWeight);
         }
     }
+    const fusedResults = chunkIds.map((cid) => {
+        const entry = chunkScoreMap.get(cid);
+        return {
+            chunkId: cid,
+            score: entry?.score ?? 0,
+            source: entry?.source,
+        };
+    });
+    return { fusedResults, queryEmbedding, useIndexSearch: true };
+}
+/**
+ * Chunk-based hybrid retrieval path (fallback when no semantic index).
+ *
+ * vector + keyword → RRF
+ */
+async function chunkBasedSearch(queryEmbedding, query, projectFilter, agentFilter, vectorSearchLimit, config) {
+    const { hybridSearch } = config;
+    const vectorSearchPromise = projectFilter
+        ? vectorStore.searchByProject(queryEmbedding, projectFilter, vectorSearchLimit, agentFilter)
+        : vectorStore.search(queryEmbedding, vectorSearchLimit);
+    let keywordResults = [];
+    try {
+        const keywordStore = getKeywordStore();
+        keywordResults = projectFilter
+            ? keywordStore.searchByProject(query, projectFilter, hybridSearch.keywordSearchLimit, agentFilter)
+            : keywordStore.search(query, hybridSearch.keywordSearchLimit);
+    }
+    catch (error) {
+        log.warn('Keyword search unavailable, falling back to vector-only', {
+            error: error.message,
+        });
+    }
+    let similar = await vectorSearchPromise;
+    similar = filterByAgent(similar, agentFilter, projectFilter, (id) => {
+        const chunk = getChunkById(id);
+        return chunk?.agentId;
+    });
+    keywordResults = filterByAgent(keywordResults, agentFilter, projectFilter, (id) => {
+        const chunk = getChunkById(id);
+        return chunk?.agentId;
+    });
+    if (similar.length === 0 && keywordResults.length === 0) {
+        return null;
+    }
+    const vectorItems = similar.map((s) => ({
+        chunkId: s.id,
+        score: Math.max(0, 1 - s.distance),
+        source: 'vector',
+    }));
+    const keywordItems = keywordResults.map((r) => ({
+        chunkId: r.id,
+        score: r.score,
+        source: 'keyword',
+    }));
+    const fusedResults = fuseRRF([
+        { items: vectorItems, weight: hybridSearch.vectorWeight },
+        ...(keywordItems.length > 0
+            ? [{ items: keywordItems, weight: hybridSearch.keywordWeight }]
+            : []),
+    ], hybridSearch.rrfK);
+    return { fusedResults, queryEmbedding, useIndexSearch: false };
+}
+/**
+ * Shared post-processing pipeline that all retrieval paths converge on.
+ *
+ * source tracking → seed extraction → dedupe → recency boost + length penalty →
+ * size bounding → MMR reranking → score normalization → budget assembly
+ */
+async function postProcessResults(fusedResults, opts) {
+    const { queryEmbedding, maxTokens, currentSessionId, config, useIndexSearch } = opts;
     const sourceMap = new Map();
     for (const item of fusedResults) {
         if (item.source && !sourceMap.has(item.chunkId)) {
@@ -336,7 +355,7 @@ export async function searchContext(request) {
         return tokens !== undefined && tokens <= maxTokens;
     });
     // MMR reranking (diversity-aware, budget-aware ordering)
-    const reordered = await reorderWithMMR(sizeBounded, queryEmbedding, mmrReranking, {
+    const reordered = await reorderWithMMR(sizeBounded, queryEmbedding, config.mmrReranking, {
         tokenBudget: maxTokens,
         chunkTokenCounts: chunkTokenMap,
     });
@@ -356,11 +375,89 @@ export async function searchContext(request) {
         tokenCount: assembled.tokenCount,
         chunks: assembled.includedChunks,
         totalConsidered: deduped.length,
-        durationMs: Date.now() - startTime,
-        queryEmbedding,
         seedIds,
     };
 }
+// ── Main orchestrator ────────────────────────────────────────────────────────
+/**
+ * Run the search pipeline.
+ *
+ * Keyword-primary mode: keyword → [optional vector enrichment] → recency → MMR → budget
+ * Hybrid mode:          embed → [vector, keyword] → RRF → cluster expand → recency → MMR → budget
+ */
+export async function searchContext(request) {
+    const startTime = Date.now();
+    const externalConfig = loadConfig();
+    const config = toRuntimeConfig(externalConfig);
+    const { query, currentSessionId, projectFilter, maxTokens = config.mcpMaxResponseTokens, vectorSearchLimit = 20, skipClusters = false, agentFilter, } = request;
+    const { embeddingModel } = config;
+    const retrievalMode = config.retrievalPrimary;
+    const emptyResponse = {
+        text: '',
+        tokenCount: 0,
+        chunks: [],
+        totalConsidered: 0,
+        durationMs: Date.now() - startTime,
+        queryEmbedding: [],
+        seedIds: [],
+    };
+    let result;
+    if (retrievalMode === 'keyword') {
+        // ── Keyword-primary search path ──────────────────────────────────────
+        result = await keywordPrimarySearch(query, projectFilter, agentFilter, vectorSearchLimit, config);
+        if (!result) {
+            emptyResponse.durationMs = Date.now() - startTime;
+            return emptyResponse;
+        }
+        // Skip cluster expansion for keyword-primary mode
+    }
+    else {
+        // ── Hybrid/vector search path ────────────────────────────────────────
+        // Configure vector store for current model
+        vectorStore.setModelId(embeddingModel);
+        // 1. Embed query
+        const embedder = await getEmbedder(embeddingModel);
+        const queryResult = await embedder.embed(query, true);
+        const queryEmbedding = queryResult.embedding;
+        // Determine whether to use index-based search
+        const useIndexSearch = config.semanticIndex.useForSearch && getIndexEntryCount() > 0;
+        if (useIndexSearch) {
+            result = await indexBasedSearch(queryEmbedding, query, projectFilter, agentFilter, vectorSearchLimit, config);
+        }
+        else {
+            result = await chunkBasedSearch(queryEmbedding, query, projectFilter, agentFilter, vectorSearchLimit, config);
+        }
+        if (!result) {
+            emptyResponse.queryEmbedding = queryEmbedding;
+            emptyResponse.durationMs = Date.now() - startTime;
+            return emptyResponse;
+        }
+        // Entity boost (hybrid/vector path)
+        result.fusedResults = applyEntityBoost(result.fusedResults, query, projectFilter, config.hybridSearch.rrfK);
+        // Cluster expansion (hybrid/vector path only)
+        if (!skipClusters) {
+            result.fusedResults = expandViaClusters(result.fusedResults, config.clusterExpansion, projectFilter, agentFilter, config.feedbackWeight);
+        }
+    }
+    // ── Shared post-processing ───────────────────────────────────────────
+    const processed = await postProcessResults(result.fusedResults, {
+        queryEmbedding: result.queryEmbedding,
+        maxTokens,
+        currentSessionId,
+        config,
+        useIndexSearch: result.useIndexSearch,
+    });
+    return {
+        text: processed.text,
+        tokenCount: processed.tokenCount,
+        chunks: processed.chunks,
+        totalConsidered: processed.totalConsidered,
+        durationMs: Date.now() - startTime,
+        queryEmbedding: result.queryEmbedding,
+        seedIds: processed.seedIds,
+    };
+}
+// ── Budget assembly ──────────────────────────────────────────────────────────
 /**
  * Formatting overhead constants.
  *