@devflow-tools/context-engine 0.17.8 → 0.18.1

package/dist/context-engine.js

@@ -1,1741 +1,242 @@
-import CGModule from "@colbymchenry/codegraph";
-import { parseIntent, expandQuery } from "./intent-parser.js";
-import { buildRetrievalTaskPlan } from './retrieval-task-plan.js';
-import { fuzzySearch, shouldFallback } from "./fuzzy-fallback.js";
-import { compressToTokenLimit } from "./compressor.js";
-import { claudeRerank } from "./claude-rerank.js";
-import { invalidateContextPrefetchCache, QueryCache } from "./query-cache.js";
-import { rankOptionalContextFiles, } from "./ranker.js";
-import { describeLayerEvidence, detectLanguageFromPath, } from "./layer-rules.js";
-import { reachableCodeGraphNodeIds, sanitizeCodeGraphEdges, } from './graph-edge-quality.js';
-import { assembleContextFileRoles } from './context-file-roles.js';
-import { buildArtifactInventory } from './artifact-inventory.js';
-import { buildTaskContextEnvelope } from './task-retrieval-orchestrator.js';
-import { recordTaskEnvelopeLedger } from './retrieval-ledger.js';
-import { selectGraphEvidence } from './graph-evidence-selector.js';
+import { CodeEvidenceRuntime } from './code-evidence-producer.js';
 import { allocateContextFileBudget } from './context-budget-allocator.js';
-import { emitSemanticControlLog } from '@devflow-tools/telemetry';
-const CG = CGModule.default ?? CGModule;
-const SYMBOL_VECTOR_WARNING = "Symbol vector search is not ready; using CodeGraph/BM25 results. Run `devflow doctor` for details.";
-// ── RRF (Reciprocal Rank Fusion) ─────────────────────────────────
-const RRF_K = 60;
-function rrfFusion(fts5Nodes, vectorResults, cg) {
-    const scores = new Map();
-    const merged = new Map(fts5Nodes);
-    // FTS5 rank signals
-    let rank = 1;
-    for (const id of fts5Nodes.keys()) {
-        scores.set(id, 0.5 / (RRF_K + rank));
-        rank++;
-    }
-    // Vector rank signals + merge
-    rank = 1;
-    for (const { id } of vectorResults) {
-        const existing = scores.get(id) ?? 0;
-        scores.set(id, existing + 0.5 / (RRF_K + rank));
-        rank++;
-        if (!merged.has(id)) {
-            const node = cg.getNode(id);
-            if (node)
-                merged.set(id, node);
-        }
-    }
-    // Sort by score descending
-    const sorted = [...scores.entries()].sort((a, b) => b[1] - a[1]);
-    const result = new Map();
-    for (const [id] of sorted) {
-        const node = merged.get(id);
-        if (node)
-            result.set(id, node);
-    }
-    return result;
-}
 /**
- * Merge the original query with L1 dict expansion and Agent-provided English terms.
- * Deduplicates terms before sending to codegraph.
+ * Code-only facade for callers outside canonical cross-channel retrieval.
+ *
+ * Cross-channel retrieval is owned by retrieval-engine. This class does not
+ * classify prompts, read Memory/Knowledge, persist runtime state, or assemble
+ * composite receipts. New task-aware callers use CodeEvidenceProducer.
  */
-function mergeQueries(original, l1, agentTerms) {
-    const terms = new Set();
-    for (const q of [original, l1, agentTerms]) {
-        if (!q)
-            continue;
-        for (const w of q.split(/\s+/)) {
-            if (w.length >= 2)
-                terms.add(w.toLowerCase());
-        }
-    }
-    return [...terms].join(" ");
-}
-function sigmoid(x, midpoint = 0.5, steepness = 6) {
-    return 1 / (1 + Math.exp(-steepness * (x - midpoint)));
-}
-function calculateConfidence(input) {
-    // CodeGraph score: based on provided confidence, node count, and structural signals
-    let cgScore = typeof input.cgConfidence === "number" ? input.cgConfidence : 0;
-    if (cgScore === 0 && input.nodeCount > 0) {
-        // Derive from node count when explicit confidence unavailable
-        cgScore = sigmoid(Math.min(input.nodeCount, 30) / 30, 0.3, 8);
-    }
-    // Bonus for structural richness
-    if (input.hasEdges)
-        cgScore = Math.min(1, cgScore + 0.1);
-    if (input.hasExactMatches)
-        cgScore = Math.min(1, cgScore + 0.15);
-    // Knowledge score: diminishing returns after 5 hits
-    const knowledgeScore = sigmoid(input.knowledgeHitCount / 10, 0.3, 5);
-    // Memory score: diminishing returns
-    const memoryScore = sigmoid(input.memoryHitCount / 10, 0.25, 5);
-    // Node count score
-    const nodeScore = sigmoid(input.nodeCount / 30, 0.3, 5);
-    // Intent confidence
-    const intentScore = input.intentConfidence;
-    const weighted = cgScore * 0.35 +
-        knowledgeScore * 0.25 +
-        memoryScore * 0.2 +
-        nodeScore * 0.1 +
-        intentScore * 0.1;
-    let confidence = weighted;
-    if (typeof input.targetPrecision === 'number') {
-        confidence *= 0.55 + 0.45 * Math.max(0, Math.min(1, input.targetPrecision));
-    }
-    // Diversity bonus: all five signals present
-    const activeSignals = [cgScore > 0, input.knowledgeHitCount > 0, input.memoryHitCount > 0, input.nodeCount > 0, input.intentConfidence > 0].filter(Boolean).length;
-    if (activeSignals >= 4)
-        confidence += 0.05;
-    // Penalty: very low node count with no other signals
-    if (input.nodeCount < 3 && input.knowledgeHitCount === 0 && input.memoryHitCount === 0) {
-        confidence *= 0.5;
-    }
-    return Math.round(Math.min(1, Math.max(0, confidence)) * 100) / 100;
-}
-function getAdaptiveParams(fileCount) {
-    if (fileCount <= 200)
-        return { depth: 1, searchLimit: 5, maxNodes: 10 };
-    if (fileCount <= 1000)
-        return { depth: 2, searchLimit: 10, maxNodes: 20 };
-    return { depth: 3, searchLimit: 15, maxNodes: 30 };
-}
-const RISK_PATTERNS = [
-    { pattern: /(main|index|app|entry|bootstrap)\.(ts|tsx|js|jsx)$/i, level: "high", category: "main_flow" },
-    { pattern: /(config|settings?|env|constants?)\.(ts|tsx|js|jsx|json)$/i, level: "medium", category: "config" },
-    { pattern: /(store|state|context|provider|redux)\.(ts|tsx|js|jsx)$/i, level: "high", category: "global_state" },
-    { pattern: /(api|route|controller|handler|service|middleware)\.(ts|tsx|js|jsx)$/i, level: "medium", category: "api_contract" },
-];
-function buildGraphEvidence(nodes, rootIds, edges, _cg) {
-    const nodeIds = new Set(nodes.map(node => node.id));
-    const adjacency = new Map();
-    const reasons = new Map();
-    const connect = (source, target, reason) => {
-        if (!nodeIds.has(source) || !nodeIds.has(target))
-            return;
-        const targets = adjacency.get(source) ?? new Set();
-        targets.add(target);
-        adjacency.set(source, targets);
-        const sourceReasons = reasons.get(target) ?? [];
-        if (!sourceReasons.includes(reason))
-            sourceReasons.push(reason);
-        reasons.set(target, sourceReasons);
-    };
-    for (const edge of edges)
-        connect(edge.source, edge.target, `${edge.source} -> ${edge.target} graph edge`);
-    const distances = new Map();
-    const queue = [];
-    for (const root of rootIds) {
-        if (!nodeIds.has(root))
-            continue;
-        distances.set(root, 0);
-        queue.push(root);
-    }
-    while (queue.length > 0) {
-        const current = queue.shift();
-        const distance = distances.get(current);
-        for (const target of adjacency.get(current) ?? []) {
-            if (!distances.has(target)) {
-                distances.set(target, distance + 1);
-                queue.push(target);
-            }
-        }
-        for (const [source, targets] of adjacency) {
-            if (targets.has(current) && !distances.has(source)) {
-                distances.set(source, distance + 1);
-                queue.push(source);
-            }
-        }
-    }
-    for (const root of rootIds)
-        reasons.set(root, ["matched query symbol"]);
-    return { distances, reasons, roots: rootIds };
-}
-function generateRiskHints(nodes, graphEvidence) {
-    const hints = [];
-    const seen = new Set();
-    for (const node of nodes) {
-        const distance = graphEvidence.distances.get(node.id);
-        if (distance === undefined)
-            continue;
-        for (const { pattern, level, category } of RISK_PATTERNS) {
-            if (pattern.test(node.filePath)) {
-                const key = `${category}:${node.filePath}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const existing = hints.find(h => h.category === category && h.level === level);
-                if (existing) {
-                    if (!existing.affectedFiles.includes(node.filePath)) {
-                        existing.affectedFiles.push(node.filePath);
-                    }
-                }
-                else {
-                    hints.push({
-                        level,
-                        category,
-                        description: `${category.replace(/_/g, " ")} file: ${node.filePath}; ${distance === 0 ? "matched target" : `reachable in ${distance} graph hop${distance === 1 ? "" : "s"}`}`,
-                        affectedFiles: [node.filePath],
-                        score: distance === 0 ? 1 : Math.max(0.35, 1 - distance * 0.2),
-                        evidence: graphEvidence.reasons.get(node.id) ?? [],
-                    });
-                }
-            }
-        }
-    }
-    // Add cross-layer hint if files span multiple directory levels
-    const reachableNodes = nodes.filter(node => graphEvidence.distances.has(node.id));
-    const layers = new Set(reachableNodes.map(n => n.filePath.split("/")[0]));
-    if (layers.size >= 3) {
-        hints.push({
-            level: "medium",
-            category: "cross_layer",
-            description: `Changes span ${layers.size} top-level directories`,
-            affectedFiles: reachableNodes.slice(0, 5).map(n => n.filePath),
-            score: Math.min(1, 0.4 + layers.size * 0.1),
-            evidence: ["reachable files span multiple top-level directories"],
-        });
-    }
-    return hints.slice(0, 10);
-}
-const TASK_WORKFLOW_MAP = {
-    debug: ["debug"],
-    feature: ["feature"],
-    refactor: ["review"],
-    review: ["review"],
-    understand: ["scan"],
-    unknown: ["scan"],
-};
-function generateNextActions(taskType, topSymbols) {
-    const actions = [];
-    const workflows = TASK_WORKFLOW_MAP[taskType] ?? ["scan"];
-    for (const w of workflows) {
-        actions.push({ kind: "workflow", label: `Run ${w} workflow`, payload: w });
-    }
-    if (topSymbols.length > 0) {
-        actions.push({
-            kind: "graph_query",
-            label: `Explore ${topSymbols[0].name}`,
-            payload: topSymbols[0].name,
-        });
-    }
-    actions.push({
-        kind: "symbol_search",
-        label: "Search related symbols",
-        payload: topSymbols.slice(0, 3).map(s => s.name).join(" "),
-    });
-    return actions;
-}
-function extractTargetAnchors(query) {
-    const pathAnchors = new Set();
-    for (const match of query.matchAll(/(?:^|\s)([a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)+)/g)) {
-        if (match[1])
-            pathAnchors.add(match[1].replace(/^\.\//, '').replace(/\/+$/, '').toLowerCase());
-    }
-    if (pathAnchors.size > 0) {
-        const directories = [...pathAnchors]
-            .filter(anchor => /\.[a-z0-9]+$/iu.test(anchor))
-            .map(anchor => anchor.split('/').slice(0, -1).join('/'))
-            .filter(Boolean);
-        const existingNames = new Set([...pathAnchors].map(anchor => anchor.split('/').at(-1)));
-        for (const match of query.matchAll(/\b([A-Za-z0-9_.-]+\.(?:[cm]?[jt]sx?|vue|svelte|json|ya?ml|md))\b/gu)) {
-            const fileName = match[1]?.toLowerCase();
-            if (!fileName || existingNames.has(fileName))
-                continue;
-            if (directories.length === 1)
-                pathAnchors.add(`${directories[0]}/${fileName}`);
-        }
-        return [...pathAnchors];
-    }
-    const anchors = new Set();
-    for (const match of query.matchAll(/([a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)+)\s+(?:component|module|file|组件|模块|文件)/gi)) {
-        if (match[1])
-            anchors.add(match[1].toLowerCase());
-    }
-    return [...anchors];
-}
-function fileMatchesTargetAnchor(filePath, anchors) {
-    const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-    return anchors.some(anchor => normalized === anchor
-        || normalized.startsWith(`${anchor}/`)
-        || normalized.includes(`/${anchor}/`)
-        || normalized.includes(anchor));
-}
 export class ContextEngine {
-    cg;
-    data;
-    graph;
-    indexer;
-    memory;
-    knowledge;
-    embedder;
+    dependencies;
     symbolStore;
-    symbolEmbedder;
-    constructor(deps) {
-        this.cg = deps.cg;
-        this.data = deps.data;
-        this.graph = deps.graph;
-        this.indexer = deps.indexer;
-        this.memory = deps.memory;
-        this.knowledge = deps.knowledge;
-        this.embedder = deps.embedder;
-        this.symbolStore = deps.symbolStore;
-        this.symbolEmbedder = deps.symbolEmbedder;
+    runtime;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.symbolStore = dependencies.symbolStore;
+        this.runtime = new CodeEvidenceRuntime({
+            codegraph: dependencies.cg,
+            indexer: dependencies.indexer,
+            ...(dependencies.embedder ? { embedder: dependencies.embedder } : {}),
+            ...(dependencies.symbolStore ? { symbolStore: dependencies.symbolStore } : {}),
+        });
     }
     close() {
         this.symbolStore?.close();
         this.symbolStore = undefined;
     }
-    queryCache = new QueryCache(60_000, 100);
-    async recordPrefetchedContextSelection(input) {
-        await this.memory.recordContextEnvelopeSelection?.(input);
-    }
     async index(_projectRoot) {
-        await this.indexer.reconcile();
+        await this.dependencies.indexer.reconcile();
     }
-    getKnowledgeSearchOptions(query, limit, options = {}, taskPlan, totalBudget = 8_000) {
-        const stats = this.cg.getStats();
-        const frameworks = typeof this.cg.getDetectedFrameworks === "function"
-            ? this.cg.getDetectedFrameworks()
-            : [];
-        const languages = Object.keys(stats.filesByLanguage ?? {});
+    getStatus() {
+        const stats = this.dependencies.cg.getStats();
         return {
-            limit,
-            retrievalIntent: 'automatic_context',
-            budgetTokens: Math.max(0, Math.floor(totalBudget * 0.25)),
-            activeSkill: options.activeSkill,
-            relevantFiles: options.relevantFiles,
-            action: taskPlan?.action,
-            knowledgeNeeds: taskPlan?.knowledgeNeeds,
-            semanticNeedsResolved: (options.intentArtifact?.version ?? 1) >= 2,
-            sessionId: options.sessionId,
-            executionId: options.executionId,
-            requestId: options.requestId,
-            turnId: options.turnId,
-            intentArtifactHash: options.intentArtifact?.artifactHash,
-            queryPlanHash: options.queryPlan?.planHash,
-            projectSignals: {
-                frameworks,
-                languages,
-                activeSkill: options.activeSkill,
-                relevantFiles: options.relevantFiles,
-            },
+            totalFiles: stats.fileCount,
+            totalSymbols: stats.nodeCount,
+            lastIndexTime: stats.lastUpdated,
+            indexing: this.dependencies.cg.isIndexing(),
         };
     }
-    async searchKnowledgeWithStatus(query, options) {
-        const knowledge = this.knowledge;
-        if (typeof knowledge.searchWithStatus === 'function') {
-            const result = await knowledge.searchWithStatus(query, options);
-            return {
-                entries: result.entries,
-                warnings: result.warnings ?? [],
-                rejectedLowScore: result.rejectedLowScore,
-                rejectedIncompatibleSources: result.rejectedIncompatibleSources,
-                retrievalDiagnostics: result.retrievalDiagnostics,
-            };
-        }
-        return { entries: await knowledge.search(query, options), warnings: [] };
-    }
-    getFileLanguage(filePath) {
-        const file = this.cg.getFile?.(filePath);
-        return typeof file?.language === "string" ? file.language : detectLanguageFromPath(filePath);
-    }
     async build(request) {
-        const warnings = this.scheduleSymbolVectorBuild();
-        const maxTokens = request.maxTokens ?? 8000;
-        const intent = parseIntent(request.query);
-        const retrievalTaskPlan = buildRetrievalTaskPlan({
-            query: request.query,
-            parsedIntent: intent,
-            targetAnchors: request.relevantFiles,
-            activeSkill: request.activeSkill,
-        });
-        const stats = this.cg.getStats();
-        const adaptive = getAdaptiveParams(stats.fileCount ?? 500);
-        const depth = request.mode === "deep" ? 3 : adaptive.depth;
-        // Layer 1: ZH_EN_MAP dict expansion (offline, ~5ms)
-        const l1Query = expandQuery(request.query);
-        // Merge: original query + L1 dict terms + Agent-provided English terms
-        const combinedQuery = mergeQueries(request.query, l1Query, request.expandedTerms);
-        // 1. CodeGraph semantic search + graph traversal
-        const cgResult = await this.cg.findRelevantContext(combinedQuery, {
-            searchLimit: adaptive.searchLimit,
-            traversalDepth: depth,
-            maxNodes: request.mode === "deep" ? 30 : adaptive.maxNodes,
-        });
-        // Layer 3: Fuzzy fallback if primary search returned low confidence or too few results
-        if (shouldFallback(cgResult.nodes.size, cgResult.confidence)) {
-            const fallbackTerms = fuzzySearch(this.cg, combinedQuery, 10);
-            for (const term of fallbackTerms) {
-                const hits = this.cg.searchNodes(term, { limit: 3 });
-                for (const hit of hits) {
-                    if (!cgResult.nodes.has(hit.node.id)) {
-                        cgResult.nodes.set(hit.node.id, hit.node);
-                        if (!cgResult.roots.includes(hit.node.id)) {
-                            cgResult.roots.push(hit.node.id);
-                        }
-                    }
-                }
-            }
-        }
-        const vectorEmbedder = this.embedder;
-        const symbolStore = this.symbolStore;
-        // Vector recall: semantic search across all indexed symbols (bypasses FTS5 tokenization)
-        if (vectorEmbedder
-            && symbolStore
-            && this.isSymbolVectorReady(warnings)) {
-            try {
-                const queryEmbedding = await vectorEmbedder.embed(combinedQuery);
-                const vectorResults = symbolStore.search(queryEmbedding, 50);
-                if (vectorResults.length > 0) {
-                    const fused = rrfFusion(cgResult.nodes, vectorResults, this.cg);
-                    cgResult.nodes = fused;
-                    cgResult.roots = [...fused.keys()].slice(0, 3);
-                }
-            }
-            catch {
-                this.addSymbolVectorWarning(warnings);
-            }
-        }
-        // Embedding reranking (if available)
-        if (vectorEmbedder && this.isSymbolVectorReady(warnings)) {
-            try {
-                const nodesList = Array.from(cgResult.nodes.values());
-                const nodeTexts = nodesList.map(n => `${n.name} ${n.signature ?? ''} ${n.kind} ${n.filePath}`);
-                const queryEmbedding = await vectorEmbedder.embed(combinedQuery);
-                const nodeEmbeddings = await vectorEmbedder.embedBatch(nodeTexts);
-                const scoredNodes = nodesList.map((node, i) => {
-                    const nodeEmb = nodeEmbeddings[i];
-                    let dot = 0, normA = 0, normB = 0;
-                    for (let j = 0; j < queryEmbedding.length; j++) {
-                        dot += queryEmbedding[j] * nodeEmb[j];
-                        normA += queryEmbedding[j] * queryEmbedding[j];
-                        normB += nodeEmb[j] * nodeEmb[j];
-                    }
-                    const score = dot / (Math.sqrt(normA) * Math.sqrt(normB));
-                    return { node, score };
-                });
-                scoredNodes.sort((a, b) => b.score - a.score);
-                cgResult.nodes = new Map();
-                const topK = Math.min(scoredNodes.length, request.mode === "deep" ? 30 : adaptive.maxNodes);
-                for (const { node } of scoredNodes.slice(0, topK)) {
-                    cgResult.nodes.set(node.id, node);
-                }
-                cgResult.roots = scoredNodes.slice(0, 3).map(s => s.node.id);
-            }
-            catch {
-                this.addSymbolVectorWarning(warnings);
-            }
-        }
-        // Claude rerank (second pass, if available)
-        const allNodesList = Array.from(cgResult.nodes.values());
-        if (allNodesList.length > 30) {
-            try {
-                const reranked = await claudeRerank(combinedQuery, allNodesList.map(n => ({ id: n.id, name: n.name, snippet: n.signature ?? '', file: n.filePath })), { topK: 30 });
-                cgResult.nodes = new Map(reranked.map(r => [r.id, allNodesList.find(n => n.id === r.id)]));
-                cgResult.roots = reranked.slice(0, 3).map(r => r.id);
-            }
-            catch { /* keep embedding/bm25 ranking */ }
-        }
-        // 2. Knowledge + Memory in parallel
-        const [kResultsRaw, memResultsRaw] = await Promise.all([
-            this.searchKnowledgeWithStatus(combinedQuery, this.getKnowledgeSearchOptions(combinedQuery, 10, { activeSkill: request.activeSkill, relevantFiles: request.relevantFiles }, retrievalTaskPlan, maxTokens)).catch(() => ({ entries: [], warnings: [] })),
-            this.memory.search(request.query, {
-                limit: 5,
-                purpose: intent.intent,
-                scope: this.cg.getProjectRoot?.() ?? process.cwd(),
-                action: retrievalTaskPlan.action,
-                requiredPolicyFacets: retrievalTaskPlan.requiredPolicyFacets,
-            }).catch(() => []),
-        ]);
-        if (kResultsRaw.warnings.length > 0)
-            warnings.push(...kResultsRaw.warnings);
-        const knowledgeHits = kResultsRaw.entries;
-        const memoryContext = memResultsRaw.length > 0 ? {
-            relevant: memResultsRaw.map((r) => ({
-                content: r.entry.content,
-                category: r.entry.category,
-                score: r.score,
-            })),
-        } : undefined;
-        // 4. Build file snippets, layer by quality
-        const MIN_CORE_SCORE = 0.7;
-        const MIN_WEAK_SCORE = 0.4;
-        const L1_TOKEN_RATIO = 0.6;
-        const L2_TOKEN_RATIO = 0.3;
-        const ESTIMATED_TOKENS_PER_CHAR = 0.25;
-        function estimateTokens(text) {
-            return Math.ceil(text.length * ESTIMATED_TOKENS_PER_CHAR);
-        }
-        function diversityTrim(items, maxPerDir) {
-            const dirCount = new Map();
-            return items.filter(f => {
-                const dir = f.path.split('/').slice(0, -1).join('/') || f.path;
-                const count = dirCount.get(dir) ?? 0;
-                if (count >= maxPerDir)
-                    return false;
-                dirCount.set(dir, count + 1);
-                return true;
-            });
-        }
-        // Group by file, classify into L1/L2
-        const fileMap = new Map();
-        for (const [id, node] of cgResult.nodes) {
-            const fp = node.filePath;
-            const isRoot = cgResult.roots.includes(id);
-            if (fileMap.has(fp)) {
-                const existing = fileMap.get(fp);
-                existing.symbols.push(node.name);
-                existing.snippetParts.push(`// ${node.kind}: ${node.name}${node.signature ? ` ${node.signature}` : ""}`);
-                if (isRoot)
-                    existing.bestScore = 1.0;
-            }
-            else {
-                fileMap.set(fp, {
-                    symbols: [node.name],
-                    snippetParts: [`// ${node.kind}: ${node.name}${node.signature ? ` ${node.signature}` : ""}`],
-                    bestScore: isRoot ? 1.0 : 0.5,
-                });
-            }
-        }
-        const l1Files = [];
-        const l2Files = [];
-        for (const [fp, data] of fileMap) {
-            const snippet = {
-                path: fp,
-                snippet: data.snippetParts.join('\n'),
-                symbols: data.symbols,
-                score: data.bestScore,
-            };
-            if (data.bestScore >= MIN_CORE_SCORE) {
-                l1Files.push(snippet);
-            }
-            else if (data.bestScore >= MIN_WEAK_SCORE) {
-                l2Files.push(snippet);
-            }
-        }
-        // L3: knowledge hits (max 3)
-        const l3Files = knowledgeHits.slice(0, 3).map(kh => ({
-            path: kh.source ?? 'knowledge',
-            snippet: kh.content ?? '',
-            symbols: [kh.title ?? 'knowledge'],
-            score: 0.6,
-        }));
-        // Token budget allocation
-        const allFiles = [];
-        let remaining = maxTokens;
-        const l1Cap = Math.floor(maxTokens * L1_TOKEN_RATIO);
-        const l2Cap = Math.floor(maxTokens * L2_TOKEN_RATIO);
-        // L1: by score descending
-        let l1Used = 0;
-        for (const f of l1Files.sort((a, b) => (b.score ?? 0) - (a.score ?? 0))) {
-            const tokens = estimateTokens(f.snippet);
-            if (tokens <= remaining && l1Used + tokens <= l1Cap) {
-                allFiles.push(f);
-                remaining -= tokens;
-                l1Used += tokens;
-            }
-        }
-        // L2: diversity trim, then fill
-        let l2Used = 0;
-        for (const f of diversityTrim(l2Files, 2)) {
-            const tokens = Math.min(estimateTokens(f.snippet), 300);
-            if (remaining < tokens)
-                break;
-            if (l2Used + tokens > l2Cap)
-                continue;
-            allFiles.push(f);
-            remaining -= tokens;
-            l2Used += tokens;
-        }
-        // fallback: if nothing made it in, push top L1
-        if (allFiles.length === 0 && l1Files.length > 0) {
-            allFiles.push(l1Files.sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0]);
-        }
-        const tokenCount = allFiles.reduce((s, f) => s + estimateTokens(f.snippet), 0);
-        // Build graph output from subgraph
-        let graphOutput;
-        if (request.includeGraph) {
-            const graphNodes = [];
-            for (const n of cgResult.nodes.values()) {
-                graphNodes.push({
-                    id: n.id,
-                    name: n.name,
-                    type: n.kind,
-                    file: n.filePath,
-                });
-            }
-            graphOutput = {
-                nodes: graphNodes,
-                edges: cgResult.edges.map((e) => ({
-                    type: "depends_on",
-                    from: e.source,
-                    to: e.target,
-                })),
-            };
-        }
-        return {
-            files: allFiles,
-            knowledgeFiles: l3Files.length > 0 ? l3Files : undefined,
-            graph: graphOutput,
-            memory: memoryContext,
-            confidence: intent.confidence,
-            tokenCount,
-            warnings: warnings.length > 0 ? warnings : undefined,
-        };
-    }
-    async buildTaskContext(query, options) {
-        const warnings = this.scheduleSymbolVectorBuild();
-        const maxTokens = options?.maxTokens ?? 8000;
-        const mode = options?.mode ?? "fast";
-        const memoryRevision = this.memory.getRetrievalRevision?.() ?? 0;
-        const cacheKey = `ctx:${query}:${mode}:${options?.activeSkill ?? ""}:${(options?.relevantFiles ?? []).join(",")}:memory:${memoryRevision}`;
-        let cached = warnings.length === 0 && !options?.requestId
-            ? this.queryCache.get(cacheKey)
-            : undefined;
-        if (cached) {
-            const changed = typeof this.cg.getChangedFiles === 'function'
-                ? this.cg.getChangedFiles()
-                : {};
-            const changedPaths = [...(changed.added ?? []), ...(changed.modified ?? []), ...(changed.removed ?? [])];
-            const cachedPaths = [
-                ...getGroupFilePaths(cached.requiredFiles),
-                ...getGroupFilePaths(cached.optionalFiles),
-            ];
-            const freshness = this.indexer?.ensureFilesCurrent
-                ? await this.indexer.ensureFilesCurrent(cachedPaths, { refresh: false })
-                : null;
-            if (changedPaths.length > 0 || freshness?.files.some(file => !file.current)) {
-                this.queryCache.invalidatePaths(new Set([...changedPaths, ...(freshness?.stale ?? []), ...(freshness?.missing ?? [])]));
-                invalidateContextPrefetchCache(this.cg.getProjectRoot?.() ?? process.cwd());
-                cached = undefined;
-            }
-        }
-        if (cached) {
-            return {
-                ...cached,
-                warnings: warnings.length > 0 ? warnings : undefined,
-            };
-        }
-        const intent = parseIntent(query);
-        const taskType = intent.intent;
-        const combinedQuery = options?.queryPlan?.code[0]?.query
-            ?? mergeQueries(query, expandQuery(query), options?.expandedTerms);
-        const explicitTargetAnchors = options?.intentArtifact?.targetAnchors ?? extractTargetAnchors(query);
-        const initialTaskPlan = buildRetrievalTaskPlan({
-            query,
-            parsedIntent: intent,
-            targetAnchors: explicitTargetAnchors,
-            activeSkill: options?.activeSkill,
-            command: options?.command,
-            authoritativeArtifact: options?.intentArtifact,
-        });
-        const projectRoot = this.cg.getProjectRoot?.() ?? process.cwd();
-        const logIdentity = {
-            projectRoot,
-            sessionId: options?.sessionId,
-            turnId: options?.turnId,
-            requestId: options?.requestId,
-            executionId: options?.executionId,
-            intentArtifactHash: options?.intentArtifact?.artifactHash,
-            queryPlanHash: options?.queryPlan?.planHash,
+        const query = {
+            query: request.query.slice(0, 2_000),
+            targetAnchors: request.relevantFiles ?? [],
+            symbols: [],
+            relationKinds: ['dependency'],
+            maxDepth: request.mode === 'deep' ? 3 : 1,
         };
-        let artifactInventory = this.indexer
-            ? buildArtifactInventory({
-                codegraph: this.cg,
-                indexer: this.indexer,
-                query: combinedQuery,
-                explicitTargetAnchors,
-                action: initialTaskPlan.action,
-                identity: logIdentity,
-            })
-            : { entries: [], operationTargets: [], missingExplicitTargets: [], ambiguous: false };
-        const staleInventoryTargets = artifactInventory.operationTargets
-            .filter(entry => entry.freshness.exists && !entry.freshness.current)
-            .map(entry => entry.path);
-        if (this.indexer && staleInventoryTargets.length > 0) {
-            await this.indexer.ensureFilesCurrent(staleInventoryTargets, { refresh: true, timeoutMs: 5_000 });
-            artifactInventory = buildArtifactInventory({
-                codegraph: this.cg,
-                indexer: this.indexer,
-                query: combinedQuery,
-                explicitTargetAnchors,
-                action: initialTaskPlan.action,
-                identity: logIdentity,
-            });
-        }
-        const targetAnchors = [...new Set([
-                ...explicitTargetAnchors,
-                ...artifactInventory.operationTargets
-                    .filter(entry => entry.freshness.current)
-                    .map(entry => entry.path),
-            ])];
-        const retrievalTaskPlan = buildRetrievalTaskPlan({
+        const output = await this.runtime.search({
             query,
-            parsedIntent: intent,
-            targetAnchors,
-            activeSkill: options?.activeSkill,
-            command: options?.command,
-            authoritativeArtifact: options?.intentArtifact,
+            projectId: projectId(this.dependencies.cg),
+            contextHash: 'diagnostic-code-search',
+            tokenBudget: request.maxTokens ?? 8_000,
+            now: Date.now(),
         });
-        if (artifactInventory.missingExplicitTargets.length > 0) {
-            warnings.push(`explicit-target-missing:${artifactInventory.missingExplicitTargets.length}`);
-        }
-        if (artifactInventory.ambiguous)
-            warnings.push('artifact-target-ambiguous');
-        const timing = {};
-        const t0 = Date.now();
-        const [cgResult, knowledgeResult, memoryHits] = await Promise.all([
-            typeof this.cg.buildContext === "function"
-                ? Promise.race([
-                    this.cg.buildContext(combinedQuery, {
-                        searchLimit: mode === "deep" ? 10 : 5,
-                        traversalDepth: mode === "deep" ? 3 : 2,
-                        maxNodes: mode === "deep" ? 50 : 20,
-                        includeCode: false,
-                        format: "json",
-                    }),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("buildContext timeout")), 15000)),
-                ]).catch((err) => {
-                    emitSemanticControlLog({
-                        event: 'context.build.degraded', identity: logIdentity, level: 'warn', timestamp: Date.now(),
-                        data: { stage: 'codegraph_context', reason: err.message, fallback: 'manual_pipeline' },
-                    });
-                    return null;
-                })
-                : Promise.resolve(null),
-            Promise.race([
-                this.searchKnowledgeWithStatus(combinedQuery, this.getKnowledgeSearchOptions(combinedQuery, 5, options, retrievalTaskPlan, maxTokens)),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("knowledge timeout")), 5000)),
-            ]).catch((err) => {
-                emitSemanticControlLog({
-                    event: 'knowledge.search.degraded', identity: logIdentity, level: 'warn', timestamp: Date.now(),
-                    data: { reason: err.message, fallback: 'knowledge_empty' },
-                });
-                return { entries: [], warnings: [`knowledge-search-failed: ${err.message}`] };
-            }),
-            typeof this.memory.search === "function"
-                ? Promise.race([
-                    this.memory.search(query, {
-                        limit: 5,
-                        purpose: taskType,
-                        recordAccess: false,
-                        scope: this.cg.getProjectRoot?.() ?? process.cwd(),
-                        action: retrievalTaskPlan.action,
-                        requiredPolicyFacets: retrievalTaskPlan.requiredPolicyFacets,
-                    }),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("memory timeout")), 5000)),
-                ]).catch((err) => {
-                    emitSemanticControlLog({
-                        event: 'memory.search.completed', identity: logIdentity, level: 'warn', timestamp: Date.now(),
-                        data: { status: 'degraded', reason: err.message, selected: 0, fallback: 'memory_empty' },
-                    });
-                    return [];
-                })
-                : Promise.resolve([]),
-        ]);
-        timing["1_promise_all"] = Date.now() - t0;
-        const knowledgeHits = knowledgeResult.entries;
-        if (knowledgeResult.warnings.length > 0)
-            warnings.push(...knowledgeResult.warnings);
-        if (!cgResult) {
-            emitSemanticControlLog({
-                event: 'context.build.degraded', identity: logIdentity, level: 'warn', timestamp: Date.now(),
-                data: { stage: 'codegraph_context', reason: 'context_unavailable', fallback: 'manual_pipeline' },
-            });
-            const result = await this.buildTaskContextLegacy(query, options);
-            result._devflow = { fallback: "buildContext-unavailable" };
-            return result;
-        }
-        // buildContext returns JSON string when format="json" — parse it
-        let ctx;
-        if (typeof cgResult === "string") {
-            try {
-                ctx = JSON.parse(cgResult);
-            }
-            catch {
-                emitSemanticControlLog({
-                    event: 'context.build.degraded', identity: logIdentity, level: 'warn', timestamp: Date.now(),
-                    data: { stage: 'codegraph_parse', reason: 'unparseable_context', fallback: 'manual_pipeline' },
-                });
-                return this.buildTaskContextLegacy(query, options);
-            }
-        }
-        else {
-            ctx = cgResult;
-        }
-        ctx.nodes = Array.isArray(ctx.nodes) ? ctx.nodes : [];
-        ctx.entryPoints = Array.isArray(ctx.entryPoints) ? ctx.entryPoints : [];
-        const inventoryNodeIds = new Set(ctx.nodes.map((node) => String(node.id ?? '')));
-        for (const target of artifactInventory.operationTargets.filter(entry => entry.freshness.current)) {
-            const nodes = this.cg.getNodesInFile(target.path)
-                .filter(node => node.kind !== 'file' && node.kind !== 'import');
-            for (const node of nodes) {
-                if (!inventoryNodeIds.has(node.id)) {
-                    ctx.nodes.push(node);
-                    inventoryNodeIds.add(node.id);
-                }
-            }
-            const root = nodes.find(node => target.symbols.includes(node.name)) ?? nodes[0];
-            if (root && !ctx.entryPoints.some((entry) => entry.id === root.id))
-                ctx.entryPoints.unshift(root);
-        }
-        await this.applyTaskSymbolVectorRecall(ctx, combinedQuery, warnings);
-        this.clearRecoveredSymbolWarning(warnings);
-        // Fallback: direct searchNodes for query terms that buildContext may have missed
-        // (e.g. hyphenated terms like "post-tool-use" get tokenized and lost in FTS noise)
-        const tFallback = Date.now();
-        const existingFiles = new Set((ctx.nodes ?? []).map((n) => n.filePath));
-        const existingIds = new Set((ctx.nodes ?? []).map((n) => n.id));
-        const fallbackTerms = combinedQuery.split(/\s+/).filter(w => w.length > 2).sort((a, b) => b.length - a.length).slice(0, 5);
-        for (const term of fallbackTerms) {
-            const hits = this.cg.searchNodes(term, { limit: 3 });
-            for (const hit of hits) {
-                if (!existingFiles.has(hit.node.filePath)) {
-                    const fileNodes = this.cg.getNodesInFile(hit.node.filePath);
-                    let addedCount = 0;
-                    const MAX_PER_FILE = 5;
-                    // Only add the matching symbol + a few high-value symbols (functions, components, classes)
-                    for (const fn of fileNodes) {
-                        if (fn.kind === "file" || fn.kind === "import" || existingIds.has(fn.id))
-                            continue;
-                        const isHighValue = fn.kind === "function" || fn.kind === "class" || fn.kind === "component" || fn.kind === "method";
-                        if (addedCount >= MAX_PER_FILE && !isHighValue)
-                            continue;
-                        ctx.nodes.push(fn);
-                        existingIds.add(fn.id);
-                        addedCount++;
-                    }
-                    existingFiles.add(hit.node.filePath);
-                    // Lexical fallback is supporting evidence, not a graph root. Promoting
-                    // it to an entry point turns weak term matches into required files.
-                }
-            }
-        }
-        timing["2_fallback_loop"] = Date.now() - tFallback;
-        const fileFreshnessByPath = new Map();
-        if (this.indexer?.ensureFilesCurrent) {
-            const candidatePaths = [...new Set([
-                    ...ctx.nodes.map((node) => String(node.filePath ?? '')).filter(Boolean),
-                    ...ctx.entryPoints.map((entry) => String(entry.filePath ?? '')).filter(Boolean),
-                ])];
-            const freshness = await this.indexer.ensureFilesCurrent(candidatePaths, { refresh: true, timeoutMs: 5_000 });
-            for (const file of freshness.files)
-                fileFreshnessByPath.set(file.path, file);
-            const rejectedPaths = new Set([...freshness.missing, ...freshness.stale]);
-            if (rejectedPaths.size > 0 || freshness.refreshed.length > 0) {
-                this.queryCache.invalidatePaths(new Set([...rejectedPaths, ...freshness.refreshed]));
-                invalidateContextPrefetchCache(this.cg.getProjectRoot?.() ?? process.cwd());
-            }
-            if (freshness.missing.length > 0)
-                warnings.push(`codegraph-missing-files:${freshness.missing.length}`);
-            if (freshness.stale.length > 0)
-                warnings.push(`codegraph-stale-degraded:${freshness.stale.length}`);
-            ctx.nodes = ctx.nodes.filter((node) => !rejectedPaths.has(node.filePath));
-            ctx.entryPoints = ctx.entryPoints.filter((entry) => !rejectedPaths.has(entry.filePath));
-            if (Array.isArray(ctx.edges) && rejectedPaths.size > 0) {
-                const retainedIds = new Set(ctx.nodes.map((node) => node.id));
-                ctx.edges = ctx.edges.filter((edge) => retainedIds.has(edge.source) && retainedIds.has(edge.target));
-            }
-        }
-        const edgeQuality = sanitizeCodeGraphEdges(this.cg, Array.isArray(ctx.edges) ? ctx.edges : []);
-        ctx.edges = edgeQuality.accepted;
-        if (edgeQuality.rejected.length > 0) {
-            warnings.push(`codegraph-relations-rejected:${edgeQuality.rejected.length}`);
-            emitSemanticControlLog({
-                event: 'codegraph.edge.rejected',
-                identity: logIdentity,
-                level: 'warn',
-                timestamp: Date.now(),
-                data: {
-                    rejectedCount: edgeQuality.rejected.length,
-                    reasons: countValues(edgeQuality.rejected.map(edge => edge.reason)),
-                    examples: edgeQuality.rejected.slice(0, 8).map(edge => ({
-                        kind: edge.kind,
-                        sourceFile: edge.sourceFile,
-                        targetFile: edge.targetFile,
-                        reason: edge.reason,
+        const selected = packCandidates(output.candidates, request.maxTokens ?? 8_000);
+        return {
+            files: selected.map(toSnippet),
+            ...(request.includeGraph ? {
+                graph: {
+                    nodes: selected.map(candidate => ({
+                        id: candidate.evidence.sourceId,
+                        type: String(candidate.payload.kind ?? 'unknown'),
+                        name: String(candidate.payload.symbol ?? ''),
+                        file: String(candidate.payload.path ?? ''),
+                        metadata: {},
                     })),
+                    edges: [],
                 },
-            });
-        }
-        const tSnippet = Date.now();
-        let allNodes = ctx.nodes ?? [];
-        const originalEntryPoints = (ctx.entryPoints ?? []);
-        const anchoredEntryPoints = targetAnchors.length > 0
-            ? originalEntryPoints.filter(entry => fileMatchesTargetAnchor(entry.filePath, targetAnchors))
-            : originalEntryPoints;
-        const graphSelection = selectGraphEvidence({
-            codegraph: this.cg,
-            candidates: originalEntryPoints,
-            symbols: retrievalTaskPlan.symbols,
-            targetAnchors,
-        });
-        const evidenceEntryPoints = graphSelection.selected.length > 0
-            ? graphSelection.selected
-            : originalEntryPoints;
-        const selectedAnchoredEntryPoints = targetAnchors.length > 0
-            ? evidenceEntryPoints.filter(entry => fileMatchesTargetAnchor(entry.filePath, targetAnchors))
-            : evidenceEntryPoints;
-        const effectiveEntryPoints = selectedAnchoredEntryPoints.length > 0
-            ? selectedAnchoredEntryPoints
-            : anchoredEntryPoints.length > 0 ? anchoredEntryPoints : evidenceEntryPoints;
-        if (graphSelection.ambiguities.length > 0) {
-            warnings.push(`codegraph-symbol-ambiguity:${graphSelection.ambiguities.length}`);
-        }
-        const rootIds = new Set(effectiveEntryPoints.map((ep) => ep.id));
-        const reachableNodeIds = reachableCodeGraphNodeIds(rootIds, edgeQuality.accepted);
-        const entryFiles = new Set(effectiveEntryPoints.map((entry) => entry.filePath));
-        const protectedTerms = combinedQuery.toLocaleLowerCase('en-US')
-            .split(/\s+/u)
-            .filter(term => term.length >= 4);
-        allNodes = allNodes.filter(node => {
-            if (reachableNodeIds.has(node.id) || entryFiles.has(node.filePath))
-                return true;
-            const text = `${node.name ?? ''} ${node.filePath ?? ''}`.toLocaleLowerCase('en-US');
-            return protectedTerms.some(term => text.includes(term));
-        });
-        ctx.nodes = allNodes;
-        const requiredFileSet = new Set();
-        const optionalFileSet = new Set();
-        const keySymbols = [];
-        const entryFileSet = new Set(effectiveEntryPoints.map((ep) => ep.filePath));
-        const graphEvidence = buildGraphEvidence(allNodes.filter(node => node.id && node.filePath), rootIds, Array.isArray(ctx.edges) ? ctx.edges : [], this.cg);
-        const perFileCount = new Map();
-        const MAX_SYMBOLS_PER_FILE = 5;
-        const optionalCandidates = new Map();
-        const graphOptionalPaths = new Set();
-        const queryTerms = combinedQuery.split(/\s+/).map(term => term.toLowerCase()).filter(term => term.length >= 3);
-        for (const target of artifactInventory.operationTargets) {
-            if (target.freshness.current)
-                requiredFileSet.add(target.path);
-        }
-        for (const node of allNodes) {
-            // Skip file wrappers and import edges — they're not actionable symbols
-            if (node.kind === "file" || node.kind === "import")
-                continue;
-            const isDirect = targetAnchors.length > 0
-                ? fileMatchesTargetAnchor(node.filePath, targetAnchors)
-                : rootIds.has(node.id) || entryFileSet.has(node.filePath);
-            if (isDirect) {
-                requiredFileSet.add(node.filePath);
-            }
-            else {
-                const distance = graphEvidence.distances.get(node.id);
-                const text = `${node.name} ${node.signature ?? ""} ${node.filePath}`.toLowerCase();
-                const lexicalMatches = queryTerms.filter(term => text.includes(term));
-                const evidence = [
-                    ...(graphEvidence.reasons.get(node.id) ?? []),
-                    ...(lexicalMatches.length > 0 ? [`matched query term${lexicalMatches.length > 1 ? "s" : ""}: ${lexicalMatches.join(", ")}`] : []),
-                ];
-                // A path-anchored request already identifies the target precisely. Only
-                // direct graph neighbours are useful supporting context; wider graph
-                // traversal and generic lexical matches reintroduce unrelated modules.
-                const hasStrongTargetEvidence = targetAnchors.length === 0
-                    ? evidence.length > 0
-                    : distance !== undefined && distance <= 1;
-                if (hasStrongTargetEvidence) {
-                    const graphScore = distance === undefined ? 0 : Math.max(0.35, 0.8 - distance * 0.15);
-                    const lexicalScore = Math.min(0.3, lexicalMatches.length * 0.1);
-                    const score = Math.min(1, graphScore + lexicalScore);
-                    const existing = optionalCandidates.get(node.filePath);
-                    if (!existing || score > existing.score) {
-                        optionalCandidates.set(node.filePath, {
-                            path: node.filePath,
-                            score,
-                            evidence,
-                            symbols: [],
-                            snippet: "",
-                            distance,
-                        });
-                        graphOptionalPaths.add(node.filePath);
-                    }
-                }
-            }
-            const count = perFileCount.get(node.filePath) ?? 0;
-            if (count < MAX_SYMBOLS_PER_FILE && (isDirect || optionalCandidates.has(node.filePath))) {
-                perFileCount.set(node.filePath, count + 1);
-                keySymbols.push({
-                    name: node.name,
-                    file: node.filePath,
-                    kind: node.kind,
-                    relevance: isDirect ? "direct" : "indirect",
-                });
-            }
-        }
-        const fileRoleByPath = new Map();
-        for (const artifact of artifactInventory.entries.filter(entry => entry.freshness.current)) {
-            fileRoleByPath.set(artifact.path, {
-                path: artifact.path,
-                role: artifact.artifactRole === 'operation_target' ? 'target' : 'dependency',
-                artifactRole: artifact.artifactRole,
-                score: artifact.score,
-                evidence: artifact.evidence,
-            });
-            fileFreshnessByPath.set(artifact.path, artifact.freshness);
-        }
-        const roleCandidates = this.indexer
-            ? assembleContextFileRoles({
-                codegraph: this.cg,
-                indexer: this.indexer,
-                targetFiles: [...requiredFileSet],
-                taskType,
-            })
-            : [];
-        for (const candidate of roleCandidates) {
-            if (this.indexer?.getFileFreshness) {
-                fileFreshnessByPath.set(candidate.path, this.indexer.getFileFreshness(candidate.path));
-            }
-            const inventoryRole = fileRoleByPath.get(candidate.path);
-            fileRoleByPath.set(candidate.path, inventoryRole && inventoryRole.score >= candidate.score
-                ? inventoryRole
-                : candidate);
-            if (candidate.role === 'target') {
-                requiredFileSet.add(candidate.path);
-                continue;
-            }
-            const existing = optionalCandidates.get(candidate.path);
-            if (!existing || candidate.score > existing.score) {
-                optionalCandidates.set(candidate.path, {
-                    path: candidate.path,
-                    score: candidate.score,
-                    evidence: candidate.evidence,
-                    symbols: [],
-                    snippet: '',
-                    distance: candidate.role === 'caller' ? 1 : undefined,
-                });
-            }
-        }
-        let rankedOptionalFiles = rankOptionalContextFiles([...optionalCandidates.values()], taskType);
-        const codeBudget = allocateContextFileBudget({
-            requiredPaths: requiredFileSet,
-            candidates: rankedOptionalFiles.map(candidate => ({
-                path: candidate.path,
-                score: candidate.score,
-                source: fileRoleByPath.has(candidate.path) && fileRoleByPath.get(candidate.path)?.role !== 'dependency'
-                    ? 'structural'
-                    : graphOptionalPaths.has(candidate.path) ? 'graph' : 'structural',
-            })),
-            tokenBudget: Math.floor(maxTokens * 0.45),
-            graphRatio: 0.2,
-        });
-        rankedOptionalFiles = rankedOptionalFiles.filter(candidate => codeBudget.selectedPaths.has(candidate.path));
-        if (codeBudget.rejectedPaths.size > 0)
-            warnings.push(`codegraph-budget-rejected:${codeBudget.rejectedPaths.size}`);
-        for (const candidate of rankedOptionalFiles)
-            optionalFileSet.add(candidate.path);
-        if (this.indexer?.getFileFreshness) {
-            for (const path of [...requiredFileSet, ...optionalFileSet]) {
-                const freshness = fileFreshnessByPath.get(path) ?? this.indexer.getFileFreshness(path);
-                fileFreshnessByPath.set(path, freshness);
-                if (freshness.current)
-                    continue;
-                requiredFileSet.delete(path);
-                optionalFileSet.delete(path);
-                fileRoleByPath.delete(path);
-            }
-            rankedOptionalFiles = rankedOptionalFiles.filter(candidate => optionalFileSet.has(candidate.path));
-        }
-        const optionalCandidateByPath = new Map(rankedOptionalFiles.map(candidate => [candidate.path, candidate]));
-        const retainedFiles = new Set([...requiredFileSet, ...optionalFileSet]);
-        for (let index = keySymbols.length - 1; index >= 0; index--) {
-            if (!retainedFiles.has(keySymbols[index].file))
-                keySymbols.splice(index, 1);
-        }
-        // Fallback: when code graph returns no nodes but knowledge/memory have hits,
-        // the query is likely a non-code question (e.g. "how to run the project").
-        // Surface knowledge and memory results as the primary context.
-        const isNonCodeQuery = allNodes.length === 0 && (knowledgeHits.length > 0 || memoryHits.length > 0);
-        const cgReasoning = isNonCodeQuery ? [{
-                source: "graph_root",
-                fileGroup: "knowledge-memory",
-                explanation: `No code symbols matched — query interpreted as a non-code question. Falling back to project knowledge (${knowledgeHits.length} hits) and memory (${memoryHits.length} hits).`,
-            }] : [{
-                source: "graph_root",
-                fileGroup: "codegraph-buildContext",
-                explanation: ctx.summary
-                    ? `CodeGraph: ${ctx.summary}`
-                    : `CodeGraph matched ${allNodes.length} nodes across ${requiredFileSet.size + optionalFileSet.size} files`,
-            }];
-        const knowledgeReasoning = knowledgeHits.map((k) => ({
-            source: "knowledge",
-            fileGroup: k.source ?? "knowledge",
-            explanation: `Knowledge entry "${k.title || k.source || "source"}" matched query${typeof k.score === "number" ? ` with score ${k.score.toFixed(2)}` : ""}`,
-        }));
-        const memoryReasoning = memoryHits.map((m) => ({
-            source: "memory",
-            fileGroup: m.entry?.category ?? "memory",
-            explanation: `Memory entry matched: ${String(m.entry?.content ?? "").slice(0, 100)}`,
-        }));
-        const allFileSnippets = [];
-        for (const fp of [...requiredFileSet].sort()) {
-            const nodesInFile = allNodes.filter(n => n.filePath === fp);
-            allFileSnippets.push({
-                path: fp,
-                snippet: nodesInFile.map(n => `// ${n.kind}: ${n.name}${n.signature ? ` ${n.signature}` : ""}`).join("\n"),
-                symbols: nodesInFile.map(n => n.name),
-                score: 1.0,
-            });
-        }
-        for (const fp of [...optionalFileSet].sort()) {
-            const nodesInFile = allNodes.filter(n => n.filePath === fp);
-            allFileSnippets.push({
-                path: fp,
-                snippet: nodesInFile.map(n => `// ${n.kind}: ${n.name}${n.signature ? ` ${n.signature}` : ""}`).join("\n"),
-                symbols: nodesInFile.map(n => n.name),
-                score: 0.5,
-            });
-        }
-        const compressed = compressToTokenLimit(allFileSnippets, Math.floor(maxTokens * 0.45));
-        if (compressed.overBudget)
-            warnings.push("context-compressor-budget-exceeded");
-        timing["3_snippet_compress"] = Date.now() - tSnippet;
-        const riskHints = generateRiskHints(allNodes.filter(node => node.kind !== "file" && node.kind !== "import"), graphEvidence);
-        const nextActions = generateNextActions(taskType, keySymbols.slice(0, 5));
-        const rootPrecision = targetAnchors.length === 0
-            ? 1
-            : requiredFileSet.size === 0
-                ? 0
-                : [...requiredFileSet].filter(file => fileMatchesTargetAnchor(file, targetAnchors)).length / requiredFileSet.size;
-        if (targetAnchors.length > 0 && effectiveEntryPoints.length < originalEntryPoints.length) {
-            warnings.push(`context-quality-filtered:${originalEntryPoints.length - effectiveEntryPoints.length}`);
-        }
-        const provenanceFiles = [];
-        for (const file of [...requiredFileSet].sort()) {
-            const node = allNodes.find(candidate => candidate.filePath === file);
-            const language = this.getFileLanguage(file);
-            const layer = describeLayerEvidence(file, language);
-            provenanceFiles.push({
-                path: file,
-                layer: "codegraph",
-                score: 1,
-                evidence: [
-                    ...(node ? [`matched symbol ${node.name}`] : []),
-                    ...(graphEvidence.reasons.get(node?.id ?? "") ?? []),
-                ],
-                reason: `required as ${fileRoleByPath.get(file)?.role ?? 'target'} by CodeGraph evidence (${layer.evidence})`,
-            });
-        }
-        for (const candidate of rankedOptionalFiles) {
-            const layer = describeLayerEvidence(candidate.path, this.getFileLanguage(candidate.path));
-            provenanceFiles.push({
-                path: candidate.path,
-                layer: "codegraph",
-                score: candidate.score,
-                evidence: candidate.evidence,
-                reason: `selected as ${fileRoleByPath.get(candidate.path)?.role ?? 'dependency'} (${layer.evidence})`,
-            });
-        }
-        const knowledgeScore = knowledgeHits.length === 0
-            ? 0
-            : knowledgeHits.reduce((total, hit) => total + (typeof hit.score === "number" ? hit.score : 0.5), 0) / knowledgeHits.length;
-        const memoryScore = memoryHits.length === 0
-            ? 0
-            : memoryHits.reduce((total, hit) => total + (typeof hit.score === "number" ? hit.score : 0), 0) / memoryHits.length;
-        const provenance = {
-            layers: [
-                {
-                    layer: "codegraph",
-                    score: requiredFileSet.size > 0 ? 1 : 0,
-                    evidence: [`${requiredFileSet.size} required and ${optionalFileSet.size} optional repository files retained`],
-                },
-                {
-                    layer: "knowledge",
-                    score: knowledgeScore,
-                    evidence: knowledgeHits.slice(0, 5).map((hit) => `${hit.source ?? "knowledge"}: ${hit.title || "untitled"}`),
-                },
-                {
-                    layer: "memory",
-                    score: memoryScore,
-                    evidence: memoryHits.slice(0, 5).map((hit) => String(hit.entry?.content ?? "").slice(0, 120)),
-                },
-            ],
-            files: provenanceFiles,
-        };
-        const result = {
-            taskType,
-            requiredFiles: {
-                files: [...requiredFileSet],
-                symbols: keySymbols.filter(s => s.relevance === "direct").map(s => s.name).slice(0, 30),
-                reasoning: isNonCodeQuery
-                    ? [...cgReasoning, ...knowledgeReasoning, ...memoryReasoning]
-                    : cgReasoning,
-            },
-            optionalFiles: {
-                files: [...optionalFileSet],
-                symbols: keySymbols.filter(s => s.relevance === "indirect").map(s => s.name).slice(0, 30),
-                reasoning: isNonCodeQuery ? [] : [
-                    ...rankedOptionalFiles.map(candidate => ({
-                        source: "dependency_trace",
-                        fileGroup: candidate.path,
-                        explanation: candidate.evidence.join("; "),
-                    })),
-                ],
-            },
-            keySymbols: keySymbols
-                .sort((a, b) => {
-                // Direct before indirect
-                if (a.relevance === "direct" && b.relevance !== "direct")
-                    return -1;
-                if (a.relevance !== "direct" && b.relevance === "direct")
-                    return 1;
-                // Functions/classes before constants/variables
-                const kindScore = (k) => k === "function" || k === "method" || k === "class" ? 0 :
-                    k === "component" || k === "interface" || k === "type" ? 1 :
-                        k === "variable" || k === "constant" || k === "enum" ? 2 : 3;
-                return kindScore(a.kind) - kindScore(b.kind);
-            })
-                .slice(0, 20),
-            graphSummary: {
-                roots: [...rootIds],
-                traversalDepth: ctx.stats?.traversalDepth ?? 2,
-                relatedNodeCount: allNodes.length,
-            },
-            riskHints,
-            nextActions,
-            reasoning: [...cgReasoning, ...knowledgeReasoning, ...memoryReasoning],
-            confidence: calculateConfidence({
-                cgConfidence: ctx.stats?.confidence,
-                knowledgeHitCount: knowledgeHits.length,
-                memoryHitCount: memoryHits.length,
-                nodeCount: allNodes.length,
-                intentConfidence: intent.confidence,
-                hasEdges: Array.isArray(ctx.edges) && (ctx.edges.length > 0),
-                hasExactMatches: keySymbols.some(s => s.relevance === "direct"),
-                targetPrecision: rootPrecision,
-            }),
-            tokenCount: compressed.tokenCount,
-            warnings: warnings.length > 0 ? warnings : undefined,
-            provenance,
+            } : {}),
+            confidence: codeConfidence(selected),
+            tokenCount: selected.reduce((sum, candidate) => sum + (candidate.estimatedTokens ?? 0), 0),
+            ...(output.gaps.length > 0 || output.rejectedRefs.length > 0
+                ? { warnings: reasonCodes(output.gaps.map(item => item.reason), output.rejectedRefs.map(item => item.reason)) }
+                : {}),
         };
-        result.taskEnvelope = buildTaskContextEnvelope({
-            query,
-            result,
-            projectRoot: this.cg.getProjectRoot?.() ?? process.cwd(),
-            sessionId: options?.sessionId,
-            executionId: options?.executionId,
-            requestId: options?.requestId,
-            host: options?.host,
-            command: options?.command,
-            turnId: options?.turnId,
-            intentArtifact: options?.intentArtifact,
-            queryPlan: options?.queryPlan,
-            tokenBudget: maxTokens,
-            targetAnchors,
-            taskPlan: retrievalTaskPlan,
-            graphAmbiguities: graphSelection.ambiguities,
-            codeBudget: {
-                maxFiles: codeBudget.maxFiles,
-                graphFileLimit: codeBudget.graphFileLimit,
-                selectedGraphFiles: codeBudget.selectedGraphFiles,
-            },
-            fileRoles: fileRoleByPath,
-            fileFreshness: fileFreshnessByPath,
-            memoryHits,
-            knowledgeHits,
-            rejectedCodeRelations: edgeQuality.rejected.length,
-            knowledgeRejected: (knowledgeResult.rejectedLowScore ?? 0)
-                + (knowledgeResult.rejectedIncompatibleSources ?? 0)
-                + Object.values((knowledgeResult
-                    .retrievalDiagnostics?.qualityRejected) ?? {}).reduce((total, count) => total + count, 0),
-        });
-        try {
-            recordTaskEnvelopeLedger(result.taskEnvelope);
-        }
-        catch {
-            result.warnings = [...(result.warnings ?? []), 'retrieval-ledger-degraded'];
-        }
-        if (options?.requestId && result.taskEnvelope.memory.entries.length > 0) {
-            try {
-                await this.memory.recordContextEnvelopeSelection?.({
-                    entries: result.taskEnvelope.memory.entries,
-                    sessionId: options.sessionId,
-                    executionId: options.executionId,
-                    requestId: options.requestId,
-                    query,
-                    contextReceipt: result.taskEnvelope.receipt.contextHash,
-                });
-            }
-            catch {
-                result.warnings = [...(result.warnings ?? []), 'memory-attribution-degraded'];
-            }
-        }
-        if (warnings.length === 0 && !options?.requestId) {
-            this.queryCache.set(cacheKey, result);
-        }
-        timing["0_total"] = Date.now() - t0;
-        emitSemanticControlLog({
-            event: 'codegraph.selection.completed',
-            identity: {
-                ...logIdentity,
-                contextReceipt: result.taskEnvelope?.receipt.contextHash,
-            },
-            level: warnings.length > 0 ? 'warn' : 'info',
-            timestamp: Date.now(),
-            data: {
-                selectedFiles: result.taskEnvelope?.code.files.length ?? 0,
-                selectedSymbols: result.taskEnvelope?.code.symbols.length ?? 0,
-                rejectedRelations: result.taskEnvelope?.quality.code.rejected ?? 0,
-                ambiguityCount: result.taskEnvelope?.code.ambiguities?.length ?? 0,
-                timing,
-                warnings: warnings.map(value => value.split(':')[0]),
-            },
-        });
-        result._timing = timing;
-        return result;
     }
-    async buildTaskContextLegacy(query, options) {
-        const warnings = this.scheduleSymbolVectorBuild();
-        const stats = this.cg.getStats();
-        const adaptive = getAdaptiveParams(stats.fileCount ?? 500);
-        const maxTokens = options?.maxTokens ?? 8000;
-        const depth = options?.mode === "deep" ? 3 : Math.max(2, adaptive.depth);
-        const intent = parseIntent(query);
-        const taskType = intent.intent;
-        // L1 dict + agent terms merge
-        const l1Query = expandQuery(query);
-        const combinedQuery = mergeQueries(query, l1Query, options?.expandedTerms);
-        // CodeGraph semantic search + graph traversal
-        const cgResult = await this.cg.findRelevantContext(combinedQuery, {
-            searchLimit: 10,
-            traversalDepth: depth,
-            maxNodes: depth === 3 ? 30 : 15,
-        });
-        await this.applyLegacySymbolVectorRecall(cgResult, query, warnings);
-        this.clearRecoveredSymbolWarning(warnings);
-        const fileFreshnessByPath = new Map();
-        if (this.indexer?.ensureFilesCurrent) {
-            const candidatePaths = [...new Set(Array.from(cgResult.nodes.values()).map(node => node.filePath))];
-            const freshness = await this.indexer.ensureFilesCurrent(candidatePaths, { refresh: true, timeoutMs: 5_000 });
-            for (const file of freshness.files)
-                fileFreshnessByPath.set(file.path, file);
-            const rejectedPaths = new Set([...freshness.missing, ...freshness.stale]);
-            for (const [id, node] of cgResult.nodes) {
-                if (rejectedPaths.has(node.filePath))
-                    cgResult.nodes.delete(id);
-            }
-            cgResult.roots = cgResult.roots.filter(id => cgResult.nodes.has(id));
-            if (freshness.missing.length > 0)
-                warnings.push(`codegraph-missing-files:${freshness.missing.length}`);
-            if (freshness.stale.length > 0)
-                warnings.push(`codegraph-stale-degraded:${freshness.stale.length}`);
-            if (rejectedPaths.size > 0 || freshness.refreshed.length > 0) {
-                this.queryCache.invalidatePaths(new Set([...rejectedPaths, ...freshness.refreshed]));
-                invalidateContextPrefetchCache(this.cg.getProjectRoot?.() ?? process.cwd());
-            }
-        }
-        const edgeQuality = sanitizeCodeGraphEdges(this.cg, cgResult.edges ?? []);
-        if (edgeQuality.rejected.length > 0) {
-            warnings.push(`codegraph-relations-rejected:${edgeQuality.rejected.length}`);
-        }
-        // Build full node list for classification
-        const allNodes = Array.from(cgResult.nodes.values());
-        const rootIds = new Set(cgResult.roots);
-        // Get outgoing edges to classify direct vs indirect dependencies
-        const directDeps = new Set();
-        for (const rootId of rootIds) {
-            const edges = sanitizeCodeGraphEdges(this.cg, this.cg.getOutgoingEdges(rootId)).accepted;
-            for (const e of edges)
-                directDeps.add(e.target);
-        }
-        const graphEvidence = buildGraphEvidence(allNodes.filter(node => node.id && node.filePath), rootIds, edgeQuality.accepted, this.cg);
-        // Classify files into required (root matches + direct deps) and evidence-ranked optional files.
-        const requiredFileSet = new Set();
-        const requiredSymbols = [];
-        const optionalFileSet = new Set();
-        const optionalSymbols = [];
-        const optionalCandidates = new Map();
-        const queryTerms = query.split(/\s+/).map(term => term.toLowerCase()).filter(term => term.length >= 3);
-        for (const node of allNodes) {
-            const fp = node.filePath;
-            if (rootIds.has(node.id) || directDeps.has(node.id)) {
-                requiredFileSet.add(fp);
-                requiredSymbols.push(node.name);
-            }
-            else {
-                const distance = graphEvidence.distances.get(node.id);
-                const text = `${node.name} ${node.signature ?? ""} ${node.filePath}`.toLowerCase();
-                const lexicalMatches = queryTerms.filter(term => text.includes(term));
-                const evidence = [
-                    ...(graphEvidence.reasons.get(node.id) ?? []),
-                    ...(lexicalMatches.length > 0 ? [`matched query term${lexicalMatches.length > 1 ? "s" : ""}: ${lexicalMatches.join(", ")}`] : []),
-                ];
-                if (evidence.length === 0)
-                    continue;
-                const score = Math.min(1, (distance === undefined ? 0 : Math.max(0.35, 0.8 - distance * 0.15)) + Math.min(0.3, lexicalMatches.length * 0.1));
-                const existing = optionalCandidates.get(fp);
-                if (!existing || score > existing.score) {
-                    optionalCandidates.set(fp, {
-                        path: fp,
-                        score,
-                        evidence,
-                        symbols: [],
-                        snippet: "",
-                        distance,
-                    });
-                }
-            }
-        }
-        const targetAnchors = extractTargetAnchors(query);
-        const retrievalTaskPlan = buildRetrievalTaskPlan({
+    async buildTaskContext(queryText, options = {}) {
+        const planned = options.queryPlan?.code;
+        const codeQueries = planned
+            ? planned.requirement === 'prohibited' ? [] : [planned.typedQuery]
+            : [directCodeQuery(queryText, options)];
+        const budget = options.maxTokens ?? 8_000;
+        const outputs = await Promise.all(codeQueries.map(query => this.runtime.search({
             query,
-            parsedIntent: intent,
-            targetAnchors,
-            activeSkill: options?.activeSkill,
-            command: options?.command,
-        });
-        const roleTargets = targetAnchors.length > 0
-            ? [...requiredFileSet].filter(file => fileMatchesTargetAnchor(file, targetAnchors))
-            : allNodes.filter(node => rootIds.has(node.id)).map(node => node.filePath);
-        const fileRoleByPath = new Map();
-        const roleCandidates = this.indexer
-            ? assembleContextFileRoles({
-                codegraph: this.cg,
-                indexer: this.indexer,
-                targetFiles: [...new Set(roleTargets)],
-                taskType,
-            })
-            : [];
-        for (const candidate of roleCandidates) {
-            if (this.indexer?.getFileFreshness) {
-                fileFreshnessByPath.set(candidate.path, this.indexer.getFileFreshness(candidate.path));
-            }
-            fileRoleByPath.set(candidate.path, candidate);
-            if (candidate.role === 'target') {
-                requiredFileSet.add(candidate.path);
-                continue;
-            }
-            const existing = optionalCandidates.get(candidate.path);
-            if (!existing || candidate.score > existing.score) {
-                optionalCandidates.set(candidate.path, {
-                    path: candidate.path,
-                    score: candidate.score,
-                    evidence: candidate.evidence,
-                    symbols: [],
-                    snippet: '',
-                    distance: candidate.role === 'caller' ? 1 : undefined,
-                });
-            }
-        }
-        let rankedOptionalFiles = rankOptionalContextFiles([...optionalCandidates.values()], taskType);
-        for (const candidate of rankedOptionalFiles)
-            optionalFileSet.add(candidate.path);
-        if (this.indexer?.getFileFreshness) {
-            for (const path of [...requiredFileSet, ...optionalFileSet]) {
-                const freshness = fileFreshnessByPath.get(path) ?? this.indexer.getFileFreshness(path);
-                fileFreshnessByPath.set(path, freshness);
-                if (freshness.current)
-                    continue;
-                requiredFileSet.delete(path);
-                optionalFileSet.delete(path);
-                fileRoleByPath.delete(path);
-            }
-            rankedOptionalFiles = rankedOptionalFiles.filter(candidate => optionalFileSet.has(candidate.path));
-        }
-        for (const node of allNodes) {
-            if (optionalFileSet.has(node.filePath))
-                optionalSymbols.push(node.name);
-        }
-        // Sort required files: roots first, then alphabetically
-        const requiredFilesList = [...requiredFileSet].sort((a, b) => {
-            const aIsRoot = allNodes.some(n => n.filePath === a && rootIds.has(n.id));
-            const bIsRoot = allNodes.some(n => n.filePath === b && rootIds.has(n.id));
-            if (aIsRoot && !bIsRoot)
-                return -1;
-            if (!aIsRoot && bIsRoot)
-                return 1;
-            return a.localeCompare(b);
-        });
-        const optionalFilesList = [...optionalFileSet].sort();
-        // Build reasoning for file groups
-        const requiredReasoning = requiredFilesList.slice(0, 10).map(file => {
-            const node = allNodes.find(n => n.filePath === file);
-            if (!node)
-                return null;
-            const isRoot = rootIds.has(node.id);
-            return {
-                source: (isRoot ? "graph_root" : "dependency_trace"),
-                fileGroup: file,
-                explanation: isRoot
-                    ? `Matched query "${query}" via semantic search on symbol "${node.name}"`
-                    : `Dependency of a root match, relevant for context`,
-            };
-        }).filter(Boolean);
-        const optionalReasoning = rankedOptionalFiles.map(candidate => {
-            return {
-                source: "dependency_trace",
-                fileGroup: candidate.path,
-                explanation: candidate.evidence.join("; "),
-            };
-        });
-        // Key symbols: root symbols as "direct", non-root as "indirect"
-        const keySymbols = allNodes
-            .filter(n => requiredFileSet.has(n.filePath) || optionalFileSet.has(n.filePath))
-            .map(n => ({
-            name: n.name,
-            file: n.filePath,
-            kind: n.kind,
-            relevance: (rootIds.has(n.id) ? "direct" : "indirect"),
+            projectId: projectId(this.dependencies.cg),
+            contextHash: options.queryPlan?.planHash ?? 'diagnostic-code-search',
+            tokenBudget: Math.max(256, Math.floor(budget / codeQueries.length)),
+            now: Date.now(),
+        })));
+        const candidates = dedupeCandidates(outputs.flatMap(output => output.candidates));
+        const selected = packCandidates(candidates, budget);
+        const required = selected.filter(candidate => candidate.strength === 'strong');
+        const optional = selected.filter(candidate => candidate.strength !== 'strong');
+        const paths = [...new Set(selected.map(candidate => String(candidate.payload.path ?? '')))].filter(Boolean);
+        const riskHints = generateRiskHints(paths);
+        const warnings = reasonCodes(outputs.flatMap(output => output.gaps.map(item => item.reason)), outputs.flatMap(output => output.rejectedRefs.map(item => item.reason)));
+        const reasoning = selected.map(candidate => ({
+            source: candidate.strength === 'weak' ? 'fuzzy_search' : 'dependency_trace',
+            fileGroup: String(candidate.payload.path ?? candidate.evidence.sourceId),
+            explanation: `${candidate.strength} code evidence from ${candidate.contributingLegs.map(leg => leg.leg).join(', ')}`,
         }));
-        // Graph summary
-        const graphSummary = {
-            roots: cgResult.roots,
-            traversalDepth: depth,
-            relatedNodeCount: allNodes.length,
-        };
-        // Generate risk hints
-        const riskHints = generateRiskHints(allNodes.filter(node => node.kind !== "file" && node.kind !== "import"), graphEvidence);
-        // Generate next actions
-        const nextActions = generateNextActions(taskType, keySymbols.slice(0, 5));
-        // Knowledge hits
-        let knowledgeReasoning = [];
-        let knowledgeHits = [];
-        try {
-            const kResults = await this.searchKnowledgeWithStatus(combinedQuery, this.getKnowledgeSearchOptions(combinedQuery, 5, options, retrievalTaskPlan, maxTokens));
-            if (kResults.warnings.length > 0)
-                warnings.push(...kResults.warnings);
-            knowledgeHits = kResults.entries;
-            knowledgeReasoning = kResults.entries.map(k => ({
-                source: "knowledge",
-                fileGroup: k.source ?? "knowledge",
-                explanation: `Knowledge entry "${k.title || k.source || "source"}" matched query${typeof k.score === "number" ? ` with score ${k.score.toFixed(2)}` : ""}`,
-            }));
-        }
-        catch {
-            // knowledge may be empty
-        }
-        // Memory context
-        let memoryReasoning = [];
-        let memoryHits = [];
-        try {
-            memoryHits = await this.memory.search(query, {
-                limit: 5,
-                purpose: taskType,
-                scope: this.cg.getProjectRoot?.() ?? process.cwd(),
-                action: retrievalTaskPlan.action,
-                requiredPolicyFacets: retrievalTaskPlan.requiredPolicyFacets,
-                recordAccess: false,
-            });
-            memoryReasoning = memoryHits.map((hit) => ({
-                source: 'memory',
-                fileGroup: hit.entry?.title ?? 'project memory',
-                explanation: `Selected applicable memory ${hit.entry?.id ?? 'unknown'} with score ${hit.score ?? 0}`,
-            }));
-        }
-        catch {
-            // memory may be empty
-        }
-        // Compress: prioritize required files, then optional
-        const allFileSnippets = [];
-        for (const file of requiredFilesList) {
-            const nodesInFile = allNodes.filter(n => n.filePath === file);
-            allFileSnippets.push({
-                path: file,
-                snippet: nodesInFile.map(n => `// ${n.kind}: ${n.name}${n.signature ? ` ${n.signature}` : ""}`).join("\n"),
-                symbols: nodesInFile.map(n => n.name),
-                score: 1.0,
-            });
-        }
-        for (const file of optionalFilesList) {
-            const nodesInFile = allNodes.filter(n => n.filePath === file);
-            allFileSnippets.push({
-                path: file,
-                snippet: nodesInFile.map(n => `// ${n.kind}: ${n.name}${n.signature ? ` ${n.signature}` : ""}`).join("\n"),
-                symbols: nodesInFile.map(n => n.name),
-                score: 0.5,
-            });
-        }
-        const compressed = compressToTokenLimit(allFileSnippets, Math.floor(maxTokens * 0.45));
-        if (compressed.overBudget)
-            warnings.push("context-compressor-budget-exceeded");
-        const requiredPaths = new Set(compressed.files.filter(f => requiredFileSet.has(f.path)).map(f => f.path));
-        const optionalPaths = new Set(compressed.files.filter(f => optionalFileSet.has(f.path)).map(f => f.path));
+        const taskType = taskTypeFromProjection(options);
         const result = {
             taskType,
-            requiredFiles: {
-                files: [...requiredPaths],
-                symbols: requiredSymbols.filter((_, i) => i < 30),
-                reasoning: requiredReasoning,
-            },
-            optionalFiles: {
-                files: [...optionalPaths],
-                symbols: optionalSymbols.filter((_, i) => i < 30),
-                reasoning: optionalReasoning,
+            selectedEvidence: selected,
+            requiredFiles: group(required, reasoning),
+            optionalFiles: group(optional, reasoning),
+            keySymbols: selected.flatMap(candidate => {
+                const symbol = typeof candidate.payload.symbol === 'string' ? candidate.payload.symbol : undefined;
+                const path = typeof candidate.payload.path === 'string' ? candidate.payload.path : undefined;
+                const kind = typeof candidate.payload.kind === 'string' ? candidate.payload.kind : 'unknown';
+                return symbol && path ? [{
+                        name: symbol, file: path, kind,
+                        relevance: candidate.strength === 'strong' ? 'direct' : 'indirect',
+                    }] : [];
+            }),
+            graphSummary: {
+                roots: required.map(candidate => candidate.evidence.sourceId),
+                traversalDepth: Math.max(0, ...codeQueries.map(query => query.maxDepth)),
+                relatedNodeCount: selected.length,
             },
-            keySymbols: keySymbols.slice(0, 20),
-            graphSummary,
             riskHints,
-            nextActions,
-            reasoning: [...requiredReasoning, ...optionalReasoning, ...knowledgeReasoning, ...memoryReasoning],
-            confidence: intent.confidence,
-            tokenCount: compressed.tokenCount,
-            warnings: warnings.length > 0 ? warnings : undefined,
+            nextActions: selected.slice(0, 1).flatMap(candidate => {
+                const symbol = typeof candidate.payload.symbol === 'string' ? candidate.payload.symbol : undefined;
+                return symbol ? [{ kind: 'graph_query', label: `Explore ${symbol}`, payload: symbol }] : [];
+            }),
+            reasoning,
+            confidence: codeConfidence(selected),
+            tokenCount: selected.reduce((sum, candidate) => sum + (candidate.estimatedTokens ?? 0), 0),
+            ...(warnings.length > 0 ? { warnings } : {}),
             provenance: {
-                layers: [
-                    {
-                        layer: "codegraph",
-                        score: requiredFileSet.size > 0 ? 1 : 0,
-                        evidence: [`${requiredFileSet.size} required and ${optionalFileSet.size} optional repository files retained`],
-                    },
-                    {
-                        layer: "knowledge",
-                        score: knowledgeReasoning.length > 0 ? 0.5 : 0,
-                        evidence: knowledgeReasoning.map(reason => reason.explanation),
-                    },
-                    {
-                        layer: "memory",
-                        score: 0,
-                        evidence: memoryReasoning.map(reason => reason.explanation),
-                    },
-                ],
-                files: [
-                    ...requiredFilesList.map(file => ({
-                        path: file,
-                        layer: "codegraph",
-                        score: 1,
-                        evidence: ["matched target or direct dependency"],
-                        reason: "required by CodeGraph evidence",
-                    })),
-                    ...rankedOptionalFiles.map(candidate => ({
-                        path: candidate.path,
-                        layer: "codegraph",
-                        score: candidate.score,
-                        evidence: candidate.evidence,
-                        reason: "optional file survived graph/query evidence",
-                    })),
-                ],
+                layers: [{
+                        layer: 'codegraph', score: codeConfidence(selected),
+                        evidence: [`${required.length} strong, ${optional.filter(item => item.strength === 'supporting').length} supporting, ${optional.filter(item => item.strength === 'weak').length} weak candidates`],
+                    }],
+                files: selected.map(candidate => ({
+                    path: String(candidate.payload.path ?? candidate.evidence.sourceId),
+                    layer: 'codegraph', score: strengthScore(candidate.strength),
+                    evidence: candidate.contributingLegs.map(leg => leg.leg),
+                    reason: `${candidate.strength} typed code evidence`,
+                })),
             },
         };
-        result.taskEnvelope = buildTaskContextEnvelope({
-            query,
-            result,
-            projectRoot: this.cg.getProjectRoot?.() ?? process.cwd(),
-            sessionId: options?.sessionId,
-            executionId: options?.executionId,
-            requestId: options?.requestId,
-            host: options?.host,
-            command: options?.command,
-            turnId: options?.turnId,
-            intentArtifact: options?.intentArtifact,
-            queryPlan: options?.queryPlan,
-            tokenBudget: maxTokens,
-            targetAnchors,
-            fileRoles: fileRoleByPath,
-            fileFreshness: fileFreshnessByPath,
-            memoryHits,
-            knowledgeHits,
-            rejectedCodeRelations: edgeQuality.rejected.length,
-            taskPlan: retrievalTaskPlan,
-        });
         return result;
     }
-    scheduleSymbolVectorBuild() {
-        const warnings = [];
-        try {
-            if (this.symbolEmbedder) {
-                void this.symbolEmbedder.buildAllIfNeeded().catch(() => {
-                    // Status is retained by SymbolEmbedder and surfaced on the next request.
-                });
-            }
-        }
-        catch {
-            this.addSymbolVectorWarning(warnings);
-        }
-        this.isSymbolVectorReady(warnings);
-        return warnings;
-    }
-    async applyTaskSymbolVectorRecall(ctx, query, warnings) {
-        const embedder = this.embedder;
-        const symbolStore = this.symbolStore;
-        if (!embedder || !symbolStore || !this.isSymbolVectorReady(warnings)) {
-            return;
-        }
-        try {
-            const combinedQuery = mergeQueries(query, expandQuery(query));
-            const queryEmbedding = await embedder.embed(combinedQuery);
-            const vectorResults = symbolStore.search(queryEmbedding, 50);
-            if (vectorResults.length === 0)
-                return;
-            const currentNodes = new Map(ctx.nodes.map((node) => [node.id, node]));
-            const fused = rrfFusion(currentNodes, vectorResults, this.cg);
-            ctx.nodes = [...fused.values()];
-            ctx.entryPoints = [...fused.values()].slice(0, 3);
-        }
-        catch {
-            this.addSymbolVectorWarning(warnings);
-        }
-    }
-    async applyLegacySymbolVectorRecall(result, query, warnings) {
-        const vectorContext = {
-            nodes: [...result.nodes.values()],
-            entryPoints: result.roots
-                .map((id) => result.nodes.get(id))
-                .filter(Boolean),
-        };
-        await this.applyTaskSymbolVectorRecall(vectorContext, query, warnings);
-        result.nodes = new Map(vectorContext.nodes.map((node) => [node.id, node]));
-        result.roots = vectorContext.entryPoints.map((node) => node.id);
-    }
-    isSymbolVectorReady(warnings) {
-        try {
-            const ready = this.embedder?.getStatus() === "ready"
-                && this.symbolEmbedder?.getStatus().state === "ready";
-            if (!ready)
-                this.addSymbolVectorWarning(warnings);
-            return ready;
-        }
-        catch {
-            this.addSymbolVectorWarning(warnings);
-            return false;
-        }
-    }
-    addSymbolVectorWarning(warnings) {
-        if (!warnings.includes(SYMBOL_VECTOR_WARNING)) {
-            warnings.push(SYMBOL_VECTOR_WARNING);
-        }
-    }
-    clearRecoveredSymbolWarning(warnings) {
-        const currentStatus = [];
-        if (!this.isSymbolVectorReady(currentStatus))
-            return;
-        const index = warnings.indexOf(SYMBOL_VECTOR_WARNING);
-        if (index >= 0)
-            warnings.splice(index, 1);
-    }
-    getStatus() {
-        const stats = this.cg.getStats();
-        return {
-            totalFiles: stats.fileCount,
-            totalSymbols: stats.nodeCount,
-            lastIndexTime: stats.lastUpdated,
-            indexing: this.cg.isIndexing(),
-        };
+}
+function directCodeQuery(query, options) {
+    return {
+        query: query.slice(0, 2_000),
+        targetAnchors: options.relevantFiles ?? [],
+        symbols: [],
+        relationKinds: ['dependency'],
+        maxDepth: options.mode === 'deep' ? 3 : 1,
+    };
+}
+function taskTypeFromProjection(options) {
+    const intent = options.intentArtifact?.intent;
+    return intent === 'debug' || intent === 'feature' || intent === 'refactor'
+        || intent === 'understand' || intent === 'review' ? intent : 'unknown';
+}
+function group(candidates, reasoning) {
+    const files = [...new Set(candidates.map(candidate => String(candidate.payload.path ?? '')))].filter(Boolean);
+    const symbols = [...new Set(candidates.map(candidate => String(candidate.payload.symbol ?? '')).filter(Boolean))];
+    return { files, symbols, reasoning: reasoning.filter(item => files.includes(item.fileGroup)) };
+}
+function packCandidates(candidates, tokenBudget) {
+    const allocation = allocateContextFileBudget({
+        requiredPaths: candidates
+            .filter(candidate => candidate.strength === 'strong')
+            .map(candidate => String(candidate.payload.path ?? candidate.evidence.sourceId)),
+        candidates: candidates.map(candidate => ({
+            path: String(candidate.payload.path ?? candidate.evidence.sourceId),
+            score: strengthScore(candidate.strength),
+            source: candidate.contributingLegs.some(leg => /graph/iu.test(leg.leg)) ? 'graph' : 'structural',
+            hop: candidate.contributingLegs.some(leg => /graph/iu.test(leg.leg)) ? 1 : undefined,
+        })),
+        tokenBudget,
+    });
+    const sorted = [...candidates].sort((left, right) => strengthScore(right.strength) - strengthScore(left.strength)
+        || left.rank - right.rank
+        || left.stableRef.localeCompare(right.stableRef));
+    const result = [];
+    let used = 0;
+    for (const candidate of sorted) {
+        const path = String(candidate.payload.path ?? candidate.evidence.sourceId);
+        if (!allocation.selectedPaths.has(path))
+            continue;
+        const cost = Math.max(1, candidate.estimatedTokens ?? 128);
+        if (used + cost > tokenBudget)
+            continue;
+        result.push(candidate);
+        used += cost;
     }
+    return result;
 }
-function getGroupFilePaths(group) {
-    if (Array.isArray(group))
-        return group;
-    return group?.files ?? [];
+function dedupeCandidates(candidates) {
+    return [...new Map(candidates.map(candidate => [candidate.stableRef, candidate])).values()];
+}
+function toSnippet(candidate) {
+    const symbol = String(candidate.payload.symbol ?? 'symbol');
+    const kind = String(candidate.payload.kind ?? 'unknown');
+    return {
+        path: String(candidate.payload.path ?? candidate.evidence.sourceId),
+        symbols: [symbol],
+        snippet: `// ${kind}: ${symbol}`,
+        score: strengthScore(candidate.strength),
+    };
+}
+function codeConfidence(candidates) {
+    if (candidates.some(candidate => candidate.strength === 'strong'))
+        return 0.9;
+    if (candidates.some(candidate => candidate.strength === 'supporting'))
+        return 0.65;
+    if (candidates.length > 0)
+        return 0.35;
+    return 0;
+}
+function strengthScore(value) {
+    return value === 'strong' ? 1 : value === 'supporting' ? 0.65 : 0.3;
+}
+function projectId(codegraph) {
+    return `project:${codegraph.getProjectRoot?.() ?? process.cwd()}`;
+}
+function generateRiskHints(paths) {
+    const rules = [
+        { pattern: /(?:^|\/)(?:main|index|app|entry|bootstrap)\.[^/]+$/iu, level: 'high', category: 'main_flow' },
+        { pattern: /(?:config|settings?|env|constants?)/iu, level: 'medium', category: 'config' },
+        { pattern: /(?:store|state|provider|redux)/iu, level: 'high', category: 'global_state' },
+        { pattern: /(?:api|route|controller|handler|service|middleware)/iu, level: 'medium', category: 'api_contract' },
+    ];
+    return rules.flatMap(rule => {
+        const affectedFiles = paths.filter(path => rule.pattern.test(path));
+        return affectedFiles.length > 0 ? [{
+                level: rule.level, category: rule.category,
+                description: `${rule.category.replaceAll('_', ' ')} code evidence`, affectedFiles,
+            }] : [];
+    });
 }
-function countValues(values) {
-    const counts = {};
-    for (const value of values)
-        counts[value] = (counts[value] ?? 0) + 1;
-    return counts;
+function reasonCodes(...groups) {
+    return [...new Set(groups.flat().map(value => value.slice(0, 160)))];
 }
 //# sourceMappingURL=context-engine.js.map