rea-agents 6.3.0 → 6.4.0

package/dist/application/javascript/JavaScriptSemanticGraphBuilder.js

@@ -1,5 +1,5 @@
-import { createJavaScriptSemanticGraph, createImmutableJavaScriptSemanticGraphSteps, } from "../../domain/javascript/javascriptSemanticGraph.js";
-import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
+import { createJavaScriptSemanticGraph, createJavaScriptSemanticGraphUnknown, 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";
 import { projectSemanticChildProcesses } from "./JavaScriptSemanticGraphChildProcessProjection.js";
@@ -8,6 +8,9 @@ import { projectSemanticResources } from "./JavaScriptSemanticGraphResourceProje
 import { projectSemanticObjects } from "./JavaScriptSemanticGraphObjectProjection.js";
 import { projectSemanticValues } from "./JavaScriptSemanticGraphValueProjection.js";
 import { inferredSemanticEvidenceAt } from "./JavaScriptSemanticGraphEvidence.js";
+import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
+import { 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";
@@ -49,10 +52,13 @@ export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGr
 };
 /** Accumulate semantic nodes while each source IR is still file-local. */
 export const createJavaScriptSemanticGraphProjection = () => {
-    const state = emptyState({ nodes: [] });
+    const state = emptyState();
     const fingerprints = [];
     let truncatedFiles = 0;
-    const projectSource = (file, ir) => {
+    let unavailableFiles = 0;
+    let resourceTruncatedFiles = 0;
+    const executionLimits = new Map();
+    const projectSourceSteps = function* (file, ir) {
         if (state.nodes.size >= SEMANTIC_GRAPH_NODE_CEILING) {
             truncatedFiles += 1;
             return;
@@ -60,7 +66,7 @@ export const createJavaScriptSemanticGraphProjection = () => {
         const remainingTreeBudget = SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size;
         state.fileNodeBudget = Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, remainingTreeBudget);
         state.fileNodesDropped = false;
-        fingerprints.push(...projectFile(file, ir, state));
+        fingerprints.push(...(yield* projectFileSteps(file, ir, state)));
         // Nodes were dropped only if the budget actually blocked creation. A file
         // that exactly fills its share ends with a zero budget without dropping
         // anything, so the remaining budget alone cannot decide truncation.
@@ -72,7 +78,21 @@ export const createJavaScriptSemanticGraphProjection = () => {
         bindSemanticGraphApplicationNodes(state, applicationGraph);
         if (state.roots.size === 0)
             addFallbackRoot(rootArtifactSha256, state);
+        const relations = [...state.relations.values()];
         const unknowns = [...state.unknowns.values()];
+        const retainedByFamily = new Map();
+        const unknownIdsByFamily = new Map();
+        for (const relation of relations) {
+            const family = JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation.relation];
+            retainedByFamily.set(family, (retainedByFamily.get(family) ?? 0) + 1);
+        }
+        for (const unknown of unknowns) {
+            const identifiers = unknownIdsByFamily.get(unknown.family);
+            if (identifiers === undefined)
+                unknownIdsByFamily.set(unknown.family, [unknown.unknown_id]);
+            else
+                identifiers.push(unknown.unknown_id);
+        }
         const graph = factory({
             schema: "JavaScriptSemanticRelationGraph",
             root_artifact_sha256: rootArtifactSha256,
@@ -80,32 +100,33 @@ export const createJavaScriptSemanticGraphProjection = () => {
             root_node_ids: [...state.roots],
             evidence_contexts: state.evidenceContexts.contexts,
             nodes: [...state.nodes.values()],
-            relations: [...state.relations.values()],
-            fingerprints,
+            relations,
+            // The input is transferred to the factory; `fingerprints` is cleared below.
+            fingerprints: [...fingerprints],
             unknowns,
             coverage: {
-                status: truncatedFiles > 0 ? "partial" : "unknown",
-                truncated: truncatedFiles > 0,
-                omitted_nodes: truncatedFiles > 0 ? null : 0,
-                omitted_relations: truncatedFiles > 0 ? null : 0,
-                limits: truncatedFiles > 0
-                    ? [
-                        {
-                            name: "semantic_graph_node_ceiling",
-                            value: SEMANTIC_GRAPH_NODE_CEILING,
-                            unit: "items",
-                        },
-                    ]
-                    : [],
+                status: truncatedFiles > 0 || unavailableFiles > 0 ? "partial" : "unknown",
+                truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0,
+                omitted_nodes: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                limits: [
+                    ...executionLimits.values(),
+                    ...(truncatedFiles > 0
+                        ? [
+                            {
+                                name: "semantic_graph_node_ceiling",
+                                value: SEMANTIC_GRAPH_NODE_CEILING,
+                                unit: "items",
+                            },
+                        ]
+                        : []),
+                ],
                 families: JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => ({
                     family,
                     status: semanticFamilyStatus(family),
-                    retained_relations: [...state.relations.values()].filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation.relation] ===
-                        family).length,
-                    omitted_relations: truncatedFiles > 0 ? null : 0,
-                    unknown_ids: unknowns
-                        .filter((unknown) => unknown.family === family)
-                        .map(({ unknown_id: identifier }) => identifier),
+                    retained_relations: retainedByFamily.get(family) ?? 0,
+                    omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                    unknown_ids: unknownIdsByFamily.get(family) ?? [],
                 })),
             },
             limitations: [
@@ -131,12 +152,98 @@ export const createJavaScriptSemanticGraphProjection = () => {
         return graph;
     };
     return {
-        projectFile: projectSource,
+        remainingFileNodeBudget: () => Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, Math.max(0, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size)),
+        adoptFileProjection: (projection) => {
+            const newNodes = projection.nodes.filter(({ node_id }) => !state.nodes.has(node_id));
+            if (newNodes.length >
+                Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size))
+                throw new RangeError("Transferred semantic nodes exceed the offered tree capacity");
+            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)
+                state.unknowns.set(unknown.unknown_id, unknown);
+            for (const root of projection.roots)
+                state.roots.add(root);
+            fingerprints.push(...projection.fingerprints);
+            if (projection.truncated)
+                truncatedFiles += 1;
+        },
+        recordUnavailableFile: (file, reason, limits, unknownReason) => {
+            const retainedLimits = javaScriptAnalysisCoverageLimits(limits);
+            for (const limit of retainedLimits) {
+                executionLimits.set(JSON.stringify([limit.name, limit.value, limit.unit]), limit);
+            }
+            state.fileNodeBudget = Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, Math.max(0, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size));
+            const module = retainNode(state, file, {
+                kind: "module",
+                roleKey: "module",
+                location: null,
+                label: file.path,
+                functionNodeId: null,
+            });
+            state.fileNodeBudget = null;
+            if (module !== null)
+                state.roots.add(module.node_id);
+            const evidence = {
+                ...observedSemanticEvidence(file, null),
+                authority: "unknown",
+                state: "unknown",
+                confidence: "unknown",
+                coverage: partialApplicationCoverage(retainedLimits, null),
+                limitations: [reason],
+            };
+            for (const family of JAVASCRIPT_SEMANTIC_RELATION_FAMILIES) {
+                const unknown = createJavaScriptSemanticGraphUnknown({
+                    node_id: module?.node_id ?? null,
+                    family,
+                    relation_kinds: JAVASCRIPT_SEMANTIC_RELATIONS.filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation] === family),
+                    reason: unknownReason,
+                    detail: reason,
+                    candidate_node_ids: [],
+                    evidence,
+                }, state.evidenceContexts);
+                state.unknowns.set(unknown.unknown_id, unknown);
+            }
+            unavailableFiles += 1;
+            if (unknownReason === "resource-limit" && retainedLimits.length > 0)
+                resourceTruncatedFiles += 1;
+        },
+        projectFile: (file, ir) => {
+            const steps = projectSourceSteps(file, ir);
+            while (steps.next().done !== true)
+                ;
+        },
+        projectFileSteps: projectSourceSteps,
         finish: (rootArtifactSha256, applicationGraph) => finishWith(createJavaScriptSemanticGraph, rootArtifactSha256, applicationGraph),
-        finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(createImmutableJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph),
+        finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(sealTransferredJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph),
     };
 };
-const projectFile = (file, ir, state) => {
+/** Project one source with the parent's remaining node capacity, retaining no full IR. */
+export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget) {
+    if (!Number.isSafeInteger(nodeBudget) ||
+        nodeBudget < 0 ||
+        nodeBudget > SEMANTIC_GRAPH_FILE_NODE_CEILING)
+        throw new RangeError("File semantic projection requires a valid offered node capacity");
+    const state = emptyState();
+    state.fileNodeBudget = nodeBudget;
+    state.fileNodesDropped = false;
+    const fingerprints = yield* projectFileSteps(file, ir, state);
+    return {
+        roots: [...state.roots],
+        evidenceContexts: state.evidenceContexts.contexts,
+        nodes: [...state.nodes.values()],
+        relations: [...state.relations.values()],
+        unknowns: [...state.unknowns.values()],
+        fingerprints,
+        truncated: Boolean(state.fileNodesDropped),
+    };
+}
+function* projectFileSteps(file, ir, state) {
+    yield;
     const moduleNode = retainNode(state, file, {
         kind: "module",
         roleKey: "module",
@@ -147,7 +254,12 @@ const projectFile = (file, ir, state) => {
     if (moduleNode === null)
         return [];
     state.roots.add(moduleNode.node_id);
-    const callableNodes = new Map(ir.callables.flatMap((callable) => {
+    // Node creation keeps source order, which the per-file node budget relies
+    // on; yields between nodes do not change it.
+    const callableNodes = new Map();
+    for (const [index, callable] of ir.callables.entries()) {
+        if (index % 64 === 0)
+            yield;
         const node = retainNode(state, file, {
             kind: "function",
             roleKey: `callable:${callable.callableId}`,
@@ -157,10 +269,14 @@ const projectFile = (file, ir, state) => {
             // The label is display text; keep the exact name, which may be "".
             properties: { name: callable.name },
         });
-        return node === null ? [] : [[callable.callableId, node]];
-    }));
+        if (node !== null)
+            callableNodes.set(callable.callableId, node);
+    }
     const callableOwnerAt = createSemanticCallableOwnerLookup(ir, callableNodes);
-    const bindingNodes = new Map(ir.bindings.flatMap((binding) => {
+    const bindingNodes = new Map();
+    for (const [index, binding] of ir.bindings.entries()) {
+        if (index % 64 === 0)
+            yield;
         const location = binding.definitions[0]?.location ?? null;
         const kind = binding.kind === "parameter" ? "parameter" : "binding";
         const owner = callableOwnerAt(location);
@@ -171,10 +287,11 @@ const projectFile = (file, ir, state) => {
             label: binding.name,
             functionNodeId: owner?.node_id ?? null,
         });
-        return node === null ? [] : [[binding.bindingId, node]];
-    }));
-    const returnSiteNodes = createReturnSiteNodes(file, ir, callableNodes, state);
-    const callSiteNodes = createCallSiteNodes(file, ir, callableNodes, state);
+        if (node !== null)
+            bindingNodes.set(binding.bindingId, node);
+    }
+    const returnSiteNodes = yield* createReturnSiteNodes(file, ir, callableNodes, state);
+    const callSiteNodes = yield* createCallSiteNodes(file, ir, callableNodes, state);
     const definitions = {
         file,
         ir,
@@ -193,29 +310,28 @@ const projectFile = (file, ir, state) => {
         callableOwnerAt,
         callSiteAt: createSemanticCallSiteLookup(ir, callSiteNodes),
     };
-    projectDefinitionsAndReferences(definitions);
+    yield* projectDefinitionsAndReferences(definitions);
     const context = {
         ...definitions,
         referenceNodesWithin: createSemanticNodeRangeLookup(definitions.referenceNodes),
     };
-    projectSemanticValues(context);
-    projectSemanticObjects(context);
-    projectCalls(context);
-    projectSemanticPromises(context);
-    projectSemanticEvents(context);
-    projectSemanticTimers(context);
-    projectSemanticChildProcesses(context);
-    projectSemanticConfiguration(context);
-    projectSemanticRequests(context);
-    projectSemanticBoundaries(context);
-    projectSemanticResources(context);
-    projectSemanticClosureCaptures(context);
-    projectSemanticFrontiers(context);
+    // Each pass completes before the next starts, so yielding between passes
+    // keeps projection order and results unchanged.
+    for (const project of FILE_PROJECTION_PASSES) {
+        yield;
+        const steps = project(context);
+        if (steps !== undefined)
+            while (steps.next().done !== true)
+                yield;
+    }
+    yield;
     return projectSemanticFunctionFingerprints(file, ir, callableNodes, state.evidenceContexts);
-};
-const createReturnSiteNodes = (file, ir, callables, state) => {
+}
+function* createReturnSiteNodes(file, ir, callables, state) {
     const result = new Map();
-    for (const callable of ir.callables) {
+    for (const [index, callable] of ir.callables.entries()) {
+        if (index % 64 === 0)
+            yield;
         const owner = callables.get(callable.callableId);
         if (owner === undefined)
             continue;
@@ -233,10 +349,12 @@ const createReturnSiteNodes = (file, ir, callables, state) => {
         }
     }
     return result;
-};
-const createCallSiteNodes = (file, ir, callables, state) => {
+}
+function* createCallSiteNodes(file, ir, callables, state) {
     const result = new Map();
-    for (const call of ir.callSites) {
+    for (const [index, call] of ir.callSites.entries()) {
+        if (index % 64 === 0)
+            yield;
         const owner = call.callerCallableId === null
             ? null
             : (callables.get(call.callerCallableId)?.node_id ?? null);
@@ -251,9 +369,11 @@ const createCallSiteNodes = (file, ir, callables, state) => {
             result.set(call.callSiteId, node);
     }
     return result;
-};
-const projectDefinitionsAndReferences = (context) => {
-    for (const binding of context.ir.bindings) {
+}
+function* projectDefinitionsAndReferences(context) {
+    for (const [bindingIndex, binding] of context.ir.bindings.entries()) {
+        if (bindingIndex % 64 === 0)
+            yield;
         const bindingNode = context.bindingNodes.get(binding.bindingId);
         if (bindingNode === undefined)
             continue;
@@ -274,6 +394,8 @@ const projectDefinitionsAndReferences = (context) => {
         }
     }
     for (const [index, reference] of context.ir.references.entries()) {
+        if (index % 64 === 0)
+            yield;
         const expression = retainNode(context.state, context.file, {
             kind: "expression",
             roleKey: `reference:${String(index)}:${reference.role}:${reference.name}`,
@@ -304,7 +426,7 @@ const projectDefinitionsAndReferences = (context) => {
                 resolution: "resolved",
             });
     }
-};
+}
 const projectCalls = (context) => {
     for (const call of context.ir.callSites) {
         const callNode = context.callSiteNodes.get(call.callSiteId);
@@ -371,3 +493,19 @@ const createArgumentNode = (context, callNode, callSiteId, argument) => retainNo
         : `argument ${String(argument.index)}`,
     functionNodeId: callNode.function_node_id,
 });
+/** Per-file projection passes, run in this order with a yield between each. */
+const FILE_PROJECTION_PASSES = [
+    projectSemanticValues,
+    projectSemanticObjects,
+    projectCalls,
+    projectSemanticPromises,
+    projectSemanticEvents,
+    projectSemanticTimers,
+    projectSemanticChildProcesses,
+    projectSemanticConfiguration,
+    projectSemanticRequests,
+    projectSemanticBoundaries,
+    projectSemanticResources,
+    projectSemanticClosureCaptures,
+    projectSemanticFrontiers,
+];

package/dist/application/javascript/JavaScriptSemanticGraphConstruction.js

@@ -1,26 +1,22 @@
 import { javascriptDisplayText } from "../../domain/javascript/javascriptAstValues.js";
 import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, JavaScriptSemanticEvidenceContextRegistry, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { inferredSemanticEvidence, observedSemanticEvidence, unavailableSemanticRootEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
-/** Create empty projection state with structural application-node mappings. */
-export const createSemanticGraphProjectionState = (applicationGraph) => {
-    const index = indexApplicationNodes(applicationGraph.nodes);
-    return {
-        nodes: new Map(),
-        relations: new Map(),
-        unknowns: new Map(),
-        evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
-        roots: new Set(),
-        applicationNodeIdsByLocation: index.identifiers,
-    };
-};
+/** Create empty projection state; application-node links are bound at finish. */
+export const createSemanticGraphProjectionState = () => ({
+    nodes: new Map(),
+    relations: new Map(),
+    unknowns: new Map(),
+    evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
+    roots: new Set(),
+});
 /** Bind retained semantic identities after all application observations exist. */
 export const bindSemanticGraphApplicationNodes = (state, applicationGraph) => {
-    const index = indexApplicationNodes(applicationGraph.nodes).identifiers;
+    const applicationNodeIdsByLocation = indexApplicationNodes(applicationGraph.nodes);
     for (const [identifier, node] of state.nodes) {
         state.nodes.set(identifier, {
             ...node,
             application_node_ids: [
-                ...(index.get(applicationLocationKey(node.identity.artifact_sha256, node.identity.module_path, node.identity.source_range)) ?? []),
+                ...(applicationNodeIdsByLocation.get(applicationLocationKey(node.identity.artifact_sha256, node.identity.module_path, node.identity.source_range)) ?? []),
             ],
         });
     }
@@ -35,7 +31,7 @@ export const constructSemanticGraphNode = (file, input, state) => createJavaScri
         role_key: input.roleKey,
     },
     function_node_id: input.functionNodeId,
-    application_node_ids: matchingApplicationNodeIds(file, input, state),
+    application_node_ids: [],
     label: input.label === null ? null : javascriptDisplayText(input.label),
     properties: input.properties ?? {},
     evidence: observedSemanticEvidence(file, input.location),
@@ -144,11 +140,8 @@ const indexApplicationNodes = (nodes) => {
         const sorted = [...values].sort();
         return [key, sorted];
     }));
-    return { identifiers: indexed };
+    return indexed;
 };
-const matchingApplicationNodeIds = (file, input, state) => [
-    ...(state.applicationNodeIdsByLocation.get(applicationLocationKey(file.sha256, file.path, input.location)) ?? []),
-];
 const addApplicationNodeIdentifier = (identifiers, key, nodeId) => {
     const values = identifiers.get(key) ?? new Set();
     values.add(nodeId);

package/dist/application/javascript/JavaScriptSemanticGraphDataProjection.js

@@ -97,7 +97,10 @@ const addRequestNode = (context, operation) => retainSemanticGraphNode(context.s
     kind: operation.kind === "request" ? "request" : "response",
     roleKey: operation.requestId,
     location: operation.location,
-    label: operation.endpoint ?? operation.method,
+    label: operation.endpoint !== null &&
+        operation.endpoint.length <= operation.method.length
+        ? operation.endpoint
+        : operation.method,
     functionNodeId: operation.ownerCallableId === null
         ? null
         : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??

package/dist/application/javascript/JavaScriptSemanticGraphFlowProjection.js

@@ -151,8 +151,10 @@ export const projectSemanticClosureCaptures = (context) => {
         });
 };
 /** Retain bounded unresolved dynamic-call, dynamic-property and dynamic-scope frontiers. */
-export const projectSemanticFrontiers = (context) => {
-    for (const frontier of context.ir.frontiers) {
+export function* projectSemanticFrontiers(context) {
+    for (const [index, frontier] of context.ir.frontiers.entries()) {
+        if (index % 64 === 0)
+            yield;
         // Dynamic environments leave identifier reads and writes unresolved.
         const family = frontier.kind === "dynamic-call"
             ? "call-flow"
@@ -178,4 +180,4 @@ export const projectSemanticFrontiers = (context) => {
         }, context.state.evidenceContexts);
         addSemanticGraphUnknown(context.state, unknown);
     }
-};
+}

package/dist/application/javascript/JavaScriptSemanticGraphObjectProjection.js

@@ -4,9 +4,11 @@ import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnkn
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
 /** Project static object reads, writes, spreads, and destructuring. */
-export const projectSemanticObjects = (context) => {
+export function* projectSemanticObjects(context) {
     const values = new Map(context.ir.bindings.map((binding) => [binding.bindingId, binding.value]));
-    for (const operation of context.ir.objectOperations) {
+    for (const [index, operation] of context.ir.objectOperations.entries()) {
+        if (index % 64 === 0)
+            yield;
         const occurrence = addObjectOccurrence(context, operation);
         const target = objectTarget(context, values, operation);
         const ends = objectRelationEnds(context, operation, occurrence, target);
@@ -22,7 +24,7 @@ export const projectSemanticObjects = (context) => {
         if (!resolved)
             addObjectUnknown(context, operation, target.slot ?? occurrence, target);
     }
-};
+}
 const OBJECT_RELATIONS = {
     read: "reads-property",
     write: "writes-property",

package/dist/application/javascript/JavaScriptSemanticGraphValueProjection.js

@@ -1,4 +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";
@@ -98,14 +99,24 @@ const projectValue = (input) => {
         }, context.state.evidenceContexts));
     }
 };
-const addLiteralNode = (context, binding, value, role) => retainSemanticGraphNode(context.state, context.file, {
-    kind: "literal",
-    roleKey: `literal:${binding.bindingId}:${role}:${JSON.stringify(value)}`,
-    location: binding.definitions[0]?.location ?? null,
-    label: JSON.stringify(value),
-    functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
-    properties: { value },
-});
+const addLiteralNode = (context, binding, value, role) => {
+    const encodedValue = JSON.stringify(value);
+    const valueDigest = `value-sha256:${digestCanonicalValue(value, "Semantic literal")}`;
+    const valueKey = encodedValue.length <= valueDigest.length ? encodedValue : valueDigest;
+    const stringLabel = "string literal";
+    return retainSemanticGraphNode(context.state, context.file, {
+        kind: "literal",
+        // Identity needs an exact value commitment, not another payload copy.
+        // Keep the complete literal in properties for queries and Evidence export.
+        roleKey: `literal:${binding.bindingId}:${role}:${valueKey}`,
+        location: binding.definitions[0]?.location ?? null,
+        label: typeof value === "string" && encodedValue.length > stringLabel.length
+            ? stringLabel
+            : encodedValue,
+        functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
+        properties: { value },
+    });
+};
 /** Create one canonical slot for a root binding and exact static property path. */
 export const semanticPropertySlot = (context, objectBindingId, path, fact) => retainSemanticGraphNode(context.state, context.file, {
     kind: "property-slot",

package/dist/application/jeb/JebAnalysisPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/jeb/JebAnalysisService.js

@@ -0,0 +1,13 @@
+import { jebRequestSchema, } from "../../domain/jeb/jebAnalysis.js";
+import { executeProviderOperation } from "../ProviderOperationExecution.js";
+/** Shared CLI/MCP admission, execution and Evidence composition for JEB. */
+export class JebAnalysisService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Run one caller-selected JEB request and retain engine provenance inline. */
+    async execute(operation, input, options) {
+        return executeProviderOperation(operation, input, options, jebRequestSchema, this.provider, operation === "decompile_jeb_item" ? "derived" : "observed");
+    }
+}

package/dist/application/managed/ManagedApplicationGraphService.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.js";
-import { createEvidence } from "../../domain/evidence.js";
+import { createEvidence, } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../../domain/managed/managedApplicationGraph.js";
 import { err, ok } from "../../domain/result.js";

package/dist/application/native/NativeUiActionTrace.js

@@ -35,14 +35,23 @@ export const traceNativeUiAction = async (analysis, input, signal) => {
         if (decoded.data.target_sha256 !== targetSha256)
             return err(new AnalysisOutputError("decode_interface_builder", "UI and native provider results refer to different target SHA-256 values"));
         graph = joinInterfaceBuilderDispatch(decoded.data.graph, metadata.result);
+        const archiveDecode = decoded.data.graph.coverage.find((facet) => facet.facet === "archive_decode");
+        const documentsFound = decoded.data.documents.length > 0;
         coverage.push({
             facet: "interface_builder_archives",
-            status: decoded.data.documents.length > 0 ? "complete" : "unsupported",
-            reason: decoded.data.documents.length > 0
-                ? null
-                : "no_compiled_interface_builder_archives_found",
-            examined: decoded.data.documents.length,
-            omitted: 0,
+            status: archiveDecode?.status === "partial" ||
+                archiveDecode?.status === "complete" ||
+                archiveDecode?.status === "unsupported"
+                ? archiveDecode.status
+                : documentsFound
+                    ? "complete"
+                    : "unsupported",
+            reason: archiveDecode?.reason ??
+                (documentsFound
+                    ? null
+                    : "no_compiled_interface_builder_archives_found"),
+            examined: archiveDecode?.examined ?? decoded.data.documents.length,
+            omitted: archiveDecode?.omitted ?? 0,
         });
         const bounded = boundUiGraph(graph, input.max_nodes, input.max_edges);
         graph = bounded.graph;
@@ -218,8 +227,7 @@ const resolveUiAction = (graph, query) => {
         };
     const objectMatches = graph.nodes.filter((node) => ["control", "view", "view_controller", "scene"].includes(node.kind) &&
         (node.id === query ||
-            node.attributes.interface_builder_object_id === query ||
-            node.id.endsWith(`:object:${query}`)));
+            node.attributes.interface_builder_object_id === query));
     const actionIds = new Set(graph.edges.flatMap((edge) => edge.resolution === "observed" &&
         edge.relation === "target_action" &&
         objectMatches.some(({ id }) => edge.from === id) &&