rea-agents 3.0.0 → 3.2.0

package/dist/domain/javascriptRuntimeReconciliationActive.js

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { isPathWithinRoot } from "./localPath.js";
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { classifyBrowserCompleteness, } from "./browserCompleteness.js";
+import { electronActiveObservationResultSchema, } from "./electronActiveObservation.js";
+/** Parse active Electron Evidence as a bounded, target-only runtime capture. */
+export const parseActiveElectronCapture = (evidence) => {
+    assertIdentity(evidence);
+    const result = electronActiveObservationResultSchema.parse(evidence.normalized_result);
+    const parameters = z
+        .object({
+        application_path: absolutePathSchema,
+        application_root: absolutePathSchema,
+    })
+        .passthrough()
+        .parse(evidence.parameters);
+    if (result.application.application_path !== parameters.application_path ||
+        !isPathWithinRoot(parameters.application_root, result.application.application_path))
+        throw new TypeError("Active Electron Evidence application path disagrees with its configured root");
+    return {
+        kind: "electron-active",
+        evidence,
+        inspection: normalizeInspection(result),
+        captureSha256: digestCanonical(result),
+        scriptsCompleteWithinScope: false,
+    };
+};
+const absolutePathSchema = z.string().min(1).refine(isAbsolute);
+const assertIdentity = (evidence) => {
+    if (evidence.operation !== "capture_electron_scenario" ||
+        evidence.predicate_type !== "rea.electron-active-scenario" ||
+        evidence.provider.id !== "rea-playwright-electron-active" ||
+        evidence.provider.name !==
+            "REA Playwright active Electron observation provider" ||
+        evidence.provider.version !== "1" ||
+        evidence.authority !== "controlled-replay" ||
+        evidence.confidence !== "observed")
+        throw new TypeError("Evidence does not match the supported capture_electron_scenario contract");
+};
+const normalizeInspection = (result) => ({
+    target: {
+        target_id: `electron-active:${digestCanonical(result.application.application_path).slice(0, 32)}`,
+        type: "electron-application",
+        title: result.application.application_path,
+        attached: true,
+        file_path: result.application.application_path,
+    },
+    frames: [],
+    scripts: { items: [] },
+    workers: [],
+    completeness: classifyBrowserCompleteness({
+        policyFilteredSections: new Set(),
+        attachLimitedSections: new Set(),
+        truncatedSections: new Set(),
+        unavailableSections: new Set([
+            "frames",
+            "scripts",
+            "script_sources",
+            "workers",
+        ]),
+        excluded: [],
+        droppedEvents: {
+            scripts: 0,
+            network_requests: 0,
+            console_events: 0,
+            websocket_connections: 0,
+            websocket_frames: 0,
+            webmcp_tools: 0,
+            timeline_events: 0,
+        },
+    }),
+});
+const digestCanonical = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Runtime reconciliation could not canonicalize input");
+    return createHash("sha256").update(encoded).digest("hex");
+};

package/dist/domain/javascriptRuntimeReconciliationGraph.js

@@ -10,11 +10,10 @@ export const buildReconciledApplicationGraph = (input) => {
         ...input.runtime.edges,
         ...input.reconciliationEdges,
     ]);
-    const bounded = boundGraphContent(input, merged.nodes, allEdges);
-    const facts = graphCoverageFacts(input, merged.omittedObservations + bounded.omittedItems);
+    const bounded = boundGraphContent(input, merged, allEdges);
+    const facts = graphCoverageFacts(input, bounded.omittedItems);
     const graph = createJavaScriptApplicationGraph({
         schema: "JavaScriptApplicationGraph",
-        schema_version: 1,
         root_node_ids: bounded.rootNodeIds,
         nodes: bounded.nodes,
         edges: bounded.edges,
@@ -24,45 +23,37 @@ export const buildReconciledApplicationGraph = (input) => {
             "Runtime presence is bounded to passive capture windows and does not prove feature execution.",
             "Cross-layer observed_as edges are inferences; digest equality proves byte identity only.",
             "Source-map relationships retain their original static authority and are not promoted into runtime matches.",
-            ...(facts.inputTruncated
+            ...(facts.inputStatus === "truncated"
                 ? [
                     "One or more source graphs or passive captures were incomplete or truncated.",
                 ]
                 : []),
             ...(facts.outputTruncated
                 ? [
-                    "The reconciled graph omitted entities or classifications at caller limits.",
+                    "The reconciled graph omitted entities or classifications during projection.",
                 ]
                 : []),
         ]),
     });
     return {
         graph,
-        omittedGraphItems: merged.omittedObservations + bounded.omittedItems,
+        omittedGraphItems: bounded.omittedItems,
     };
 };
 const boundGraphContent = (input, nodes, edges) => {
     const allRoots = preferredRootIds(input);
-    const rootNodeIds = allRoots.slice(0, 1_000);
-    const roots = new Set(rootNodeIds);
+    const rootNodeIds = allRoots;
     const sortedNodes = [...nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id));
-    const retainedNodes = [
-        ...sortedNodes.filter(({ node_id: id }) => roots.has(id)),
-        ...sortedNodes.filter(({ node_id: id }) => !roots.has(id)),
-    ].slice(0, 100_000);
+    const retainedNodes = sortedNodes;
     const retainedIds = new Set(retainedNodes.map(({ node_id: id }) => id));
     const retainedEdges = [...edges]
         .sort((left, right) => compareCodePoints(left.edge_id, right.edge_id))
-        .filter(({ source_node_id: source, target_node_id: target }) => retainedIds.has(source) && retainedIds.has(target))
-        .slice(0, 200_000);
+        .filter(({ source_node_id: source, target_node_id: target }) => retainedIds.has(source) && retainedIds.has(target));
     return {
         rootNodeIds,
         nodes: retainedNodes,
         edges: retainedEdges,
-        omittedItems: allRoots.length -
-            rootNodeIds.length +
-            (nodes.length - retainedNodes.length) +
-            (edges.length - retainedEdges.length),
+        omittedItems: 0,
     };
 };
 const preferredRootIds = (input) => {
@@ -83,6 +74,8 @@ const graphCoverageFacts = (input, omittedNodeObservations) => {
     const captureHasUnknownOmissions = input.captures.some(({ inspection }) => inspection.completeness.unavailable_sections.length > 0);
     const inputTruncated = input.layers.some(({ graph }) => graph.coverage.truncated) ||
         captureTruncated;
+    const inputComplete = input.layers.every(({ graph }) => graph.coverage.status === "complete") &&
+        input.captures.every(({ inspection }) => inspection.completeness.status === "complete_within_window");
     const outputTruncated = projectionOmissions > 0;
     const sourceOmissions = input.layers.reduce((total, { graph }) => total + (graph.coverage.omitted_count ?? 0), 0);
     const omissionsKnown = !captureTruncated &&
@@ -92,24 +85,23 @@ const graphCoverageFacts = (input, omittedNodeObservations) => {
         projectionOmissions,
         knownOmissions: projectionOmissions + sourceOmissions,
         omissionsKnown,
-        inputTruncated,
+        inputStatus: inputTruncated
+            ? "truncated"
+            : inputComplete
+                ? "complete"
+                : "partial",
         outputTruncated,
-        truncated: inputTruncated || outputTruncated,
-        complete: !inputTruncated &&
-            !outputTruncated &&
-            input.layers.every(({ graph }) => graph.coverage.status === "complete") &&
-            input.captures.every(({ inspection }) => inspection.completeness.status === "complete_within_window"),
     };
 };
-const graphCoverage = (input, facts, nodeCount) => facts.complete
+const graphCoverage = (input, facts, nodeCount) => facts.inputStatus === "complete" && !facts.outputTruncated
     ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
-    : facts.truncated
+    : facts.inputStatus === "truncated" || facts.outputTruncated
         ? {
             status: "partial",
             truncated: true,
             omitted_count: facts.omissionsKnown ? facts.knownOmissions : null,
             limits: [
-                ...(facts.inputTruncated
+                ...(facts.inputStatus === "truncated"
                     ? [
                         {
                             name: "runtime-reconciliation-input-coverage",
@@ -139,7 +131,6 @@ const mergeNodes = (nodes) => {
     const grouped = new Map();
     for (const node of nodes)
         grouped.set(node.node_id, [...(grouped.get(node.node_id) ?? []), node]);
-    let omittedObservations = 0;
     const merged = [...grouped.values()].map((group) => {
         const first = group[0];
         if (first === undefined)
@@ -152,16 +143,13 @@ const mergeNodes = (nodes) => {
                 .flatMap(({ observations: values }) => values)
                 .map((observation) => [observation.observation_id, observation])).values(),
         ].sort((left, right) => compareCodePoints(left.observation_id, right.observation_id));
-        omittedObservations += Math.max(0, observations.length - 64);
         return createJavaScriptApplicationNode({
             kind: first.kind,
             identity: first.identity,
-            observations: observations
-                .slice(0, 64)
-                .map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
+            observations: observations.map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
         });
     });
-    return { nodes: merged, omittedObservations };
+    return merged;
 };
 const uniqueEdges = (edges) => [
     ...new Map(edges.map((edge) => [edge.edge_id, edge])).values(),

package/dist/domain/javascriptRuntimeReconciliationMatching.js

@@ -5,13 +5,11 @@ import { mappedRuntimePaths, } from "./javascriptRuntimeStaticCandidates.js";
 export const reconcileRuntimeEntities = (input) => {
     const index = indexCandidates(input.candidates);
     const evaluated = input.entities.map((entity) => reconcileEntity(entity, index, input.layers));
-    const retained = evaluated
-        .sort((left, right) => compareCodePoints(left.item.reconciliation_id, right.item.reconciliation_id))
-        .slice(0, input.maximumItems);
+    const retained = evaluated.sort((left, right) => compareCodePoints(left.item.reconciliation_id, right.item.reconciliation_id));
     return {
         items: retained.map(({ item }) => item),
         edges: retained.flatMap(({ edge }) => (edge === null ? [] : [edge])),
-        omittedItems: evaluated.length - retained.length,
+        omittedItems: 0,
     };
 };
 const reconcileEntity = (entity, index, layers) => {
@@ -20,14 +18,16 @@ const reconcileEntity = (entity, index, layers) => {
         const content = index.byCategoryDigest.get(categoryDigestKey(entity.staticKind, entity.sourceSha256)) ?? [];
         const locatedKeys = new Set(locations.map(({ candidate }) => candidateKey(candidate)));
         const combined = content.filter((candidate) => locatedKeys.has(candidateKey(candidate)));
-        if (combined.length === 1)
-            return matched(entity, combined[0], {
+        const combinedCandidate = combined.at(0);
+        if (combined.length === 1 && combinedCandidate !== undefined)
+            return matched(entity, combinedCandidate, {
                 basis: "content-and-location",
                 confidence: "high",
                 reason: "content-and-location-match",
             });
-        if (content.length === 1) {
-            const candidate = content[0];
+        const contentCandidate = content.at(0);
+        if (content.length === 1 && contentCandidate !== undefined) {
+            const candidate = contentCandidate;
             const digestBasis = candidate.digests.find(({ sha256 }) => sha256 === entity.sourceSha256)?.basis;
             return matched(entity, candidate, {
                 basis: digestBasis ?? "content-sha256",
@@ -59,8 +59,9 @@ const reconcileEntity = (entity, index, layers) => {
             candidates: [],
         });
     }
-    if (locations.length === 1) {
-        const located = locations[0];
+    const location = locations.at(0);
+    if (locations.length === 1 && location !== undefined) {
+        const located = location;
         return matched(entity, located.candidate, {
             basis: located.mapping.basis,
             confidence: "medium",
@@ -156,13 +157,22 @@ const unresolved = (entity, input) => ({
 });
 const createItem = (entity, input) => {
     const candidateReferences = uniqueCandidateReferences(input.candidates);
+    const staticMatch = input.status === "matched"
+        ? {
+            static_layer_id: input.layer.layerId,
+            static_node_id: input.staticNodeId,
+            status: input.status,
+        }
+        : {
+            static_layer_id: null,
+            static_node_id: null,
+            status: input.status,
+        };
     const semantic = {
         entity_kind: entity.kind,
         runtime_evidence_id: entity.capture.evidence.evidence_id,
         runtime_node_id: entity.node.node_id,
-        static_layer_id: input.layer?.layerId ?? null,
-        static_node_id: input.staticNodeId,
-        status: input.status,
+        ...staticMatch,
         basis: input.basis,
         confidence: input.confidence,
         reason: input.reason,
@@ -174,50 +184,55 @@ const createItem = (entity, input) => {
         ...semantic,
     };
 };
-const reconciliationEvidence = (entity, layer, basis, confidence) => ({
-    authority: "cross-layer-reconciliation",
-    state: "inferred",
-    confidence: confidence === "medium" ? "medium" : "high",
-    artifact: entity.sourceSha256 === null
-        ? {
-            available: false,
-            reason: "not-observed",
-            detail: "Runtime source bytes were not captured for this mapping.",
-        }
-        : {
-            available: true,
-            artifact_id: `art_${entity.sourceSha256}`,
-            sha256: entity.sourceSha256,
-        },
-    location: entity.node.observations[0].evidence.location,
-    extractor: {
-        name: "rea-javascript-runtime-reconciliation",
-        version: "1",
-        operation: "reconcile_javascript_runtime",
-        executable_sha256: null,
-    },
-    coverage: layer.graph.coverage.status === "complete" &&
-        entity.capture.scriptsCompleteWithinScope
-        ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
-        : {
-            status: "partial",
-            truncated: false,
-            omitted_count: null,
-            limits: [],
+const reconciliationEvidence = (entity, layer, basis, confidence) => {
+    const observation = entity.node.observations.at(0);
+    if (observation === undefined)
+        throw new TypeError("Runtime reconciliation entity has no observation");
+    return {
+        authority: "cross-layer-reconciliation",
+        state: "inferred",
+        confidence: confidence === "medium" ? "medium" : "high",
+        artifact: entity.sourceSha256 === null
+            ? {
+                available: false,
+                reason: "not-observed",
+                detail: "Runtime source bytes were not captured for this mapping.",
+            }
+            : {
+                available: true,
+                artifact_id: `art_${entity.sourceSha256}`,
+                sha256: entity.sourceSha256,
+            },
+        location: observation.evidence.location,
+        extractor: {
+            name: "rea-javascript-runtime-reconciliation",
+            version: "1",
+            operation: "reconcile_javascript_runtime",
+            executable_sha256: null,
         },
-    limitations: [
-        basis === "content-sha256" ||
-            basis === "module-source-sha256" ||
-            basis === "content-and-location"
-            ? "Equal content digests establish byte identity, not execution causality."
-            : "Location correspondence is inferred from an artifact root or caller-declared mapping.",
-        "Passive script parsing or target presence does not prove feature execution.",
-    ],
-    evidence_ids: [
-        layer.evidence.evidence_id,
-        entity.capture.evidence.evidence_id,
-    ].sort(),
-});
+        coverage: layer.graph.coverage.status === "complete" &&
+            entity.capture.scriptsCompleteWithinScope
+            ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
+            : {
+                status: "partial",
+                truncated: false,
+                omitted_count: null,
+                limits: [],
+            },
+        limitations: [
+            basis === "content-sha256" ||
+                basis === "module-source-sha256" ||
+                basis === "content-and-location"
+                ? "Equal content digests establish byte identity, not execution causality."
+                : "Location correspondence is inferred from an artifact root or caller-declared mapping.",
+            "Passive script parsing or target presence does not prove feature execution.",
+        ],
+        evidence_ids: [
+            layer.evidence.evidence_id,
+            entity.capture.evidence.evidence_id,
+        ].sort(),
+    };
+};
 const strongestLocationBasis = (values) => {
     const bases = new Set(values.map(({ mapping }) => mapping.basis));
     if (bases.has("artifact-path"))
@@ -237,11 +252,10 @@ const uniqueCandidateReferences = (candidates) => {
             continue;
         seen.add(key);
         count += 1;
-        if (items.length < 1_000)
-            items.push({
-                static_layer_id: layer.layerId,
-                static_node_id: node.node_id,
-            });
+        items.push({
+            static_layer_id: layer.layerId,
+            static_node_id: node.node_id,
+        });
     }
     return { count, items };
 };

package/dist/domain/javascriptRuntimeReconciliationParsing.js

@@ -1,14 +1,14 @@
 import { createHash } from "node:crypto";
-import { isAbsolute, relative } from "node:path";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { browserAllowedOriginsSchema, browserEndpointSchema, browserOriginSchema, webPageInspectionSchema, } from "./browserObservation.js";
+import { browserAllowedOriginsSchema, browserEndpointSchema, webPageInspectionSchema, } from "./browserObservation.js";
 import { classifyBrowserCompleteness, } from "./browserCompleteness.js";
-import { electronFileRootsSchema, electronPageInspectionSchema, } from "./electronObservation.js";
+import { electronPageInspectionSchema, } from "./electronObservation.js";
 import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from "./javascriptRuntimeObservation.js";
 import { parseEvidence } from "./evidence.js";
 import { javascriptApplicationAnalysisResultSchema, } from "./javascriptApplicationAnalysis.js";
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+import { parseActiveElectronCapture } from "./javascriptRuntimeReconciliationActive.js";
 /** Parse and semantically bind every static analysis Evidence layer. */
 export const parseStaticLayers = (layers) => layers
     .map((layer) => parseStaticLayer(layer))
@@ -28,7 +28,7 @@ const parseStaticLayer = (layer) => {
     const result = javascriptApplicationAnalysisResultSchema.parse(evidence.normalized_result);
     assertEvidenceIdentity(evidence, {
         operation: "analyze_javascript_application",
-        predicate: `rea.javascript-application-analysis/v${String(result.schema_version)}`,
+        predicate: "rea.javascript-application-analysis",
         providerId: "rea-javascript-application",
         providerName: "REA JavaScript application analyzer",
         providerVersion: "1",
@@ -40,13 +40,6 @@ const parseStaticLayer = (layer) => {
         evidence.subject.format !== result.format ||
         evidence.subject.local_path !== result.input_path)
         throw new TypeError("JavaScript application Evidence subject disagrees with its result");
-    const parameters = z
-        .object({
-        approved: z.literal(true),
-        source_map_read_approved: z.boolean(),
-    })
-        .passthrough()
-        .parse(evidence.parameters);
     return {
         layerId: `jrl_${digestCanonical({
             role: layer.role,
@@ -58,7 +51,6 @@ const parseStaticLayer = (layer) => {
         result,
         graph: result.graph,
         runtimeMappings: layer.runtime_mappings,
-        sourceMapReadApproved: parameters.source_map_read_approved,
     };
 };
 const parseRuntimeCapture = (input) => {
@@ -66,7 +58,7 @@ const parseRuntimeCapture = (input) => {
     if (evidence.operation === "inspect_web_page") {
         assertEvidenceIdentity(evidence, {
             operation: "inspect_web_page",
-            predicate: "rea.web-page-inspection/v2",
+            predicate: "rea.web-page-inspection",
             providerId: "rea-cdp-browser",
             providerName: "REA Chrome DevTools Protocol observation provider",
             providerVersion: "2",
@@ -91,7 +83,7 @@ const parseRuntimeCapture = (input) => {
     if (evidence.operation === "inspect_electron_page") {
         assertEvidenceIdentity(evidence, {
             operation: "inspect_electron_page",
-            predicate: "rea.electron-page-inspection/v1",
+            predicate: "rea.electron-page-inspection",
             providerId: "rea-cdp-electron",
             providerName: "REA Electron file-page CDP observation provider",
             providerVersion: "1",
@@ -115,7 +107,7 @@ const parseRuntimeCapture = (input) => {
     if (evidence.operation === "observe_javascript_runtime") {
         assertEvidenceIdentity(evidence, {
             operation: "observe_javascript_runtime",
-            predicate: "rea.javascript-runtime-observation/v1",
+            predicate: "rea.javascript-runtime-observation",
             providerId: "rea-v8-inspector",
             providerName: "REA passive Node/Electron V8 Inspector provider",
             providerVersion: "1",
@@ -133,38 +125,30 @@ const parseRuntimeCapture = (input) => {
             scriptsCompleteWithinScope: false,
         };
     }
-    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, or observe_javascript_runtime Evidence");
+    if (evidence.operation === "capture_electron_scenario") {
+        return parseActiveElectronCapture(evidence);
+    }
+    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, observe_javascript_runtime, or capture_electron_scenario Evidence");
 };
 const assertV8RuntimeParameters = (evidence, result) => {
     const parameters = z
         .object({
         inspector_endpoint: browserEndpointSchema,
-        allowed_file_roots: z
-            .array(z.string().min(1).max(16_384).refine(isAbsolute))
-            .max(32),
-        allowed_origins: z.array(browserOriginSchema).max(32),
-        target_id: z.string().trim().min(1).max(256),
-        runtime_kind: javascriptRuntimeKindSchema,
+        target_id: z.string().trim().min(1),
+        runtime_kind: javascriptRuntimeKindSchema.optional(),
     })
         .passthrough()
         .parse(evidence.parameters);
     if (parameters.target_id !== result.target.target_id ||
-        parameters.runtime_kind !== result.target.runtime_kind)
+        (parameters.runtime_kind !== undefined &&
+            parameters.runtime_kind !== result.target.runtime_kind))
         throw new TypeError("Runtime Evidence target or declared role disagrees with its result");
     for (const location of [
         result.target.location,
         ...result.scripts.items.map(({ location }) => location),
     ])
-        if ((location.kind === "file" &&
-            !parameters.allowed_file_roots.some((root) => isWithinRoot(root, location.file_path))) ||
-            (location.kind === "url" &&
-                !parameters.allowed_origins.includes(location.origin)) ||
-            (location.kind === "builtin" && !location.specifier.startsWith("node:")))
-            throw new TypeError("Runtime Evidence contains a location outside its recorded scope");
-};
-const isWithinRoot = (root, path) => {
-    const remainder = relative(root, path);
-    return (remainder === "" || (!remainder.startsWith("..") && !isAbsolute(remainder)));
+        if (location.kind === "builtin" && !location.specifier.startsWith("node:"))
+            throw new TypeError("Runtime Evidence contains an invalid builtin location");
 };
 const normalizeV8Inspection = (result) => ({
     target: {
@@ -231,7 +215,7 @@ const runtimeLocation = (location) => {
 const excludedV8Scripts = (result) => Object.values(result.scripts.excluded).reduce((total, count) => total + count, 0);
 const assertRuntimeParameters = (evidence, expected) => {
     const common = {
-        target_id: z.string().trim().min(1).max(256),
+        target_id: z.string().trim().min(1),
         cdp_endpoint: browserEndpointSchema,
         include_script_sources: z.boolean(),
     };
@@ -248,20 +232,11 @@ const assertRuntimeParameters = (evidence, expected) => {
             throw new TypeError("Runtime Evidence contains source without source-capture approval");
         return;
     }
-    const parameters = z
-        .object({
-        ...common,
-        allowed_file_roots: electronFileRootsSchema,
-        source_capture_approved: z.boolean(),
-    })
-        .passthrough()
-        .parse(evidence.parameters);
+    const parameters = z.object(common).passthrough().parse(evidence.parameters);
     if (parameters.target_id !== expected.targetId)
         throw new TypeError("Runtime Evidence target disagrees with its captured result");
-    if (expected.sourceIncluded &&
-        (!parameters.include_script_sources ||
-            parameters.source_capture_approved !== true))
-        throw new TypeError("Runtime Evidence contains source without source-capture approval");
+    if (expected.sourceIncluded && !parameters.include_script_sources)
+        throw new TypeError("Runtime Evidence contains source without source-capture selection");
 };
 const scriptsComplete = (completeness) => !completeness.truncated_sections.includes("scripts") &&
     !completeness.unavailable_sections.includes("scripts") &&

package/dist/domain/javascriptRuntimeReconciliationResult.js

@@ -5,7 +5,6 @@ import { javascriptRuntimeReconciliationResultSchema, } from "./javascriptRuntim
 export const createJavaScriptRuntimeReconciliationResult = (input) => {
     const completion = completionFlags(input);
     const semantic = {
-        schema_version: 1,
         static_layers: staticLayerSummaries(input.layers),
         runtime_captures: captureSummaries(input.captures, input.runtime),
         graph: input.graph,
@@ -45,9 +44,9 @@ const captureSummaries = (captures, runtime) => captures.map((capture) => {
         kind: capture.kind,
         target_node_id: targetNode.node_id,
         target_key: capture.inspection.target.target_id,
-        target_location: ("url" in capture.inspection.target
+        target_location: "url" in capture.inspection.target
             ? capture.inspection.target.url
-            : capture.inspection.target.file_path).slice(0, 4_096),
+            : capture.inspection.target.file_path,
         frames: capture.inspection.frames.length,
         scripts: capture.inspection.scripts.items.length,
         workers: capture.inspection.workers.length,
@@ -70,7 +69,7 @@ const reconciliationSummary = (input) => ({
 });
 const sourceMapAuthority = (input) => ({
     used_for_primary_matching: false,
-    static_layers_with_read_approval: input.layers.filter(({ sourceMapReadApproved }) => sourceMapReadApproved).length,
+    static_layer_count: input.layers.length,
     runtime_script_declarations: input.captures.reduce((total, capture) => total +
         (capture.kind === "browser"
             ? capture.inspection.scripts.items.filter(({ source_map_url: url }) => url !== null).length
@@ -78,27 +77,34 @@ const sourceMapAuthority = (input) => ({
     limitation: "Source-map declarations and approved original-source reads retain separate static authority and are not used as primary runtime byte matches.",
 });
 const reconciliationCoverage = (input, completion) => ({
-    status: completion.outputTruncated || completion.inputTruncated
+    status: completion.outputTruncated || completion.inputStatus === "truncated"
         ? "truncated"
-        : completion.inputPartial
+        : completion.inputStatus === "partial"
             ? "partial"
             : "complete-within-inputs",
-    truncated: completion.outputTruncated || completion.inputTruncated,
+    truncated: completion.outputTruncated || completion.inputStatus === "truncated",
     omitted_runtime_entities: input.runtime.omittedEntities,
     omitted_reconciliation_items: input.matching.omittedItems,
     omitted_static_load_states: input.loadStates.omittedStates,
     omitted_graph_items: input.omittedGraphItems,
 });
-const completionFlags = (input) => ({
-    outputTruncated: input.runtime.omittedEntities > 0 ||
-        input.matching.omittedItems > 0 ||
-        input.loadStates.omittedStates > 0 ||
-        input.omittedGraphItems > 0,
-    inputTruncated: input.layers.some(({ graph }) => graph.coverage.truncated) ||
-        input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated")),
-    inputPartial: input.layers.some(({ graph }) => graph.coverage.status !== "complete") ||
-        input.captures.some(({ inspection }) => inspection.completeness.status !== "complete_within_window"),
-});
+const completionFlags = (input) => {
+    const inputTruncated = input.layers.some(({ graph }) => graph.coverage.truncated) ||
+        input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated"));
+    const inputPartial = input.layers.some(({ graph }) => graph.coverage.status !== "complete") ||
+        input.captures.some(({ inspection }) => inspection.completeness.status !== "complete_within_window");
+    return {
+        outputTruncated: input.runtime.omittedEntities > 0 ||
+            input.matching.omittedItems > 0 ||
+            input.loadStates.omittedStates > 0 ||
+            input.omittedGraphItems > 0,
+        inputStatus: inputTruncated
+            ? "truncated"
+            : inputPartial
+                ? "partial"
+                : "complete",
+    };
+};
 const reconciliationLimitations = (completion) => uniqueSorted([
     "Only caller-supplied, semantically verified Evidence records were reconciled.",
     "Digest equality establishes byte identity but not code reachability, module initialization, or feature execution.",
@@ -106,12 +112,12 @@ const reconciliationLimitations = (completion) => uniqueSorted([
     "Not-observed means absent from the bounded captures in scope, never globally unloaded.",
     "Caller-declared file and URL mappings are inference inputs and do not expand CDP origin or filesystem-root authority.",
     "Source-map authority remains separate from passive runtime authority.",
-    ...(completion.inputPartial
+    ...(completion.inputStatus !== "complete"
         ? ["One or more static graphs or passive captures were incomplete."]
         : []),
     ...(completion.outputTruncated
         ? [
-            "Caller limits omitted runtime entities or reconciliation classifications.",
+            "Runtime reconciliation omitted entities or classifications during projection.",
         ]
         : []),
 ]);