rea-agents 6.5.0 → 6.7.0

package/dist/application/javascript/JavaScriptSemanticGraphBuilder.js

@@ -1,4 +1,4 @@
-import { createJavaScriptSemanticGraph, createJavaScriptSemanticGraphUnknown, sealTransferredJavaScriptSemanticGraphSteps, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { createJavaScriptSemanticGraph, sealTransferredJavaScriptSemanticGraphSteps, } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, JAVASCRIPT_SEMANTIC_RELATIONS, } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
 import { sourceRangesEqual as rangesEqual } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { projectSemanticEvents, projectSemanticTimers, } from "./JavaScriptSemanticGraphAsyncProjection.js";
@@ -7,14 +7,15 @@ import { projectSemanticBoundaries, projectSemanticConfiguration, projectSemanti
 import { projectSemanticResources } from "./JavaScriptSemanticGraphResourceProjection.js";
 import { projectSemanticObjects } from "./JavaScriptSemanticGraphObjectProjection.js";
 import { projectSemanticValues } from "./JavaScriptSemanticGraphValueProjection.js";
-import { inferredSemanticEvidenceAt } from "./JavaScriptSemanticGraphEvidence.js";
-import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { inferredSemanticEvidenceAt, observedSemanticEvidence, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticCoverageResourceLimits, semanticResourceLimitCoverage, } from "../../domain/javascript/javascriptSemanticCoverage.js";
+import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
 import { partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_NODE_MAXIMUM, javaScriptAnalysisCoverageLimits, } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
+import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM, javaScriptAnalysisCoverageLimits, } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
 import { projectSemanticFunctionFingerprints } from "./JavaScriptSemanticGraphFingerprintProjection.js";
 import { projectSemanticClosureCaptures, projectSemanticFrontiers, projectSemanticPromises, projectSemanticReturnValues, } from "./JavaScriptSemanticGraphFlowProjection.js";
 import { createSemanticCallableOwnerLookup, createSemanticCallSiteLookup, createSemanticNodeRangeLookup, semanticFamilyStatus, } from "./JavaScriptSemanticGraphProjection.js";
-import { addSemanticFallbackRoot as addFallbackRoot, retainSemanticGraphNode as retainNode, addSemanticGraphRelation as addRelation, createSemanticGraphProjectionState as emptyState, bindSemanticGraphApplicationNodes, } from "./JavaScriptSemanticGraphConstruction.js";
+import { addSemanticFallbackRoot as addFallbackRoot, addSemanticGraphUnknown, recordSemanticUnknownOmission, retainSemanticGraphNode as retainNode, addSemanticGraphRelation as addRelation, createSemanticGraphProjectionState as emptyState, bindSemanticGraphApplicationNodes, } from "./JavaScriptSemanticGraphConstruction.js";
 import { projectElectronSemanticCallPaths } from "./JavaScriptSemanticGraphElectronProjection.js";
 /**
  * Resource-safety ceiling on retained semantic nodes.
@@ -57,11 +58,20 @@ export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGr
 export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
     const nodeCeiling = limits.totalNodes ?? SEMANTIC_GRAPH_NODE_CEILING;
     const fileNodeCeiling = limits.fileNodes ?? SEMANTIC_GRAPH_FILE_NODE_CEILING;
-    for (const value of [nodeCeiling, fileNodeCeiling])
+    const unknownCeiling = limits.totalUnknowns ??
+        JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticUnknowns;
+    const fileUnknownCeiling = limits.fileUnknowns ??
+        JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticUnknownsPerFile;
+    for (const value of [
+        nodeCeiling,
+        fileNodeCeiling,
+        unknownCeiling,
+        fileUnknownCeiling,
+    ])
         if (!Number.isSafeInteger(value) ||
             value < 1 ||
-            value > JAVASCRIPT_SEMANTIC_NODE_MAXIMUM)
-            throw new RangeError("Semantic graph requires valid node capacities");
+            value > JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM)
+            throw new RangeError("Semantic graph requires valid retained capacities");
     const state = emptyState();
     const fingerprints = [];
     let truncatedFiles = 0;
@@ -76,6 +86,7 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
         const remainingTreeBudget = nodeCeiling - state.nodes.size;
         state.fileNodeBudget = Math.min(fileNodeCeiling, remainingTreeBudget);
         state.fileNodesDropped = false;
+        state.unknownCapacity = Math.min(unknownCeiling, state.unknowns.size + fileUnknownCeiling);
         fingerprints.push(...(yield* projectFileSteps(file, ir, state, paths)));
         // Nodes were dropped only if the budget actually blocked creation. A file
         // that exactly fills its share ends with a zero budget without dropping
@@ -83,6 +94,7 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
         if (state.fileNodesDropped)
             truncatedFiles += 1;
         state.fileNodeBudget = null;
+        state.unknownCapacity = null;
     };
     const finishWith = (factory, rootArtifactSha256, applicationGraph) => {
         bindSemanticGraphApplicationNodes(state, applicationGraph);
@@ -90,6 +102,8 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
             addFallbackRoot(rootArtifactSha256, state);
         const relations = [...state.relations.values()];
         const unknowns = [...state.unknowns.values()];
+        const unknownOmissions = [...state.unknownOmissions.values()];
+        const unknownsDropped = unknownOmissions.length > 0;
         const retainedByFamily = new Map();
         const unknownIdsByFamily = new Map();
         for (const relation of relations) {
@@ -115,12 +129,31 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
             fingerprints: [...fingerprints],
             unknowns,
             coverage: {
-                status: truncatedFiles > 0 || unavailableFiles > 0 ? "partial" : "unknown",
-                truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0,
+                status: truncatedFiles > 0 || unavailableFiles > 0 || unknownsDropped
+                    ? "partial"
+                    : "unknown",
+                truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0 || unknownsDropped,
+                ...(unknownsDropped
+                    ? { omitted_unknown_occurrences: unknownOmissions }
+                    : {}),
                 omitted_nodes: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
                 omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
                 limits: [
                     ...executionLimits.values(),
+                    ...(unknownsDropped
+                        ? [
+                            {
+                                name: "semantic_graph_unknown_ceiling",
+                                value: unknownCeiling,
+                                unit: "items",
+                            },
+                            {
+                                name: "semantic_graph_file_unknown_ceiling",
+                                value: fileUnknownCeiling,
+                                unit: "items",
+                            },
+                        ]
+                        : []),
                     ...(truncatedFiles > 0
                         ? [
                             {
@@ -145,6 +178,11 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
                 })),
             },
             limitations: [
+                ...(unknownsDropped
+                    ? [
+                        "Semantic unknown retention reached an effective capacity. Omission coverage counts examined emission occurrences by family and reason, including repeats; it does not count unexamined source frontiers or distinct discarded identities.",
+                    ]
+                    : []),
                 "The semantic graph contains static syntax observations and conservative relationship candidates; it does not claim runtime execution.",
                 "Local data flow does not claim control-flow-sensitive reaching definitions or arbitrary dynamic property resolution.",
                 "Promise ownership covers explicit unshadowed Promise construction, static factories, aggregation, chaining, and await syntax only.",
@@ -161,33 +199,47 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
         state.nodes.clear();
         state.relations.clear();
         state.unknowns.clear();
+        state.unknownOmissions.clear();
         state.roots.clear();
         state.evidenceContexts.clear();
         fingerprints.length = 0;
         return graph;
     };
     return {
-        remainingFileNodeBudget: () => Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size)),
+        remainingFileCapacity: () => ({
+            nodes: Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size)),
+            unknowns: Math.min(fileUnknownCeiling, Math.max(0, unknownCeiling - state.unknowns.size)),
+        }),
         adoptFileProjection: (projection) => {
             const newNodes = projection.nodes.filter(({ node_id }) => !state.nodes.has(node_id));
             if (newNodes.length >
                 Math.min(fileNodeCeiling, nodeCeiling - state.nodes.size))
                 throw new RangeError("Transferred semantic nodes exceed the offered tree capacity");
+            const newUnknowns = projection.unknowns.filter(({ unknown_id }) => !state.unknowns.has(unknown_id));
+            if (newUnknowns.length >
+                Math.min(fileUnknownCeiling, unknownCeiling - state.unknowns.size))
+                throw new RangeError("Transferred semantic unknowns exceed the offered tree capacity");
+            for (const omission of projection.omittedUnknownOccurrences ?? [])
+                recordSemanticUnknownOmission(state, omission);
             for (const context of projection.evidenceContexts)
                 state.evidenceContexts.adopt(context);
             for (const node of newNodes)
                 state.nodes.set(node.node_id, node);
             for (const relation of projection.relations)
                 state.relations.set(relation.relation_id, relation);
-            for (const unknown of projection.unknowns)
+            for (const unknown of newUnknowns)
                 state.unknowns.set(unknown.unknown_id, unknown);
             for (const root of projection.roots)
                 state.roots.add(root);
             fingerprints.push(...projection.fingerprints);
-            if (projection.truncated)
+            if (projection.nodesTruncated)
                 truncatedFiles += 1;
         },
         recordUnavailableFile: (file, reason, limits, unknownReason) => {
+            // Both full and incremental construction enter here. Metadata/native
+            // processing gaps belong to the application graph, never JavaScript IR.
+            if (file.kind !== "javascript")
+                return;
             const retainedLimits = javaScriptAnalysisCoverageLimits(limits);
             for (const limit of retainedLimits) {
                 executionLimits.set(JSON.stringify([limit.name, limit.value, limit.unit]), limit);
@@ -211,8 +263,9 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
                 coverage: partialApplicationCoverage(retainedLimits, null),
                 limitations: [reason],
             };
+            state.unknownCapacity = Math.min(unknownCeiling, state.unknowns.size + fileUnknownCeiling);
             for (const family of JAVASCRIPT_SEMANTIC_RELATION_FAMILIES) {
-                const unknown = createJavaScriptSemanticGraphUnknown({
+                addSemanticGraphUnknown(state, {
                     node_id: module?.node_id ?? null,
                     family,
                     relation_kinds: JAVASCRIPT_SEMANTIC_RELATIONS.filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation] === family),
@@ -220,9 +273,9 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
                     detail: reason,
                     candidate_node_ids: [],
                     evidence,
-                }, state.evidenceContexts);
-                state.unknowns.set(unknown.unknown_id, unknown);
+                });
             }
+            state.unknownCapacity = null;
             unavailableFiles += 1;
             if (unknownReason === "resource-limit" && retainedLimits.length > 0)
                 resourceTruncatedFiles += 1;
@@ -237,14 +290,15 @@ export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
         finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(sealTransferredJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph),
     };
 };
-/** Project one source with the parent's remaining node capacity, retaining no full IR. */
-export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget, paths = []) {
-    if (!Number.isSafeInteger(nodeBudget) ||
-        nodeBudget < 0 ||
-        nodeBudget > JAVASCRIPT_SEMANTIC_NODE_MAXIMUM)
-        throw new RangeError("File semantic projection requires a valid offered node capacity");
+/** Project one source with the parent's remaining retained capacities, retaining no full IR. */
+export function* projectJavaScriptSemanticFileSteps(file, ir, capacity, paths = []) {
+    if ([capacity.nodes, capacity.unknowns].some((value) => !Number.isSafeInteger(value) ||
+        value < 0 ||
+        value > JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM))
+        throw new RangeError("File semantic projection requires valid offered retained capacities");
     const state = emptyState();
-    state.fileNodeBudget = nodeBudget;
+    state.fileNodeBudget = capacity.nodes;
+    state.unknownCapacity = capacity.unknowns;
     state.fileNodesDropped = false;
     const fingerprints = yield* projectFileSteps(file, ir, state, paths);
     return {
@@ -254,7 +308,10 @@ export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget, paths
         relations: [...state.relations.values()],
         unknowns: [...state.unknowns.values()],
         fingerprints,
-        truncated: Boolean(state.fileNodesDropped),
+        ...(state.unknownOmissions.size > 0
+            ? { omittedUnknownOccurrences: [...state.unknownOmissions.values()] }
+            : {}),
+        nodesTruncated: Boolean(state.fileNodesDropped),
     };
 }
 function* projectFileSteps(file, ir, state, paths = []) {
@@ -269,6 +326,7 @@ function* projectFileSteps(file, ir, state, paths = []) {
     if (moduleNode === null)
         return [];
     state.roots.add(moduleNode.node_id);
+    projectFileResourceLimits({ file, ir, state, moduleNode });
     yield* projectElectronSemanticCallPaths(file, paths, state);
     // Node creation keeps source order, which the per-file node budget relies
     // on; yields between nodes do not change it.
@@ -343,6 +401,27 @@ function* projectFileSteps(file, ir, state, paths = []) {
     yield;
     return projectSemanticFunctionFingerprints(file, ir, callableNodes, state.evidenceContexts);
 }
+const projectFileResourceLimits = (context) => {
+    // Getter limits describe query effects without tagged values; other limits
+    // already project from binding or return-site values and must not be duplicated.
+    for (const limit of semanticCoverageResourceLimits(context.ir.coverage)) {
+        if (limit !== "getter-expansion")
+            continue;
+        addSemanticGraphUnknown(context.state, {
+            node_id: context.moduleNode.node_id,
+            family: "data-flow",
+            relation_kinds: ["defines"],
+            reason: "resource-limit",
+            detail: semanticResourceLimitReason(limit),
+            candidate_node_ids: [],
+            evidence: {
+                ...unknownSemanticEvidence(context.file, null),
+                coverage: partialApplicationCoverage(semanticResourceLimitCoverage([limit]), null),
+                limitations: [semanticResourceLimitReason(limit)],
+            },
+        });
+    }
+};
 function* createReturnSiteNodes(file, ir, callables, state) {
     const result = new Map();
     for (const [index, callable] of ir.callables.entries()) {

package/dist/application/javascript/JavaScriptSemanticGraphChildProcessProjection.js

@@ -1,4 +1,3 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 /** Project child creation, argv/env/stdio, listeners, and signals. */
@@ -73,6 +72,16 @@ const projectSpawn = (context, spawn, child) => {
         relation: "connects-stdio",
         resolution: spawn.stdioMode === "dynamic" ? "candidate" : "resolved",
     });
+    if (spawn.stdioMode === "dynamic")
+        addChildUnknown({
+            context,
+            node: child,
+            location: spawn.location,
+            relationKinds: ["connects-stdio"],
+            reason: "unknown-value",
+            detail: `Static ${spawn.method} stdio options remain unresolved.`,
+            candidateNodeIds: [],
+        });
     if (spawn.resolution !== "complete")
         addChildUnknown({
             context,
@@ -153,13 +162,13 @@ const addSignalNode = (context, interaction) => retainSemanticGraphNode(context.
 });
 const addChildUnknown = (input) => {
     const { context, node, location, relationKinds, detail, candidateNodeIds } = input;
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: node?.node_id ?? null,
         family: "child-process",
         relation_kinds: relationKinds,
-        reason: "ambiguous-target",
+        reason: input.reason ?? "ambiguous-target",
         detail,
         candidate_node_ids: candidateNodeIds,
         evidence: unknownSemanticEvidence(context.file, location),
-    }, context.state.evidenceContexts));
+    });
 };

package/dist/application/javascript/JavaScriptSemanticGraphConstruction.js

@@ -1,11 +1,13 @@
 import { javascriptDisplayText } from "../../domain/javascript/javascriptAstValues.js";
-import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, JavaScriptSemanticEvidenceContextRegistry, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphUnknown, createJavaScriptSemanticGraphRelation, JavaScriptSemanticEvidenceContextRegistry, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { inferredSemanticEvidence, observedSemanticEvidence, unavailableSemanticRootEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
 /** Create empty projection state; application-node links are bound at finish. */
 export const createSemanticGraphProjectionState = () => ({
     nodes: new Map(),
     relations: new Map(),
     unknowns: new Map(),
+    unknownCapacity: null,
+    unknownOmissions: new Map(),
     evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
     roots: new Set(),
 });
@@ -93,8 +95,26 @@ export const addSemanticGraphRelation = (state, input) => {
         return;
     state.relations.set(value.relation_id, value);
 };
-/** Retain one unresolved frontier. */
-export const addSemanticGraphUnknown = (state, unknown) => {
+/** Aggregate examined omissions without retaining unbounded discarded identities. */
+export const recordSemanticUnknownOmission = (state, omission) => {
+    const key = `${omission.family}:${omission.reason}`;
+    const occurrences = (state.unknownOmissions.get(key)?.occurrences ?? 0) + omission.occurrences;
+    if (!Number.isSafeInteger(occurrences))
+        throw new RangeError("Semantic unknown omission count overflow");
+    state.unknownOmissions.set(key, { ...omission, occurrences });
+};
+/** Admit unknown provenance only while its independent retained capacity allows it. */
+export const addSemanticGraphUnknown = (state, input) => {
+    if (state.unknownCapacity !== null &&
+        state.unknowns.size >= state.unknownCapacity) {
+        recordSemanticUnknownOmission(state, {
+            family: input.family,
+            reason: input.reason,
+            occurrences: 1,
+        });
+        return;
+    }
+    const unknown = createJavaScriptSemanticGraphUnknown(input, state.evidenceContexts);
     if (state.unknowns.has(unknown.unknown_id))
         return;
     state.unknowns.set(unknown.unknown_id, unknown);

package/dist/application/javascript/JavaScriptSemanticGraphDataProjection.js

@@ -1,6 +1,6 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
 /** Project environment, argv, file, default, and precedence candidates. */
 export const projectSemanticConfiguration = (context) => {
     const configNodes = new Map(context.ir.configurationOperations.flatMap((operation) => {
@@ -35,7 +35,16 @@ export const projectSemanticConfiguration = (context) => {
                     ...(operation.kind === "default" ? ["overrides"] : []),
                 ],
                 location: operation.location,
-                detail: `Static ${operation.kind} configuration identity is partial.`,
+                ...(operation.valueResourceLimit === undefined
+                    ? {
+                        detail: operation.kind === "default"
+                            ? "Static default configuration value is partial."
+                            : `Static ${operation.kind} configuration identity is partial.`,
+                    }
+                    : {
+                        reason: "resource-limit",
+                        detail: semanticResourceLimitReason(operation.valueResourceLimit),
+                    }),
                 candidateNodeIds: [],
             });
     }
@@ -53,6 +62,9 @@ const addConfigurationNode = (context, operation) => retainSemanticGraphNode(con
         key: operation.key,
         source_kind: operation.kind,
         value: operation.value,
+        ...(operation.valueResourceLimit === undefined
+            ? {}
+            : { value_resource_limit: operation.valueResourceLimit }),
     },
 });
 const configurationRelation = (operation) => operation.kind === "environment"
@@ -195,6 +207,7 @@ const addBoundaryNode = (context, operation) => retainSemanticGraphNode(context.
             null),
     properties: {
         boundary_kind: operation.kind,
+        field: operation.method,
         method: operation.method,
     },
 });
@@ -204,13 +217,13 @@ const bindingOrOwner = (context, bindingId, callableId) => (bindingId === null ?
         : (context.callableNodes.get(callableId) ?? context.moduleNode));
 const addDataUnknown = (input) => {
     const { context, node, family, relationKinds, location, detail, candidateNodeIds, } = input;
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: node.node_id,
         family,
         relation_kinds: relationKinds,
-        reason: "ambiguous-target",
+        reason: input.reason ?? "ambiguous-target",
         detail,
         candidate_node_ids: candidateNodeIds,
         evidence: unknownSemanticEvidence(context.file, location),
-    }, context.state.evidenceContexts));
+    });
 };

package/dist/application/javascript/JavaScriptSemanticGraphFlowProjection.js

@@ -1,4 +1,3 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { sourceRangesEqual } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { inferredSemanticEvidenceAt, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
@@ -108,7 +107,7 @@ const projectPromiseOwnership = (context, operation, promise) => {
 };
 const addPromiseUnknown = (context, operation, promise, promiseNodes) => {
     const relation = operation.kind === "aggregate" ? "aggregates" : "chains";
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: promise.node_id,
         family: "promise-ownership",
         relation_kinds: [relation],
@@ -119,7 +118,7 @@ const addPromiseUnknown = (context, operation, promise, promiseNodes) => {
             return candidate === undefined ? [] : [candidate.node_id];
         }),
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }, context.state.evidenceContexts));
+    });
 };
 /** Link direct return expressions to their retained semantic references. */
 export const projectSemanticReturnValues = (context) => {
@@ -166,7 +165,7 @@ export function* projectSemanticFrontiers(context) {
             : frontier.kind === "dynamic-scope"
                 ? ["reads", "writes"]
                 : ["reads-property", "writes-property"];
-        const unknown = createJavaScriptSemanticGraphUnknown({
+        addSemanticGraphUnknown(context.state, {
             node_id: frontier.callableId === null
                 ? context.moduleNode.node_id
                 : (context.callableNodes.get(frontier.callableId)?.node_id ??
@@ -177,7 +176,6 @@ export function* projectSemanticFrontiers(context) {
             detail: frontier.reason,
             candidate_node_ids: [],
             evidence: unknownSemanticEvidence(context.file, frontier.location),
-        }, context.state.evidenceContexts);
-        addSemanticGraphUnknown(context.state, unknown);
+        });
     }
 }

package/dist/application/javascript/JavaScriptSemanticGraphObjectProjection.js

@@ -1,5 +1,4 @@
 import { semanticSlotAtPath, semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
@@ -100,7 +99,7 @@ const addObjectOccurrence = (context, operation) => retainSemanticGraphNode(cont
 });
 const addObjectUnknown = (context, operation, node, target) => {
     const relation = OBJECT_RELATIONS[operation.kind];
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: node?.node_id ?? null,
         family: "object-flow",
         relation_kinds: [relation],
@@ -108,5 +107,5 @@ const addObjectUnknown = (context, operation, node, target) => {
         detail: `Static ${operation.kind} property ${operation.propertyPath === null ? "path is unresolved" : semanticPropertyPointer(operation.propertyPath)} has ${target.presence} presence; its receiver is ${target.receiverResolved ? "a retained container" : "unresolved or not a retained container"}; object identity is ${operation.resolution}.`,
         candidate_node_ids: [],
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }, context.state.evidenceContexts));
+    });
 };

package/dist/application/javascript/JavaScriptSemanticGraphResourceProjection.js

@@ -1,4 +1,3 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 /** Project built-in resource acquisition and exact local release handles. */
@@ -46,7 +45,7 @@ const projectRelease = (context, operation, resourceNodes) => {
         });
     if (operation.resolution === "complete")
         return;
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: callSite?.node_id ?? null,
         family: "resource-lifecycle",
         relation_kinds: ["releases"],
@@ -54,5 +53,5 @@ const projectRelease = (context, operation, resourceNodes) => {
         detail: `Static ${operation.method} resource ownership is ambiguous.`,
         candidate_node_ids: resources.map(({ node_id: identifier }) => identifier),
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }, context.state.evidenceContexts));
+    });
 };

package/dist/application/javascript/JavaScriptSemanticGraphValueProjection.js

@@ -1,6 +1,5 @@
 import { semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
 import { digestCanonicalValue } from "../../domain/canonicalDigest.js";
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { observedSemanticEvidence, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
 /** Project bounded literal values and object slots for exact query seeds. */
@@ -65,7 +64,7 @@ const projectValue = (input) => {
                 });
         }
         if (container.coverage.status === "partial")
-            addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+            addSemanticGraphUnknown(context.state, {
                 node_id: target.node_id,
                 family: "object-flow",
                 relation_kinds: ["writes-property"],
@@ -73,20 +72,18 @@ const projectValue = (input) => {
                 detail: `Initializer container has unknown ${value.status === "object" ? "properties" : "items"}${container.coverage.omitted === null ? " with an unknown omitted count" : `; ${container.coverage.omitted} omitted`}.`,
                 candidate_node_ids: [target.node_id],
                 evidence: unknownSemanticEvidence(context.file, binding.definitions[0]?.location ?? null),
-            }, context.state.evidenceContexts));
+            });
     }
     else if (value.status === "unknown" ||
         value.status === "ambiguous" ||
         value.status === "cycle") {
         const location = binding.definitions[0]?.location ?? null;
         const evidence = observedSemanticEvidence(context.file, location);
-        addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        addSemanticGraphUnknown(context.state, {
             node_id: target.node_id,
             family: "data-flow",
             relation_kinds: ["defines"],
-            reason: value.resourceLimit === undefined
-                ? "unknown-value"
-                : "resource-limit",
+            reason: value.resourceLimit === undefined ? "unknown-value" : "resource-limit",
             detail: `${value.reason} Unknown value at ${role}.`,
             candidate_node_ids: [target.node_id],
             evidence: {
@@ -96,7 +93,7 @@ const projectValue = (input) => {
                 confidence: "unknown",
                 limitations: [value.reason],
             },
-        }, context.state.evidenceContexts));
+        });
     }
 };
 const addLiteralNode = (context, binding, value, role) => {