@devflow-tools/context-engine 0.17.7 → 0.18.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shilongfeicool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @devflow-tools/context-engine
 
-> 组合代码图、知识、记忆和语义路由，构建有预算约束的任务上下文。（v0.17.7）
+> 组合代码图、知识、记忆和语义路由，构建有预算约束的任务上下文。（v0.17.8）
 
 [![npm version](https://img.shields.io/npm/v/%40devflow-tools%2Fcontext-engine.svg)](https://www.npmjs.com/package/@devflow-tools/context-engine)
 
@@ -31,7 +31,7 @@ context-engine 是组合层；SDK 仅提供 embedding contract，具体 embeddin
 
 ## 版本与兼容性
 
-- 当前包版本：`0.17.7`
+- 当前包版本：`0.17.8`
 - Node.js：未在 package manifest 声明更高版本时，使用 Node.js 18+；原生 SQLite/Playwright 能力请按对应依赖安装
 - workspace 内部包应使用同一 DevFlow minor/patch 版本，避免类型和数据库 schema 不一致
 

package/dist/code-evidence-producer.d.ts

@@ -0,0 +1,29 @@
+import type { CodeGraph } from '@colbymchenry/codegraph';
+import { type CodeEvidenceProducerPort, type EvidenceProducerResult, type RetrievalRequestSignatureV1, type SemanticExecutionContext } from '@devflow-tools/sdk';
+import type { IndexerAdapter } from './indexer-adapter.js';
+import type { SymbolVectorStore } from './symbol-vector-store.js';
+import type { EmbeddingProviderContract } from '@devflow-tools/sdk';
+import { type CodeEvidenceSearchInput, type CodeEvidenceSearchOutput } from './code-evidence-types.js';
+export declare class CodeEvidenceRuntime {
+    private readonly dependencies;
+    constructor(dependencies: {
+        codegraph: CodeGraph;
+        indexer: IndexerAdapter;
+        embedder?: EmbeddingProviderContract;
+        symbolStore?: SymbolVectorStore;
+    });
+    search(input: CodeEvidenceSearchInput): Promise<CodeEvidenceSearchOutput>;
+    private addSegmentCandidates;
+    private addVectorCandidates;
+}
+export declare class CodeEvidenceProducer implements CodeEvidenceProducerPort {
+    private readonly runtime;
+    private lastVectorCandidateRefs;
+    constructor(runtime: CodeEvidenceRuntime);
+    getLastVectorCandidateRefs(): Array<{
+        ref: string;
+        rank: number;
+    }>;
+    search(context: SemanticExecutionContext, request: RetrievalRequestSignatureV1): Promise<EvidenceProducerResult>;
+}
+//# sourceMappingURL=code-evidence-producer.d.ts.map

package/dist/code-evidence-producer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-evidence-producer.d.ts","sourceRoot":"","sources":["../src/code-evidence-producer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAsB,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAGL,KAAK,wBAAwB,EAI7B,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC9B,MAAM,0BAA0B,CAAC;AA0ClC,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE;QACzC,SAAS,EAAE,SAAS,CAAC;QACrB,OAAO,EAAE,cAAc,CAAC;QACxB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;QACrC,WAAW,CAAC,EAAE,iBAAiB,CAAC;KACjC;IAEK,MAAM,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAmM/E,OAAO,CAAC,oBAAoB;YA2Dd,mBAAmB;CAwClC;AAED,qBAAa,oBAAqB,YAAW,wBAAwB;IAGvD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,uBAAuB,CAA4C;gBAE9C,OAAO,EAAE,mBAAmB;IAEzD,0BAA0B,IAAI,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAI5D,MAAM,CACV,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,sBAAsB,CAAC;CA+CnC"}

package/dist/code-evidence-producer.js

@@ -0,0 +1,522 @@
+import { codeEvidenceStableRef, stableRuntimeHash, } from '@devflow-tools/sdk';
+import { sanitizeCodeGraphEdges } from './graph-edge-quality.js';
+import { requestValidatedEmbedding } from '@devflow-tools/provider-runtime';
+import { CODE_EVIDENCE_PRODUCER_VERSION, } from './code-evidence-types.js';
+const SEGMENT_CANDIDATE_LIMIT = 20;
+const PROSE_STOPWORDS = new Set([
+    'about', 'above', 'actually', 'after', 'again', 'against', 'almost', 'along', 'also', 'always',
+    'another', 'anything', 'around', 'away', 'back', 'because', 'been', 'before', 'behind', 'being',
+    'below', 'best', 'better', 'between', 'both', 'cannot', 'come', 'could', 'does', 'doing', 'done',
+    'down', 'each', 'either', 'else', 'even', 'ever', 'every', 'everything', 'fine', 'first', 'from',
+    'getting', 'give', 'goes', 'going', 'gone', 'good', 'great', 'have', 'having', 'help', 'here',
+    'inside', 'instead', 'into', 'just', 'keep', 'know', 'last', 'least', 'less', 'like', 'likely',
+    'little', 'look', 'looking', 'made', 'make', 'making', 'many', 'maybe', 'mind', 'more', 'most',
+    'much', 'must', 'need', 'needs', 'never', 'next', 'nice', 'none', 'nothing', 'okay', 'only',
+    'onto', 'other', 'otherwise', 'over', 'please', 'pretty', 'probably', 'quite', 'rather', 'really',
+    'right', 'same', 'seem', 'seems', 'should', 'show', 'since', 'some', 'someone', 'something',
+    'somewhere', 'soon', 'still', 'such', 'sure', 'take', 'than', 'thank', 'thanks', 'that', 'their',
+    'them', 'then', 'there', 'these', 'they', 'thing', 'things', 'think', 'this', 'those', 'though',
+    'tried', 'tries', 'trying', 'under', 'until', 'upon', 'very', 'want', 'wants', 'well', 'went',
+    'were', 'what', 'when', 'which', 'while', 'will', 'wish', 'with', 'within', 'without', 'would',
+    'wrong', 'your', 'yours', 'change', 'changes', 'check', 'class', 'classes', 'code', 'detail',
+    'details', 'directory', 'error', 'errors', 'example', 'examples', 'file', 'files', 'folder',
+    'function', 'functions', 'issue', 'issues', 'line', 'lines', 'method', 'methods', 'name', 'names',
+    'problem', 'problems', 'project', 'question', 'questions', 'rename', 'test', 'tests', 'type',
+    'types', 'update', 'value', 'values', 'warning', 'warnings', 'work', 'working', 'write', 'writing',
+]);
+export class CodeEvidenceRuntime {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async search(input) {
+        const stats = this.dependencies.codegraph.getStats();
+        if (stats.nodeCount === 0 || stats.lastUpdated === 0) {
+            return {
+                candidates: [], rejectedRefs: [], indexReady: false,
+                gaps: [gap('unavailable_channel', 'code_index_not_ready', 'code')],
+                producerLegs: unavailableProducerLegs(input.query.query, 'code_index_not_ready', Boolean(input.profileHash)),
+            };
+        }
+        const query = input.query.query.slice(0, 2_000);
+        const searchLimit = Math.min(30, Math.max(5, input.query.symbols.length * 3));
+        let result;
+        try {
+            result = await this.dependencies.codegraph.findRelevantContext(query, {
+                searchLimit,
+                traversalDepth: Math.max(0, Math.min(3, input.query.maxDepth)),
+                maxNodes: Math.min(60, Math.max(10, Math.floor(input.tokenBudget / 128))),
+            });
+        }
+        catch (error) {
+            const reason = error instanceof Error && error.message.toLowerCase().includes('timeout')
+                ? 'code_search_timeout' : 'code_search_unavailable';
+            return {
+                candidates: [], rejectedRefs: [], indexReady: false,
+                gaps: [gap('unavailable_channel', reason, 'code')],
+                producerLegs: unavailableProducerLegs(query, reason, Boolean(input.profileHash), reason.endsWith('timeout') ? 'timeout' : 'unavailable'),
+            };
+        }
+        const ranked = new Map();
+        for (const [index, rootId] of result.roots.entries()) {
+            const node = result.nodes.get(rootId);
+            if (node)
+                ranked.set(node.id, { node, lexicalRank: index + 1, root: true });
+        }
+        for (const node of result.nodes.values()) {
+            if (!ranked.has(node.id))
+                ranked.set(node.id, { node, root: false });
+        }
+        const segment = this.addSegmentCandidates(ranked, query, Math.max(0, Math.min(3, input.query.maxDepth)));
+        const vector = await this.addVectorCandidates(ranked, query, input.projectId, input.profileHash);
+        const rawEdges = result.edges.map(edge => ({
+            ...edge,
+            kind: typeof edge.kind === 'string'
+                ? edge.kind : 'depends_on',
+        }));
+        const sanitized = sanitizeCodeGraphEdges(this.dependencies.codegraph, rawEdges);
+        const graphRanks = graphEvidenceRanks(result.roots, sanitized.accepted);
+        const rejectedRefs = sanitized.rejected.map(edge => ({
+            ref: `code-relation:${edge.source}:${edge.target}:${edge.kind}`,
+            reason: edge.reason,
+        }));
+        const retrievalProfile = this.dependencies.symbolStore?.getProfile();
+        const gaps = [];
+        const candidates = [];
+        const bodyScores = new Map();
+        for (const item of ranked.values()) {
+            const freshness = this.dependencies.indexer.getFileFreshness(item.node.filePath);
+            const targetMatch = matchesTarget(item.node.filePath, input.query.targetAnchors);
+            const symbolMatch = input.query.symbols.some(symbol => normalizeSymbol(symbol) === normalizeSymbol(item.node.name));
+            const graphRank = graphRanks.get(item.node.id);
+            const boundStructure = graphRank !== undefined && sanitized.accepted.some(edge => edge.source === item.node.id || edge.target === item.node.id);
+            const segmentEvidence = item.segmentRank !== undefined || item.segmentGraphRank !== undefined;
+            const strength = freshness.current && (targetMatch || symbolMatch)
+                ? 'strong' : freshness.current && (boundStructure || segmentEvidence) ? 'supporting' : 'weak';
+            const stableRef = codeStableRef(input.projectId, item.node);
+            const hasEvidenceLeg = item.lexicalRank !== undefined || item.vectorRank !== undefined
+                || segmentEvidence || targetMatch || symbolMatch || boundStructure;
+            if (!hasEvidenceLeg) {
+                rejectedRefs.push({ ref: stableRef, reason: 'unbound_graph_node' });
+                continue;
+            }
+            if (!freshness.current) {
+                rejectedRefs.push({ ref: stableRef, reason: `stale:${freshness.reason ?? 'unknown'}` });
+                gaps.push({
+                    kind: 'runtime_evidence', target: item.node.filePath,
+                    reason: `code_source_stale:${freshness.reason ?? 'unknown'}`,
+                    evidenceRefs: [stableRef], resolver: 'code', priority: 1,
+                });
+                continue;
+            }
+            const excerpt = await this.dependencies.codegraph.getCode(item.node.id);
+            if (!excerpt?.trim()) {
+                rejectedRefs.push({ ref: stableRef, reason: 'source_excerpt_unavailable' });
+                gaps.push({
+                    kind: 'runtime_evidence', target: item.node.filePath,
+                    reason: 'code_source_excerpt_unavailable', evidenceRefs: [stableRef],
+                    resolver: 'code', priority: 1,
+                });
+                continue;
+            }
+            const bodyScore = sourceBodyMatchScore(query, excerpt);
+            if (bodyScore > 0)
+                bodyScores.set(stableRef, bodyScore);
+            const legs = [];
+            if (item.lexicalRank)
+                legs.push({ leg: 'code:bm25', rank: item.lexicalRank });
+            if (item.vectorRank)
+                legs.push({ leg: 'code:vector', rank: item.vectorRank });
+            if (item.segmentRank)
+                legs.push({ leg: 'code:segment', rank: item.segmentRank });
+            if (item.segmentGraphRank) {
+                legs.push({ leg: 'code:segment-graph', rank: item.segmentGraphRank });
+            }
+            if (boundStructure)
+                legs.push({ leg: 'code:graph', rank: graphRank });
+            if (targetMatch)
+                legs.push({ leg: 'code:target', rank: 1 });
+            if (symbolMatch)
+                legs.push({ leg: 'code:symbol', rank: 1 });
+            candidates.push({
+                stableRef, channel: 'code', strength,
+                rank: Math.min(...legs.map(leg => leg.rank), item.lexicalRank ?? 999),
+                ...(retrievalProfile ? {
+                    retrievalProfile: retrievalProfile.profileHash,
+                    generation: retrievalProfile.generation,
+                } : {}),
+                evidence: {
+                    ref: stableRef,
+                    sourceId: `${item.node.filePath}:${item.node.id}`,
+                    producer: 'context-engine', producerVersion: CODE_EVIDENCE_PRODUCER_VERSION,
+                    ...(freshness.currentHash ?? freshness.indexedHash
+                        ? { sourceRevision: freshness.currentHash ?? freshness.indexedHash }
+                        : {}),
+                    ...(freshness.currentHash ?? freshness.indexedHash
+                        ? { contentHash: freshness.currentHash ?? freshness.indexedHash }
+                        : {}),
+                    parentRefs: [
+                        ...(boundStructure ? relationRefs(item.node.id, sanitized.accepted) : []),
+                        ...(item.segmentParentRefs ?? []),
+                    ],
+                },
+                payload: {
+                    path: item.node.filePath, symbolId: item.node.id,
+                    symbol: item.node.name, kind: item.node.kind,
+                    excerpt: excerpt.slice(0, 2_000),
+                    ...(item.node.startLine !== undefined ? { startLine: item.node.startLine } : {}),
+                    ...(item.node.endLine !== undefined ? { endLine: item.node.endLine } : {}),
+                    relationKinds: input.query.relationKinds,
+                },
+                freshness: { current: true, checkedAt: input.now },
+                contributingLegs: legs.length > 0 ? legs : [{ leg: 'code:lexical', rank: item.lexicalRank ?? 999 }],
+                eligibility: {
+                    scope: { kind: 'project', id: input.projectId }, permission: 'allowed', sourceReady: true,
+                    ...(item.vectorRank && input.profileHash ? { profileHash: input.profileHash } : {}),
+                },
+                estimatedTokens: estimateTokens(item.node),
+            });
+        }
+        const bodyRanks = new Map([...bodyScores.entries()]
+            .sort(([leftRef, leftScore], [rightRef, rightScore]) => rightScore - leftScore
+            || leftRef.localeCompare(rightRef))
+            .map(([stableRef], index) => [stableRef, index + 1]));
+        for (const candidate of candidates) {
+            const bodyRank = bodyRanks.get(candidate.stableRef);
+            if (bodyRank === undefined)
+                continue;
+            candidate.contributingLegs = [
+                ...candidate.contributingLegs,
+                { leg: 'code:body', rank: bodyRank },
+            ];
+            candidate.rank = Math.min(candidate.rank, bodyRank);
+        }
+        if (input.query.targetAnchors.length > 0 && !candidates.some(candidate => candidate.strength === 'strong')) {
+            gaps.push({
+                kind: 'target', reason: 'explicit_target_not_resolved_to_current_strong_evidence',
+                target: input.query.targetAnchors.join(','), evidenceRefs: [], resolver: 'code', priority: 1,
+            });
+        }
+        if (input.query.symbols.length > 0 && !candidates.some(candidate => candidate.strength === 'strong')) {
+            gaps.push({
+                kind: 'symbol_ambiguity', reason: 'requested_symbol_not_resolved_to_unique_current_evidence',
+                target: input.query.symbols.join(','), evidenceRefs: [], resolver: 'code', priority: 1,
+            });
+        }
+        const legPrefix = producerLegPrefix(query);
+        return {
+            candidates,
+            rejectedRefs,
+            gaps: dedupeGaps(gaps),
+            indexReady: true,
+            producerLegs: [
+                { schemaVersion: 'evidence-producer-leg-receipt.v1', legId: `${legPrefix}:lexical`, parentReceiptIds: [], kind: 'lexical', required: true, status: result.roots.length > 0 ? 'ready' : 'empty_valid', candidateCount: result.roots.length },
+                { schemaVersion: 'evidence-producer-leg-receipt.v1', legId: `${legPrefix}:segment`, parentReceiptIds: [], kind: 'graph', required: false, status: segment.status, candidateCount: segment.candidateCount, ...(segment.reasonCode ? { reasonCode: segment.reasonCode } : {}) },
+                { schemaVersion: 'evidence-producer-leg-receipt.v1', legId: `${legPrefix}:body`, parentReceiptIds: [], kind: 'lexical', required: false, status: bodyRanks.size > 0 ? 'ready' : 'empty_valid', candidateCount: bodyRanks.size },
+                { schemaVersion: 'evidence-producer-leg-receipt.v1', legId: `${legPrefix}:vector`, parentReceiptIds: [], kind: 'vector', required: Boolean(input.profileHash), ...vector },
+                { schemaVersion: 'evidence-producer-leg-receipt.v1', legId: `${legPrefix}:graph`, parentReceiptIds: [], kind: 'graph', required: false, status: sanitized.accepted.length > 0 ? 'ready' : 'empty_valid', candidateCount: graphRanks.size },
+            ],
+        };
+    }
+    addSegmentCandidates(ranked, query, maxDepth) {
+        try {
+            const words = latinProseWords(query);
+            if (words.length === 0) {
+                return { status: 'empty_valid', candidateCount: 0 };
+            }
+            const matches = this.dependencies.codegraph.getSegmentMatches(words, SEGMENT_CANDIDATE_LIMIT);
+            const additions = new Map();
+            for (const [index, match] of matches.entries()) {
+                const node = resolveExactSegmentNode(this.dependencies.codegraph, match);
+                if (!node)
+                    continue;
+                mergeSegmentNode(additions, node, 'segmentRank', index + 1);
+                if (!isCallerExpandable(node) || maxDepth === 0)
+                    continue;
+                const callers = this.dependencies.codegraph.getCallers(node.id, maxDepth)
+                    .map(item => ({ ...item, current: resolveExactNode(this.dependencies.codegraph, item.node) }));
+                const callerIds = new Set([node.id, ...callers.flatMap(item => item.current ? [item.current.id] : [])]);
+                for (const [callerIndex, caller] of callers.entries()) {
+                    const current = caller.current;
+                    if (!current || caller.edge.kind !== 'calls'
+                        || caller.edge.source !== current.id || !callerIds.has(caller.edge.target))
+                        continue;
+                    const relationRef = `code-relation:${caller.edge.source}:${caller.edge.target}:${caller.edge.kind}`;
+                    mergeSegmentNode(additions, current, 'segmentGraphRank', callerIndex + 1, [relationRef]);
+                }
+            }
+            for (const item of additions.values()) {
+                const existing = ranked.get(item.node.id);
+                ranked.set(item.node.id, {
+                    ...(existing ?? item),
+                    ...(item.segmentRank ? { segmentRank: item.segmentRank } : {}),
+                    ...(item.segmentGraphRank ? { segmentGraphRank: item.segmentGraphRank } : {}),
+                    ...((existing?.segmentParentRefs?.length || item.segmentParentRefs?.length) ? {
+                        segmentParentRefs: [...new Set([
+                                ...(existing?.segmentParentRefs ?? []), ...(item.segmentParentRefs ?? []),
+                            ])],
+                    } : {}),
+                });
+            }
+            return {
+                status: additions.size > 0 ? 'ready' : 'empty_valid',
+                candidateCount: additions.size,
+            };
+        }
+        catch {
+            return {
+                status: 'unavailable', candidateCount: 0,
+                reasonCode: 'segment_query_unavailable',
+            };
+        }
+    }
+    async addVectorCandidates(ranked, query, projectId, expectedProfileHash) {
+        if (!this.dependencies.embedder || !this.dependencies.symbolStore || !expectedProfileHash) {
+            return { status: 'unavailable', candidateCount: 0, reasonCode: 'vector_provider_not_configured', candidateRefs: [] };
+        }
+        const storeProfile = this.dependencies.symbolStore.getProfile?.();
+        if (storeProfile && storeProfile.profileHash !== expectedProfileHash) {
+            return { status: 'invalid', candidateCount: 0, reasonCode: 'vector_profile_mismatch', candidateRefs: [] };
+        }
+        try {
+            const embedding = await requestValidatedEmbedding({
+                provider: this.dependencies.embedder,
+                purpose: 'code_retrieval',
+                text: query,
+            });
+            let vectorRank = 0;
+            const candidateRefs = [];
+            for (const result of this.dependencies.symbolStore.search(embedding, 30)) {
+                vectorRank += 1;
+                const node = this.dependencies.codegraph.getNode(result.id);
+                if (!node)
+                    continue;
+                candidateRefs.push({ ref: codeStableRef(projectId, node), rank: vectorRank });
+                const existing = ranked.get(node.id);
+                ranked.set(node.id, existing ? { ...existing, vectorRank } : { node, vectorRank, root: false });
+            }
+            return { status: vectorRank > 0 ? 'ready' : 'empty_valid', candidateCount: vectorRank, candidateRefs };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message.toLowerCase() : '';
+            return {
+                status: message.includes('timeout') ? 'timeout' : 'unavailable',
+                candidateCount: 0,
+                candidateRefs: [],
+                reasonCode: message.includes('timeout') ? 'vector_query_timeout' : 'vector_query_unavailable',
+            };
+        }
+    }
+}
+export class CodeEvidenceProducer {
+    runtime;
+    lastVectorCandidateRefs = [];
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    getLastVectorCandidateRefs() {
+        return this.lastVectorCandidateRefs.map(item => ({ ...item }));
+    }
+    async search(context, request) {
+        this.lastVectorCandidateRefs = [];
+        if (request.channel !== 'code'
+            || request.factsHash !== context.facts.factsHash
+            || request.planHash !== context.plan.planHash
+            || request.activationSnapshotHash !== context.activationSnapshotHash
+            || stableRuntimeHash(request.identity) !== stableRuntimeHash(context.identity)) {
+            throw new Error('CODE_EVIDENCE_REQUEST_CONTEXT_MISMATCH');
+        }
+        if (context.plan.code.requirement === 'prohibited') {
+            throw new Error('CODE_EVIDENCE_CHANNEL_PROHIBITED');
+        }
+        const query = { ...context.plan.code.typedQuery, query: request.queryVariant.query };
+        const outputs = await Promise.all([this.runtime.search({
+                query,
+                projectId: context.scopeBindings.project.id,
+                contextHash: context.contextHash,
+                profileHash: request.filters.embeddingProfileHash,
+                tokenBudget: 8_000,
+                now: context.createdAt,
+            })]);
+        const candidates = dedupeCandidates(outputs.flatMap(output => output.candidates));
+        this.lastVectorCandidateRefs = outputs.flatMap(output => output.vectorCandidateRefs ?? []);
+        const gaps = dedupeGaps(outputs.flatMap(output => output.gaps));
+        const rejected = outputs.flatMap(output => output.rejectedRefs);
+        const producerLegs = outputs.flatMap(output => output.producerLegs)
+            .map(leg => ({ ...leg, parentReceiptIds: [request.receiptId] }));
+        const requiredLegFailure = producerLegs.find(leg => leg.required
+            && leg.status !== 'ready' && leg.status !== 'empty_valid');
+        const unavailableGaps = requiredLegFailure ? dedupeGaps([...gaps, gap('unavailable_channel', requiredLegFailure.reasonCode ?? `${requiredLegFailure.kind}_unavailable`, 'code')]) : gaps;
+        const availability = outputs.every(output => !output.indexReady) || requiredLegFailure
+            ? 'unavailable' : candidates.length === 0 ? 'empty_valid' : 'available';
+        return receipt(context, request, availability === 'unavailable' ? [] : candidates, rejected, unavailableGaps, availability, producerLegs, outputs.flatMap(output => output.vectorCandidateRefs ?? []));
+    }
+}
+function receipt(context, request, candidates, rejectedRefs, gaps, availability, producerLegs, vectorCandidateRefs) {
+    const contributingLegs = {};
+    for (const candidate of candidates) {
+        for (const leg of candidate.contributingLegs) {
+            (contributingLegs[leg.leg] ??= []).push({
+                ref: candidate.stableRef,
+                rank: leg.rank,
+                ...(leg.score !== undefined ? { score: leg.score } : {}),
+            });
+        }
+    }
+    if (vectorCandidateRefs.length > 0)
+        contributingLegs['code:vector'] = vectorCandidateRefs;
+    const body = {
+        schemaVersion: 'evidence-receipt.v1',
+        receiptId: `code:${stableRuntimeHash({ context: context.contextHash, ...(request.queryVariant ? { queryVariant: request.queryVariant } : {}), refs: candidates.map(item => item.stableRef), gaps }).slice(0, 32)}`,
+        parentReceiptIds: [request.receiptId],
+        taskContextHash: context.contextHash,
+        channel: 'code',
+        availability,
+        factsHash: context.facts.factsHash,
+        planHash: context.plan.planHash,
+        activationSnapshotHash: context.activationSnapshotHash,
+        selectedRefs: [],
+        legId: request.signatureHash,
+        rejectedRefs,
+        gaps,
+        contributingLegs,
+        producerLegs,
+        createdAt: context.createdAt,
+    };
+    return { candidates, gaps, availability, receipt: { ...body, receiptHash: stableRuntimeHash(body) } };
+}
+function producerLegPrefix(query) {
+    return `code:${stableRuntimeHash(query).slice(0, 16)}`;
+}
+function unavailableProducerLegs(query, reasonCode, vectorRequired, status = 'unavailable') {
+    const prefix = producerLegPrefix(query);
+    return ['lexical', 'vector', 'graph'].map(kind => ({
+        schemaVersion: 'evidence-producer-leg-receipt.v1',
+        legId: `${prefix}:${kind}`,
+        parentReceiptIds: [],
+        kind,
+        required: kind === 'lexical' || (kind === 'vector' && vectorRequired),
+        status,
+        candidateCount: 0,
+        reasonCode,
+    }));
+}
+function codeStableRef(projectId, node) {
+    return codeEvidenceStableRef({
+        projectId,
+        normalizedPath: stableEvidencePath(node.filePath),
+        symbolId: node.id,
+        range: [node.startLine ?? 0, node.endLine ?? 0],
+    });
+}
+function stableEvidencePath(value) {
+    return value.normalize('NFKC').replaceAll('\\', '/').replace(/^\.\//u, '');
+}
+function latinProseWords(query) {
+    const unique = new Set();
+    for (const word of query.match(/[\p{L}\p{N}]+/gu) ?? []) {
+        const normalized = word.normalize('NFD').replace(/\p{M}+/gu, '').toLocaleLowerCase('en-US');
+        if (normalized.length < 4 || normalized.length > 24
+            || /^\p{N}+$/u.test(normalized) || PROSE_STOPWORDS.has(normalized))
+            continue;
+        unique.add(normalized);
+        if (unique.size === 16)
+            break;
+    }
+    return [...unique];
+}
+function sourceBodyMatchScore(query, excerpt) {
+    const body = excerpt.normalize('NFKC').toLocaleLowerCase('en-US');
+    return new Set(latinProseWords(query).filter(word => body.includes(word))).size;
+}
+function resolveExactSegmentNode(codegraph, match) {
+    const matches = codegraph.getNodesByName(match.name).filter(node => node.name === match.name
+        && stableEvidencePath(node.filePath) === stableEvidencePath(match.filePath)
+        && node.kind === match.kind
+        && node.startLine === match.startLine);
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function resolveExactNode(codegraph, candidate) {
+    const current = codegraph.getNodesByName(candidate.name).filter(node => node.id === candidate.id
+        && stableEvidencePath(node.filePath) === stableEvidencePath(candidate.filePath)
+        && node.kind === candidate.kind
+        && node.startLine === candidate.startLine);
+    return current.length === 1 ? current[0] : undefined;
+}
+function isCallerExpandable(node) {
+    return node.kind === 'function' || node.kind === 'method';
+}
+function mergeSegmentNode(ranked, node, rankKey, rank, parentRefs = []) {
+    const existing = ranked.get(node.id);
+    ranked.set(node.id, {
+        ...(existing ?? { node, root: false }),
+        [rankKey]: Math.min(existing?.[rankKey] ?? Number.MAX_SAFE_INTEGER, rank),
+        ...(parentRefs.length > 0 ? {
+            segmentParentRefs: [...new Set([...(existing?.segmentParentRefs ?? []), ...parentRefs])],
+        } : {}),
+    });
+}
+function graphEvidenceRanks(roots, edges) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        adjacency.set(edge.source, [...(adjacency.get(edge.source) ?? []), edge.target]);
+        adjacency.set(edge.target, [...(adjacency.get(edge.target) ?? []), edge.source]);
+    }
+    const ranks = new Map();
+    const queue = [];
+    for (const root of roots) {
+        if (ranks.has(root))
+            continue;
+        ranks.set(root, ranks.size + 1);
+        queue.push(root);
+    }
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const next of adjacency.get(current) ?? []) {
+            if (ranks.has(next))
+                continue;
+            ranks.set(next, ranks.size + 1);
+            queue.push(next);
+        }
+    }
+    return ranks;
+}
+function relationRefs(id, edges) {
+    return edges.filter(edge => edge.source === id || edge.target === id)
+        .map(edge => `code-relation:${edge.source}:${edge.target}:${edge.kind}`);
+}
+function matchesTarget(path, targets) {
+    const normalized = normalizePath(path);
+    return targets.some(target => {
+        const anchor = normalizePath(target);
+        return normalized === anchor || normalized.endsWith(`/${anchor}`);
+    });
+}
+function normalizePath(value) {
+    return value.normalize('NFKC').replaceAll('\\', '/').replace(/^\.\//u, '').toLocaleLowerCase('en-US');
+}
+function normalizeSymbol(value) {
+    return value.normalize('NFKC').toLocaleLowerCase('en-US').replace(/[^\p{L}\p{N}_$]+/gu, '');
+}
+function estimateTokens(node) {
+    return Math.max(24, Math.ceil(`${node.name} ${node.signature ?? ''} ${node.filePath}`.length / 4));
+}
+function gap(kind, reason, resolver) {
+    return { kind, reason, evidenceRefs: [], resolver, priority: 1 };
+}
+function dedupeGaps(gaps) {
+    return [...new Map(gaps.map(item => [stableRuntimeHash(item), item])).values()];
+}
+function dedupeCandidates(candidates) {
+    const byRef = new Map();
+    for (const candidate of candidates) {
+        const existing = byRef.get(candidate.stableRef);
+        if (!existing || strengthRank(candidate.strength) > strengthRank(existing.strength))
+            byRef.set(candidate.stableRef, candidate);
+    }
+    return [...byRef.values()];
+}
+function strengthRank(value) {
+    return value === 'strong' ? 3 : value === 'supporting' ? 2 : 1;
+}
+//# sourceMappingURL=code-evidence-producer.js.map