ast-mcp-server 0.13.0 → 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/runtime-policy.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import packageMetadata from "../../package.json" with { type: "json" };
 export const RUNTIME_POLICY_ENV_KEYS = Object.freeze([
     "AST_MAX_PROJECT_SESSIONS",
     "AST_MAX_QUEUED_OPERATIONS_PER_PROJECT",
@@ -8,6 +9,7 @@ export const RUNTIME_POLICY_ENV_KEYS = Object.freeze([
     "AST_COMPILER_WORKER_MODE",
     "AST_COMPILER_WORKER_IDLE_TTL_MS",
     "AST_MCP_APPLY_GUARD",
+    "AST_MCP_TEXT_PROJECTION",
 ]);
 function parseBoundedInteger(rawValue, defaultValue, minimum, maximum) {
     if (rawValue === undefined)
@@ -27,8 +29,8 @@ function parseBoundedInteger(rawValue, defaultValue, minimum, maximum) {
 export function parseRuntimePolicy(environment) {
     const maxProjectSessions = parseBoundedInteger(environment.AST_MAX_PROJECT_SESSIONS, 8, 1, 32);
     const maxQueuedOperationsPerProject = parseBoundedInteger(environment.AST_MAX_QUEUED_OPERATIONS_PER_PROJECT, 32, 1, 256);
-    const queueWaitTimeoutMs = parseBoundedInteger(environment.AST_QUEUE_WAIT_TIMEOUT_MS, 30_000, 100, 300_000);
-    const operationDeadlineMs = parseBoundedInteger(environment.AST_OPERATION_DEADLINE_MS, 120_000, 1_000, 900_000);
+    const queueWaitTimeoutMs = parseBoundedInteger(environment.AST_QUEUE_WAIT_TIMEOUT_MS, packageMetadata.deepseekHarness.timeoutBudget.queueWaitMs, 100, 300_000);
+    const operationDeadlineMs = parseBoundedInteger(environment.AST_OPERATION_DEADLINE_MS, packageMetadata.deepseekHarness.timeoutBudget.executionDeadlineMs, 1_000, 900_000);
     const shutdownDrainTimeoutMs = parseBoundedInteger(environment.AST_SHUTDOWN_DRAIN_TIMEOUT_MS, 10_000, 100, 60_000);
     const rawWorkerMode = environment.AST_COMPILER_WORKER_MODE;
     const compilerWorkerMode = rawWorkerMode === "supervised" ? "supervised" : "in_process";
@@ -47,6 +49,13 @@ export function parseRuntimePolicy(environment) {
         : rawApplyGuard === "allow" || rawApplyGuard === "deny"
             ? "configured"
             : "invalid_mode";
+    const rawTextProjection = environment.AST_MCP_TEXT_PROJECTION;
+    const projectStructuredContentAsText = rawTextProjection === "canonical_json";
+    const textProjectionReason = rawTextProjection === undefined
+        ? "default"
+        : projectStructuredContentAsText
+            ? "configured"
+            : "invalid_mode";
     const reasons = Object.freeze({
         AST_MAX_PROJECT_SESSIONS: maxProjectSessions.reason,
         AST_MAX_QUEUED_OPERATIONS_PER_PROJECT: maxQueuedOperationsPerProject.reason,
@@ -56,6 +65,7 @@ export function parseRuntimePolicy(environment) {
         AST_COMPILER_WORKER_MODE: compilerWorkerModeReason,
         AST_COMPILER_WORKER_IDLE_TTL_MS: compilerWorkerIdleTtlMs.reason,
         AST_MCP_APPLY_GUARD: applyGuardReason,
+        AST_MCP_TEXT_PROJECTION: textProjectionReason,
     });
     return Object.freeze({
         maxProjectSessions: maxProjectSessions.value,
@@ -66,6 +76,7 @@ export function parseRuntimePolicy(environment) {
         compilerWorkerMode,
         compilerWorkerIdleTtlMs: compilerWorkerIdleTtlMs.value,
         denyApply,
+        projectStructuredContentAsText,
         reasons,
     });
 }
@@ -76,6 +87,46 @@ const WORKER_ENV_KEYS = [
     "AST_SYMBOL_INDEX_BUSY_TIMEOUT_MS",
 ];
 const MAX_WORKER_ENV_VALUE_LENGTH = 4096;
+function parseClosedFixtureRecord(raw, expectedKeys) {
+    if (typeof raw !== "string" || raw.length > 1024 || raw.includes("\0"))
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        const record = value;
+        return Object.keys(record).sort().join(",") === expectedKeys ? record : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseH03FixtureDescriptor(raw) {
+    const record = parseClosedFixtureRecord(raw, "controlDirectory,generation,nonce");
+    if (!record)
+        return undefined;
+    const { controlDirectory, nonce, generation } = record;
+    if (typeof controlDirectory !== "string" ||
+        controlDirectory.length > MAX_WORKER_ENV_VALUE_LENGTH ||
+        !path.isAbsolute(controlDirectory) ||
+        path.normalize(controlDirectory) !== controlDirectory ||
+        typeof nonce !== "string" ||
+        !/^[A-Za-z0-9_-]{16,64}$/.test(nonce) ||
+        !Number.isSafeInteger(generation) ||
+        generation < 1)
+        return undefined;
+    return Object.freeze({ controlDirectory, nonce, generation: generation });
+}
+export function parseH05FixtureDescriptor(raw) {
+    const record = parseClosedFixtureRecord(raw, "controlDirectory,generation,nonce,ownerToken");
+    if (!record)
+        return undefined;
+    const { ownerToken, ...baseValue } = record;
+    if (typeof ownerToken !== "string" || !/^[A-Za-z0-9_-]{16,64}$/.test(ownerToken))
+        return undefined;
+    const base = parseH03FixtureDescriptor(JSON.stringify(baseValue));
+    return base ? Object.freeze({ ...base, ownerToken }) : undefined;
+}
 function validEnvironmentString(value) {
     return (typeof value === "string" &&
         value.length <= MAX_WORKER_ENV_VALUE_LENGTH &&
@@ -100,6 +151,20 @@ export function createCompilerWorkerSpawnSpec(workerEntryPath, environment) {
         }
         projected[key] = value;
     }
+    const fixture = environment.AST_H03_FIXTURE;
+    if (fixture !== undefined) {
+        const descriptor = parseH03FixtureDescriptor(fixture);
+        if (!descriptor)
+            return { ok: false, reason: "invalid_environment" };
+        projected.AST_H03_FIXTURE = JSON.stringify(descriptor);
+    }
+    const lifecycleFixture = environment.AST_H05_FIXTURE;
+    if (lifecycleFixture !== undefined) {
+        const descriptor = parseH05FixtureDescriptor(lifecycleFixture);
+        if (!descriptor)
+            return { ok: false, reason: "invalid_environment" };
+        projected.AST_H05_FIXTURE = JSON.stringify(descriptor);
+    }
     const policy = parseRuntimePolicy(environment);
     Object.assign(projected, {
         AST_MAX_PROJECT_SESSIONS: String(policy.maxProjectSessions),
@@ -110,6 +175,7 @@ export function createCompilerWorkerSpawnSpec(workerEntryPath, environment) {
         // Forward the parent's resolved apply-guard policy so the supervised worker
         // registers the same tool surface (deny-by-default fail-closed, allow opt-in).
         AST_MCP_APPLY_GUARD: policy.denyApply ? "deny" : "allow",
+        ...(policy.projectStructuredContentAsText ? { AST_MCP_TEXT_PROJECTION: "canonical_json" } : {}),
     });
     return {
         ok: true,