ast-mcp-server 0.13.1 → 0.14.0

package/dist/services/relationships.js

@@ -12,6 +12,41 @@ export const RELATIONSHIP_EDGE_KINDS = Object.freeze([
     "call",
     "contains",
 ]);
+export const RELATIONSHIP_COVERAGE_STATUSES = Object.freeze([
+    "not_applicable",
+    "completed",
+    "unsupported",
+    "unfinished",
+]);
+const COVERAGE_STATUS_PRECEDENCE = {
+    not_applicable: 0,
+    completed: 1,
+    unsupported: 2,
+    unfinished: 3,
+};
+function coverageKey(entry) {
+    return `${entry.kind}:${entry.direction}:${entry.endpoint_class}`;
+}
+export function canonicalRelationshipCoverage(coverage) {
+    const kindOrder = new Map(RELATIONSHIP_EDGE_KINDS.map((kind, index) => [kind, index]));
+    return [...coverage].sort((left, right) => kindOrder.get(left.kind) - kindOrder.get(right.kind) ||
+        left.direction.localeCompare(right.direction) ||
+        left.endpoint_class.localeCompare(right.endpoint_class));
+}
+export function mergeRelationshipCoverage(...observations) {
+    const merged = new Map();
+    for (const entry of observations.flat()) {
+        const current = merged.get(coverageKey(entry));
+        if (!current ||
+            COVERAGE_STATUS_PRECEDENCE[entry.status] > COVERAGE_STATUS_PRECEDENCE[current.status]) {
+            merged.set(coverageKey(entry), entry);
+        }
+    }
+    return canonicalRelationshipCoverage([...merged.values()]);
+}
+export function isRelationshipCoverageComplete(coverage) {
+    return coverage.every(({ status }) => status === "completed" || status === "not_applicable");
+}
 export const RELATIONSHIP_PROVENANCES = Object.freeze(["compiler", "syntax", "heuristic"]);
 export const RELATIONSHIP_CONFIDENCES = Object.freeze(["exact", "high", "medium", "low"]);
 export const RELATIONSHIP_RESOLUTIONS = Object.freeze([
@@ -268,6 +303,41 @@ function addModuleEdges(state, requestContext) {
         }
     }
 }
+function symbolSupportsCallDirection(node, direction) {
+    if (!node)
+        return true;
+    if (direction === "incoming") {
+        return (Node.isFunctionDeclaration(node) ||
+            Node.isMethodDeclaration(node) ||
+            Node.isConstructorDeclaration(node) ||
+            Node.isClassDeclaration(node) ||
+            Node.isVariableDeclaration(node));
+    }
+    return (Node.isFunctionDeclaration(node) ||
+        Node.isMethodDeclaration(node) ||
+        Node.isConstructorDeclaration(node) ||
+        Node.isGetAccessorDeclaration(node) ||
+        Node.isSetAccessorDeclaration(node));
+}
+export function relationshipCoverageApplicability(kind, direction, endpointClass, node) {
+    if (kind === "contains")
+        return true;
+    if (endpointClass === "module")
+        return kind === "import" || kind === "export";
+    if (kind === "reference")
+        return true;
+    if (kind === "import" || kind === "export")
+        return direction === "incoming";
+    if (kind === "call")
+        return symbolSupportsCallDirection(node, direction);
+    if (kind === "extends") {
+        return !node || Node.isClassDeclaration(node) || Node.isInterfaceDeclaration(node);
+    }
+    return (kind === "implements" &&
+        (!node ||
+            Node.isClassDeclaration(node) ||
+            (direction === "incoming" && Node.isInterfaceDeclaration(node))));
+}
 const DEFAULT_COMPILER_RELATIONSHIP_WORK_ITEMS = 100_000;
 class ScopedRelationshipLimitReached extends Error {
     constructor() {
@@ -945,6 +1015,221 @@ function addScopedIncomingExports(state, edges, target) {
         });
     }
 }
+function scopedInvocationForReference(reference) {
+    for (const ancestor of reference.getAncestors()) {
+        const expression = callLikeExpression(ancestor);
+        if (!expression)
+            continue;
+        if (reference.getStart() < expression.getStart() || reference.getEnd() > expression.getEnd()) {
+            return undefined;
+        }
+        return { invocation: ancestor, direct: unwrapInvocationExpression(expression) === reference };
+    }
+    return undefined;
+}
+function scopedLocatedCallTarget(state, collector, declaration) {
+    if (Node.isParameterDeclaration(declaration) || Node.isMethodSignature(declaration))
+        return;
+    const sourceFile = declaration.getSourceFile();
+    if (!isProjectScopedFile(state.projectRoot, sourceFile.getFilePath()))
+        return;
+    const targetNode = Node.isConstructorDeclaration(declaration)
+        ? declaration.getFirstAncestorByKind(SyntaxKind.ClassDeclaration)
+        : declaration;
+    if (!targetNode)
+        return;
+    let located;
+    forEachLocatedSymbol(sourceFile, (candidate) => {
+        consumeScopedWork(state, collector);
+        if (candidate.node !== targetNode)
+            return;
+        located = candidate;
+        return false;
+    });
+    return located;
+}
+function computedCallAuthority(projectRoot, invocation) {
+    const expression = callLikeExpression(invocation);
+    if (!expression)
+        return { state: "not_computed", workItems: 0 };
+    const invoked = unwrapInvocationExpression(expression);
+    if (!Node.isElementAccessExpression(invoked))
+        return { state: "not_computed", workItems: 0 };
+    const argument = invoked.getArgumentExpression();
+    const keyTypes = argument
+        ? argument.getType().isUnion()
+            ? argument.getType().getUnionTypes()
+            : [argument.getType()]
+        : [];
+    const keys = keyTypes.flatMap((type) => type.isStringLiteral() && typeof type.getLiteralValue() === "string"
+        ? [type.getLiteralValue()]
+        : []);
+    const receiverType = invoked.getExpression().getType();
+    const receiverTypes = receiverType.isUnion() ? receiverType.getUnionTypes() : [receiverType];
+    const workItems = keyTypes.length + receiverTypes.length;
+    if (keys.length === 1 && keyTypes.length === 1 && receiverTypes.length === 1) {
+        return { state: "single_key_eligible", workItems };
+    }
+    const alternatives = new Map();
+    for (const receiver of receiverTypes) {
+        for (const key of keys) {
+            for (const declaration of declarationsForSymbol(receiver.getProperty(key))) {
+                const target = locatedCallTarget(projectRoot, declaration);
+                if (target)
+                    alternatives.set(symbolEndpoint(target, projectRoot).selector, target);
+            }
+        }
+    }
+    const signature = invocation
+        .getSourceFile()
+        .getProject()
+        .getTypeChecker()
+        .getResolvedSignature(invocation);
+    const selected = signature?.getDeclaration();
+    const selectedTarget = selected ? locatedCallTarget(projectRoot, selected) : undefined;
+    if (selectedTarget) {
+        alternatives.set(symbolEndpoint(selectedTarget, projectRoot).selector, selectedTarget);
+    }
+    return {
+        state: "unfinished",
+        alternatives: [...alternatives.values()].sort((left, right) => symbolEndpoint(left, projectRoot).selector.localeCompare(symbolEndpoint(right, projectRoot).selector)),
+        workItems: workItems + alternatives.size,
+    };
+}
+function scopedComputedCallSites(state, collector) {
+    if (state.computedCallSites) {
+        reserveScopedWork(state, collector, state.computedCallSites.length);
+        return state.computedCallSites;
+    }
+    const sites = [];
+    for (const sourceFile of scopedSourceFiles(state, collector)) {
+        sourceFile.forEachDescendant((node) => {
+            consumeScopedWork(state, collector);
+            const expression = callLikeExpression(node);
+            if (expression && Node.isElementAccessExpression(unwrapInvocationExpression(expression))) {
+                sites.push(node);
+            }
+        });
+    }
+    state.computedCallSites = sites;
+    return sites;
+}
+function scopedDirectCallTarget(state, collector, invocation) {
+    const expression = callLikeExpression(invocation);
+    if (!expression)
+        return;
+    const invoked = unwrapInvocationExpression(expression);
+    if (!Node.isIdentifier(invoked))
+        return;
+    const targets = new Map();
+    for (const declaration of scopedDeclarationsForSymbol(state, collector, invoked.getSymbol())) {
+        const target = scopedLocatedCallTarget(state, collector, declaration);
+        if (target)
+            targets.set(endpointKey(symbolEndpoint(target, state.projectRoot)), target);
+    }
+    return targets.size === 1 ? [...targets.values()][0] : undefined;
+}
+function scopedReferenceFlowsToUncertainCall(state, collector, reference) {
+    const declaration = reference.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+    const initializer = declaration?.getInitializer();
+    const name = declaration?.getNameNode();
+    if (!initializer ||
+        !name ||
+        !Node.isIdentifier(name) ||
+        reference.getStart() < initializer.getStart() ||
+        reference.getEnd() > initializer.getEnd()) {
+        return false;
+    }
+    consumeScopedWork(state, collector);
+    const carrierReferences = name.findReferencesAsNodes();
+    reserveScopedWork(state, collector, carrierReferences.length);
+    return carrierReferences.some((carrierReference) => Boolean(scopedInvocationForReference(carrierReference)));
+}
+function addScopedIncomingCalls(state, collector, target) {
+    if (!Node.isReferenceFindable(target.node))
+        return;
+    for (const invocation of scopedComputedCallSites(state, collector)) {
+        const authority = computedCallAuthority(state.projectRoot, invocation);
+        reserveScopedWork(state, collector, authority.workItems);
+        if (authority.state === "unfinished" &&
+            authority.alternatives.some((alternative) => alternative.node === target.node)) {
+            collector.semanticUnfinished = true;
+        }
+    }
+    consumeScopedWork(state, collector);
+    const references = target.node.findReferencesAsNodes();
+    reserveScopedWork(state, collector, references.length);
+    references.sort((left, right) => left.getSourceFile().getFilePath().localeCompare(right.getSourceFile().getFilePath()) ||
+        left.getStart() - right.getStart());
+    const candidates = createScopedCandidateSet(collector);
+    for (const reference of references) {
+        const site = scopedInvocationForReference(reference);
+        if (!site) {
+            if (scopedReferenceFlowsToUncertainCall(state, collector, reference)) {
+                collector.unfinished = true;
+            }
+            continue;
+        }
+        const authority = computedCallAuthority(state.projectRoot, site.invocation);
+        reserveScopedWork(state, collector, authority.workItems);
+        if (authority.state === "unfinished") {
+            collector.semanticUnfinished = true;
+            continue;
+        }
+        const source = scopedContainingSymbol(state, collector, reference.getSourceFile(), site.invocation);
+        const resolved = site.direct
+            ? scopedDirectCallTarget(state, collector, site.invocation)
+            : undefined;
+        if (!source || !resolved || resolved.node !== target.node) {
+            collector.unfinished = true;
+            continue;
+        }
+        candidates.push(createScopedEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "call"));
+    }
+    addScopedCandidates(collector, candidates);
+}
+function isNestedNamedCallOwner(node) {
+    if (Node.isFunctionDeclaration(node) ||
+        Node.isClassDeclaration(node) ||
+        Node.isMethodDeclaration(node) ||
+        Node.isConstructorDeclaration(node) ||
+        Node.isGetAccessorDeclaration(node) ||
+        Node.isSetAccessorDeclaration(node)) {
+        return true;
+    }
+    if (!Node.isArrowFunction(node) && !Node.isFunctionExpression(node))
+        return false;
+    const parent = node.getParent();
+    return Boolean(parent &&
+        (Node.isVariableDeclaration(parent) ||
+            Node.isPropertyDeclaration(parent) ||
+            Node.isPropertyAssignment(parent)));
+}
+function addScopedOutgoingCalls(state, collector, source) {
+    const candidates = createScopedCandidateSet(collector);
+    source.node.forEachDescendant((node, traversal) => {
+        consumeScopedWork(state, collector);
+        if (isNestedNamedCallOwner(node)) {
+            traversal.skip();
+            return;
+        }
+        if (!callLikeExpression(node))
+            return;
+        const authority = computedCallAuthority(state.projectRoot, node);
+        reserveScopedWork(state, collector, authority.workItems);
+        if (authority.state === "unfinished") {
+            collector.semanticUnfinished = true;
+            return;
+        }
+        const target = scopedDirectCallTarget(state, collector, node);
+        if (!target) {
+            collector.unfinished = true;
+            return;
+        }
+        candidates.push(createScopedEdge(state, symbolEndpoint(source, state.projectRoot), symbolEndpoint(target, state.projectRoot), "call"));
+    });
+    addScopedCandidates(collector, candidates);
+}
 function endpointKey(endpoint) {
     return `${endpoint.file}\u0000${endpoint.symbol_path}\u0000${endpoint.selector}`;
 }
@@ -966,6 +1251,45 @@ function addScopedIncomingModuleEdges(state, edges) {
         addScopedModuleEdges(state, edges, sourceFile);
     }
 }
+function requestedCoverageDirections(direction) {
+    return direction === "both" ? ["incoming", "outgoing"] : [direction];
+}
+function initialRelationshipCoverage(kinds, direction, endpointClass, node) {
+    return canonicalRelationshipCoverage([...kinds].flatMap((kind) => requestedCoverageDirections(direction).map((coverageDirection) => ({
+        kind,
+        direction: coverageDirection,
+        endpoint_class: endpointClass,
+        status: relationshipCoverageApplicability(kind, coverageDirection, endpointClass, node)
+            ? "unsupported"
+            : "not_applicable",
+    }))));
+}
+function relationshipWork(budget, maxWorkItems) {
+    return {
+        work_items: budget.consumed,
+        max_work_items: maxWorkItems,
+        work_limit_reached: budget.limitReached,
+    };
+}
+function hasScopedRelationshipProducer(entry) {
+    if (entry.kind === "contains")
+        return false;
+    if (entry.kind === "call")
+        return entry.endpoint_class === "symbol";
+    if (entry.endpoint_class === "module") {
+        return entry.kind === "import" || entry.kind === "export";
+    }
+    if (entry.kind === "reference")
+        return true;
+    if (entry.kind === "import" || entry.kind === "export")
+        return entry.direction === "incoming";
+    return entry.kind === "extends" || entry.kind === "implements";
+}
+function resolveProducerCoverage(coverage, interrupted) {
+    return coverage.map((entry) => entry.status === "unsupported" && hasScopedRelationshipProducer(entry)
+        ? { ...entry, status: interrupted ? "unfinished" : "completed" }
+        : entry);
+}
 export function createCompilerRelationshipResolver(project, projectRoot, freshness, requestContext = NO_REQUEST_CONTEXT) {
     requestContext.checkpoint();
     const state = {
@@ -987,6 +1311,8 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
             }
             const direction = assertEnum(query.direction, ["incoming", "outgoing", "both"], "direction");
             const relationshipKinds = new Set(query.relationship_kinds.map((kind) => assertEnum(kind, RELATIONSHIP_EDGE_KINDS, "edge kind")));
+            const endpointClass = endpoint.symbol_path === "<module>" ? "module" : "symbol";
+            const initialCoverage = initialRelationshipCoverage(relationshipKinds, direction, endpointClass);
             const workBudget = {
                 remaining: maxWorkItems,
                 consumed: 0,
@@ -1007,6 +1333,8 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                     throw error;
                 return {
                     edges: [],
+                    coverage: resolveProducerCoverage(initialCoverage, true),
+                    work: relationshipWork(workBudget, maxWorkItems),
                     incomplete: true,
                     work_items: workBudget.consumed,
                     work_limit_reached: true,
@@ -1028,6 +1356,7 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                 excludedRelationshipIds,
                 workBudget,
                 excludedNeighbors: false,
+                unfinished: false,
             };
             let located;
             try {
@@ -1038,16 +1367,37 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                     throw error;
                 return {
                     edges: [],
+                    coverage: resolveProducerCoverage(initialCoverage, true),
+                    work: relationshipWork(workBudget, maxWorkItems),
                     incomplete: true,
                     work_items: workBudget.consumed,
                     work_limit_reached: true,
                     excluded_neighbors: false,
                 };
             }
+            const coverage = initialRelationshipCoverage(relationshipKinds, direction, endpointClass, located.symbol?.node);
             const outgoing = direction === "outgoing" || direction === "both";
             const incoming = direction === "incoming" || direction === "both";
             const producers = [];
             if (located.symbol) {
+                if (incoming &&
+                    relationshipKinds.has("call") &&
+                    relationshipCoverageApplicability("call", "incoming", "symbol", located.symbol.node)) {
+                    producers.push({
+                        kinds: ["call"],
+                        callDirection: "incoming",
+                        collect: (collector) => addScopedIncomingCalls(state, collector, located.symbol),
+                    });
+                }
+                if (outgoing &&
+                    relationshipKinds.has("call") &&
+                    relationshipCoverageApplicability("call", "outgoing", "symbol", located.symbol.node)) {
+                    producers.push({
+                        kinds: ["call"],
+                        callDirection: "outgoing",
+                        collect: (collector) => addScopedOutgoingCalls(state, collector, located.symbol),
+                    });
+                }
                 if (outgoing && (relationshipKinds.has("extends") || relationshipKinds.has("implements"))) {
                     producers.push({
                         kinds: ["extends", "implements"],
@@ -1113,7 +1463,9 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                 }
             }
             const merged = new Map();
+            const callCoverage = new Map(producers.flatMap((producer) => producer.callDirection ? [[producer.callDirection, "unfinished"]] : []));
             let incomplete = false;
+            let boundedIncomplete = false;
             let excludedNeighbors = false;
             for (const producer of producers) {
                 const collector = {
@@ -1128,7 +1480,9 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                     excludedRelationshipIds,
                     workBudget,
                     excludedNeighbors: false,
+                    unfinished: false,
                 };
+                let interrupted = false;
                 try {
                     producer.collect(collector);
                 }
@@ -1137,8 +1491,18 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                         !(error instanceof ScopedRelationshipWorkLimitReached)) {
                         throw error;
                     }
+                    interrupted = true;
+                    boundedIncomplete = true;
                     incomplete = true;
                 }
+                if (collector.unfinished)
+                    incomplete = true;
+                if (producer.callDirection &&
+                    !interrupted &&
+                    !collector.unfinished &&
+                    !collector.semanticUnfinished) {
+                    callCoverage.set(producer.callDirection, "completed");
+                }
                 for (const edge of collector.edges.values())
                     merged.set(edge.relationship_id, edge);
                 excludedNeighbors ||= collector.excludedNeighbors;
@@ -1146,11 +1510,18 @@ export function createCompilerRelationshipResolver(project, projectRoot, freshne
                     break;
             }
             const ordered = [...merged.values()].sort((left, right) => scopedNeighborOrder(key, left, right));
-            if (ordered.length > query.max_edges)
+            if (ordered.length > query.max_edges) {
                 incomplete = true;
+                boundedIncomplete = true;
+            }
             const selected = ordered.slice(0, query.max_edges);
+            const resolvedCoverage = resolveProducerCoverage(coverage, boundedIncomplete || workBudget.limitReached).map((entry) => entry.kind === "call" && callCoverage.has(entry.direction)
+                ? { ...entry, status: callCoverage.get(entry.direction) }
+                : entry);
             return {
                 edges: selected.sort((left, right) => left.relationship_id.localeCompare(right.relationship_id)),
+                coverage: resolvedCoverage,
+                work: relationshipWork(workBudget, maxWorkItems),
                 incomplete,
                 work_items: workBudget.consumed,
                 work_limit_reached: workBudget.limitReached,
@@ -1203,6 +1574,7 @@ export function collectCompilerCallRelationships(project, projectRoot, freshness
     const normalizedFreshness = normalizeFreshness(freshness);
     const checker = project.getTypeChecker();
     const edges = new Map();
+    const unfinishedGaps = [];
     let workItems = 0;
     let workLimitReached = false;
     for (const sourceFile of project
@@ -1222,6 +1594,20 @@ export function collectCompilerCallRelationships(project, projectRoot, freshness
             const caller = containingSymbol(sourceFile, node);
             if (!caller)
                 return;
+            const computedAuthority = computedCallAuthority(projectRoot, node);
+            workItems += computedAuthority.workItems;
+            if (workItems > maxWorkItems) {
+                workLimitReached = true;
+                traversal.stop();
+                return;
+            }
+            if (computedAuthority.state === "unfinished") {
+                unfinishedGaps.push({
+                    source: symbolEndpoint(caller, projectRoot),
+                    alternatives: computedAuthority.alternatives.map((target) => symbolEndpoint(target, projectRoot)),
+                });
+                return;
+            }
             const signature = checker.getResolvedSignature(node);
             const implicitConstructSignatures = Node.isNewExpression(node)
                 ? invoked.getType().getConstructSignatures()
@@ -1231,6 +1617,7 @@ export function collectCompilerCallRelationships(project, projectRoot, freshness
             const signatureDeclaration = signature?.getDeclaration();
             const declarations = declarationsForSymbol(invoked.getSymbol());
             const targets = new Map();
+            let unfinished = false;
             for (const declaration of declarations.length > 0
                 ? declarations
                 : signatureDeclaration
@@ -1238,10 +1625,18 @@ export function collectCompilerCallRelationships(project, projectRoot, freshness
                     : []) {
                 const target = locatedCallTarget(projectRoot, declaration);
                 if (target)
-                    targets.set(symbolEndpoint(target, projectRoot).selector, target);
+                    targets.set(endpointKey(symbolEndpoint(target, projectRoot)), target);
+                else
+                    unfinished = true;
             }
-            if (targets.size !== 1)
+            // Dropping an unlocatable alternative does not establish a single exact target.
+            if (unfinished || targets.size !== 1) {
+                unfinishedGaps.push({
+                    source: symbolEndpoint(caller, projectRoot),
+                    alternatives: [...targets.values()].map((target) => symbolEndpoint(target, projectRoot)),
+                });
                 return;
+            }
             const target = [...targets.values()][0];
             const edge = createRelationshipEdge({
                 source: symbolEndpoint(caller, projectRoot),
@@ -1258,9 +1653,13 @@ export function collectCompilerCallRelationships(project, projectRoot, freshness
             break;
     }
     const ordered = [...edges.values()].sort((left, right) => left.relationship_id.localeCompare(right.relationship_id));
+    const boundedIncomplete = workLimitReached || ordered.length > maxEdges;
+    unfinishedGaps.sort((left, right) => endpointKey(left.source).localeCompare(endpointKey(right.source)));
     return Object.freeze({
         edges: Object.freeze(ordered.slice(0, maxEdges)),
-        incomplete: workLimitReached || ordered.length > maxEdges,
+        unfinished_gaps: Object.freeze(unfinishedGaps),
+        bounded_incomplete: boundedIncomplete,
+        incomplete: boundedIncomplete || unfinishedGaps.length > 0,
     });
 }
 export function collectCompilerRelationships(project, projectRoot, freshness, requestContext = NO_REQUEST_CONTEXT) {

package/dist/services/test-candidates.js

@@ -1,4 +1,14 @@
-import { assertExactImpactEvidence } from "./impact.js";
+import { assertCompleteExactImpactEvidence } from "./impact.js";
+import { isRelationshipCoverageComplete, } from "./relationships.js";
+export const AFFECTED_TEST_RELATIONSHIP_KINDS = Object.freeze([
+    "reference",
+    "import",
+    "export",
+    "extends",
+    "implements",
+    "call",
+]);
+const AFFECTED_TEST_RELATIONSHIP_KIND_SET = new Set(AFFECTED_TEST_RELATIONSHIP_KINDS);
 export const DEFAULT_TEST_FILE_PATTERNS = Object.freeze(["**/*.test.*", "**/*.spec.*"]);
 export const DEFAULT_TEST_DIRECTORIES = Object.freeze(["test", "tests", "__tests__"]);
 export const TEST_CANDIDATE_REASONS = Object.freeze([
@@ -156,8 +166,31 @@ function findPathToRoot(startKeys, rootKey, edges) {
     }
     return null;
 }
+function assertCandidateImpactAuthority(impact) {
+    assertCompleteExactImpactEvidence(impact);
+    if (impact.direction !== "incoming" ||
+        impact.relationship_kinds.length !== AFFECTED_TEST_RELATIONSHIP_KINDS.length ||
+        !impact.relationship_kinds.every((kind, index) => kind === AFFECTED_TEST_RELATIONSHIP_KINDS[index])) {
+        throw new Error("Test candidates require the six-kind incoming impact scope.");
+    }
+    const coveredKinds = new Set(impact.coverage?.map((entry) => entry.kind));
+    if (!Array.isArray(impact.coverage) ||
+        coveredKinds.size !== AFFECTED_TEST_RELATIONSHIP_KINDS.length ||
+        !AFFECTED_TEST_RELATIONSHIP_KINDS.every((kind) => coveredKinds.has(kind)) ||
+        !impact.coverage.every((entry) => entry.direction === "incoming" &&
+            AFFECTED_TEST_RELATIONSHIP_KIND_SET.has(entry.kind) &&
+            (entry.status === "completed" || entry.status === "not_applicable")) ||
+        !isRelationshipCoverageComplete(impact.coverage)) {
+        throw new Error("Test candidates require complete six-kind incoming coverage.");
+    }
+    if (impact.work === undefined ||
+        impact.work.work_limit_reached ||
+        impact.work.work_items > impact.work.max_work_items) {
+        throw new Error("Test candidates require bounded impact work.");
+    }
+}
 export function findTestCandidates(impact, conventions = {}) {
-    assertExactImpactEvidence(impact);
+    assertCandidateImpactAuthority(impact);
     if (typeof impact.root !== "object" ||
         impact.root === null ||
         !Array.isArray(impact.nodes) ||

package/dist/tools/find_test_candidates.js

@@ -4,9 +4,10 @@ import { paginate, PaginationInputSchema, PaginationOutputSchema } from "../serv
 import { withProject } from "../services/project.js";
 import { PublicOperationalError } from "../services/public-errors.js";
 import { createRequestContext } from "../services/request-context.js";
-import { findTestCandidates, MAX_TEST_CANDIDATE_CONVENTION_ITEMS, MAX_TEST_CANDIDATE_CONVENTION_LENGTH, TEST_CANDIDATE_CONFIDENCES, TEST_CANDIDATE_REASONS, } from "../services/test-candidates.js";
-import { FreshnessSchema, RelationshipEdgeSchema, RelationshipEndpointSchema, } from "./relationship-schema.js";
+import { AFFECTED_TEST_RELATIONSHIP_KINDS, findTestCandidates, MAX_TEST_CANDIDATE_CONVENTION_ITEMS, MAX_TEST_CANDIDATE_CONVENTION_LENGTH, TEST_CANDIDATE_CONFIDENCES, TEST_CANDIDATE_REASONS, } from "../services/test-candidates.js";
+import { FreshnessSchema, RelationshipCoverageEntrySchema, RelationshipEdgeSchema, RelationshipEndpointSchema, RelationshipWorkSchema, } from "./relationship-schema.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
+export { AFFECTED_TEST_RELATIONSHIP_KINDS } from "../services/test-candidates.js";
 const TOOL_NAME = "ast_find_test_candidates";
 const ConventionSchema = z
     .array(z.string().min(1).max(MAX_TEST_CANDIDATE_CONVENTION_LENGTH))
@@ -40,6 +41,16 @@ const FindTestCandidatesOutputSchema = z.object({
     compiler_authoritative: z.literal(true),
     root: RelationshipEndpointSchema,
     direction: z.literal("incoming"),
+    relationship_kinds: z.tuple([
+        z.literal("reference"),
+        z.literal("import"),
+        z.literal("export"),
+        z.literal("extends"),
+        z.literal("implements"),
+        z.literal("call"),
+    ]),
+    coverage: z.array(RelationshipCoverageEntrySchema),
+    work: RelationshipWorkSchema,
     candidates: z.array(TestCandidateSchema),
     ...PaginationOutputSchema,
     visited_nodes: z.number().int().min(0),
@@ -84,7 +95,14 @@ export function registerFindTestCandidates(server) {
                     checked_at: context.status.lastSuccessfulSyncAt,
                 };
                 const root = resolveImpactRoot(context.project, context.projectRoot, { file_path, symbol_path }, operationContext);
-                const impact = traverseCompilerImpact(context.project, context.projectRoot, root, freshness, { direction: "incoming", max_depth, max_nodes, max_edges }, operationContext);
+                const impact = traverseCompilerImpact(context.project, context.projectRoot, root, freshness, {
+                    direction: "incoming",
+                    relationship_kinds: AFFECTED_TEST_RELATIONSHIP_KINDS,
+                    max_depth,
+                    max_nodes,
+                    max_edges,
+                    authority: "semantic",
+                }, operationContext);
                 if (impact.incomplete || impact.truncation.truncated) {
                     throw new PublicOperationalError("INCOMPLETE_EVIDENCE", "Evidence is incomplete.");
                 }
@@ -98,6 +116,9 @@ export function registerFindTestCandidates(server) {
                     compiler_authoritative: true,
                     root: impact.root,
                     direction: "incoming",
+                    relationship_kinds: AFFECTED_TEST_RELATIONSHIP_KINDS,
+                    coverage: impact.coverage,
+                    work: impact.work,
                     candidates: page.items,
                     offset: page.offset,
                     limit: page.limit,

package/dist/tools/get_impact.js

@@ -4,7 +4,7 @@ import { TRUNCATION_REASONS } from "../services/read-contracts.js";
 import { withProject } from "../services/project.js";
 import { createRequestContext } from "../services/request-context.js";
 import { RELATIONSHIP_EDGE_KINDS } from "../services/relationships.js";
-import { FreshnessSchema, RelationshipEdgeSchema, RelationshipEndpointSchema, } from "./relationship-schema.js";
+import { FreshnessSchema, RelationshipCoverageEntrySchema, RelationshipEdgeSchema, RelationshipEndpointSchema, RelationshipWorkSchema, } from "./relationship-schema.js";
 import { createToolErrorContext, errorResult, formattedResult, ToolOutputFormatInputSchema, } from "./result.js";
 const TOOL_NAME = "ast_get_impact";
 const AstGetImpactInputSchema = z.object({
@@ -60,6 +60,9 @@ const ImpactOutputSchema = z.object({
     max_depth: z.number().int().min(0),
     max_nodes: z.number().int().positive(),
     max_edges: z.number().int().positive(),
+    coverage: z.array(RelationshipCoverageEntrySchema),
+    work: RelationshipWorkSchema,
+    proven_empty: z.boolean(),
     incomplete: z.boolean(),
     truncation: z.object({
         truncated: z.boolean(),
@@ -92,7 +95,14 @@ export function registerGetImpact(server) {
                     checked_at: context.status.lastSuccessfulSyncAt,
                 };
                 const root = resolveImpactRoot(context.project, context.projectRoot, { file_path, symbol_path }, operationContext);
-                const impact = traverseCompilerImpact(context.project, context.projectRoot, root, freshness, { direction, max_depth, max_nodes, max_edges, relationship_kinds }, operationContext);
+                const impact = traverseCompilerImpact(context.project, context.projectRoot, root, freshness, {
+                    direction,
+                    max_depth,
+                    max_nodes,
+                    max_edges,
+                    relationship_kinds,
+                    authority: "semantic",
+                }, operationContext);
                 return {
                     ...impact,
                     freshness,