rea-agents 6.0.0 → 6.2.0

package/dist/application/javascript/JavaScriptSemanticGraphObjectProjection.js

@@ -1,80 +1,109 @@
+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";
 /** Project static object reads, writes, spreads, and destructuring. */
 export const projectSemanticObjects = (context) => {
+    const values = new Map(context.ir.bindings.map((binding) => [binding.bindingId, binding.value]));
     for (const operation of context.ir.objectOperations) {
         const occurrence = addObjectOccurrence(context, operation);
-        const slot = operation.objectBindingId === null || operation.propertyName === null
-            ? null
-            : semanticPropertySlot(context, operation.objectBindingId, operation.propertyName);
-        if (operation.kind === "read")
-            addSemanticGraphRelation(context.state, {
-                source: slot,
-                target: occurrence,
-                relation: "reads-property",
-                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
-            });
-        else if (operation.kind === "write")
-            addSemanticGraphRelation(context.state, {
-                source: occurrence,
-                target: slot,
-                relation: "writes-property",
-                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
-            });
-        else if (operation.kind === "destructure")
-            addSemanticGraphRelation(context.state, {
-                source: slot,
+        const target = objectTarget(context, values, operation);
+        const ends = objectRelationEnds(context, operation, occurrence, target);
+        const resolved = operation.resolution === "complete" &&
+            (operation.kind === "write"
+                ? target.receiverResolved
+                : target.presence === "present");
+        addSemanticGraphRelation(context.state, {
+            ...ends,
+            relation: OBJECT_RELATIONS[operation.kind],
+            resolution: resolved ? "resolved" : "candidate",
+        });
+        if (!resolved)
+            addObjectUnknown(context, operation, target.slot ?? occurrence, target);
+    }
+};
+const OBJECT_RELATIONS = {
+    read: "reads-property",
+    write: "writes-property",
+    destructure: "destructures",
+    spread: "spreads",
+};
+const objectTarget = (context, values, operation) => {
+    const binding = operation.objectBindingId === null
+        ? undefined
+        : context.bindingNodes.get(operation.objectBindingId);
+    const value = operation.objectBindingId === null
+        ? undefined
+        : values.get(operation.objectBindingId);
+    if (operation.objectBindingId === null ||
+        operation.propertyPath === null ||
+        value === undefined)
+        return {
+            objectNode: binding,
+            slot: null,
+            presence: "unknown-coverage",
+            receiverResolved: false,
+        };
+    const fact = semanticSlotAtPath(value, operation.propertyPath);
+    if (operation.propertyPath.length === 0)
+        return {
+            objectNode: binding,
+            slot: null,
+            presence: fact.presence,
+            receiverResolved: semanticContainer(value) !== null,
+        };
+    const slot = semanticPropertySlot(context, operation.objectBindingId, operation.propertyPath, fact);
+    const receiver = semanticSlotAtPath(value, operation.propertyPath.slice(0, -1));
+    return {
+        objectNode: slot,
+        slot,
+        presence: fact.presence,
+        receiverResolved: receiver.presence === "present" &&
+            semanticContainer(receiver.value) !== null,
+    };
+};
+const objectRelationEnds = (context, operation, occurrence, target) => {
+    switch (operation.kind) {
+        case "read":
+            return { source: target.slot, target: occurrence };
+        case "write":
+            return { source: occurrence, target: target.slot };
+        case "destructure":
+            return {
+                source: target.slot,
                 target: operation.targetBindingId === null
                     ? undefined
                     : context.bindingNodes.get(operation.targetBindingId),
-                relation: "destructures",
-                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
-            });
-        else
-            addSemanticGraphRelation(context.state, {
-                source: operation.objectBindingId === null
-                    ? undefined
-                    : context.bindingNodes.get(operation.objectBindingId),
-                target: occurrence,
-                relation: "spreads",
-                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
-            });
-        if (operation.resolution !== "complete")
-            addObjectUnknown(context, operation, slot ?? occurrence);
+            };
+        case "spread":
+            return { source: target.objectNode, target: occurrence };
     }
 };
 const addObjectOccurrence = (context, operation) => retainSemanticGraphNode(context.state, context.file, {
     kind: "expression",
     roleKey: operation.objectOperationId,
     location: operation.location,
-    label: operation.propertyName === null
+    label: operation.propertyPath === null
         ? operation.kind
-        : `${operation.kind}:${operation.propertyName}`,
+        : `${operation.kind}:${semanticPropertyPointer(operation.propertyPath)}`,
     functionNodeId: operation.ownerCallableId === null
         ? null
         : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
             null),
     properties: {
         operation_kind: operation.kind,
-        property_name: operation.propertyName,
+        property_path: operation.propertyPath === null ? null : [...operation.propertyPath],
     },
 });
-const addObjectUnknown = (context, operation, node) => {
-    const relation = operation.kind === "read"
-        ? "reads-property"
-        : operation.kind === "write"
-            ? "writes-property"
-            : operation.kind === "spread"
-                ? "spreads"
-                : "destructures";
+const addObjectUnknown = (context, operation, node, target) => {
+    const relation = OBJECT_RELATIONS[operation.kind];
     addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
         node_id: node?.node_id ?? null,
         family: "object-flow",
         relation_kinds: [relation],
         reason: "ambiguous-target",
-        detail: `Static ${operation.kind} object identity is partial.`,
+        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),
     }));

package/dist/application/javascript/JavaScriptSemanticGraphResourceProjection.js

@@ -1,7 +1,6 @@
 import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
-import { semanticCallSiteAt, } from "./JavaScriptSemanticGraphFlowProjection.js";
 /** Project built-in resource acquisition and exact local release handles. */
 export const projectSemanticResources = (context) => {
     const resourceNodes = new Map(context.ir.resourceOperations.flatMap((operation) => {
@@ -13,7 +12,7 @@ export const projectSemanticResources = (context) => {
     for (const operation of context.ir.resourceOperations)
         if (operation.kind === "acquire")
             addSemanticGraphRelation(context.state, {
-                source: semanticCallSiteAt(context, operation.location),
+                source: context.callSiteAt(operation.location),
                 target: resourceNodes.get(operation.resourceId),
                 relation: "acquires",
                 resolution: "resolved",
@@ -33,7 +32,7 @@ const addResourceNode = (context, operation) => retainSemanticGraphNode(context.
     properties: { method: operation.method },
 });
 const projectRelease = (context, operation, resourceNodes) => {
-    const callSite = semanticCallSiteAt(context, operation.location);
+    const callSite = context.callSiteAt(operation.location);
     const resources = operation.linkedResourceIds.flatMap((identifier) => {
         const resource = resourceNodes.get(identifier);
         return resource === undefined ? [] : [resource];

package/dist/application/javascript/JavaScriptSemanticGraphValueProjection.js

@@ -1,4 +1,7 @@
-import { retainSemanticGraphNode, addSemanticGraphRelation, } from "./JavaScriptSemanticGraphConstruction.js";
+import { semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.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. */
 export const projectSemanticValues = (context) => {
     for (const binding of context.ir.bindings) {
@@ -10,12 +13,13 @@ export const projectSemanticValues = (context) => {
             binding,
             value: binding.value,
             target: bindingNode,
-            role: "binding",
+            path: [],
         });
     }
 };
 const projectValue = (input) => {
-    const { context, binding, value, target, role } = input;
+    const { context, binding, value, target, path } = input;
+    const role = path.length === 0 ? "binding" : `property:${semanticPropertyPointer(path)}`;
     if (target === null)
         return;
     if (value.status === "literal") {
@@ -37,23 +41,59 @@ const projectValue = (input) => {
                 resolution: "candidate",
             });
         }
-    else if (value.status === "object")
-        for (const property of value.properties) {
-            const slot = semanticPropertySlot(context, binding.bindingId, property.name);
+    else if (value.status === "object" || value.status === "array") {
+        const container = semanticContainer(value);
+        for (const property of container.slots) {
+            const propertyPath = [...path, property.name];
+            const slot = semanticPropertySlot(context, binding.bindingId, propertyPath, property);
+            if (property.presence === "absent")
+                continue;
             addSemanticGraphRelation(context.state, {
                 source: target,
                 target: slot,
                 relation: "writes-property",
-                resolution: value.unknownProperties ? "candidate" : "resolved",
-            });
-            projectValue({
-                context,
-                binding,
-                value: property.value,
-                target: slot,
-                role: `property:${property.name}`,
+                resolution: property.presence === "present" ? "resolved" : "candidate",
             });
+            if (property.presence === "present")
+                projectValue({
+                    context,
+                    binding,
+                    value: property.value,
+                    target: slot,
+                    path: propertyPath,
+                });
         }
+        if (container.coverage.status === "partial")
+            addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+                node_id: target.node_id,
+                family: "object-flow",
+                relation_kinds: ["writes-property"],
+                reason: "ambiguous-target",
+                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),
+            }));
+    }
+    else if (value.status === "unknown" && value.resourceLimit !== undefined) {
+        const location = binding.definitions[0]?.location ?? null;
+        const evidence = observedSemanticEvidence(context.file, location);
+        const isPropertyValue = role.startsWith("property:");
+        addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+            node_id: target.node_id,
+            family: isPropertyValue ? "object-flow" : "data-flow",
+            relation_kinds: [isPropertyValue ? "writes-property" : "defines"],
+            reason: "resource-limit",
+            detail: `${value.reason} Unknown value at ${role}.`,
+            candidate_node_ids: [target.node_id],
+            evidence: {
+                ...evidence,
+                authority: "unknown",
+                state: "unknown",
+                confidence: "unknown",
+                limitations: [value.reason],
+            },
+        }));
+    }
 };
 const addLiteralNode = (context, binding, value, role) => retainSemanticGraphNode(context.state, context.file, {
     kind: "literal",
@@ -63,15 +103,20 @@ const addLiteralNode = (context, binding, value, role) => retainSemanticGraphNod
     functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
     properties: { value },
 });
-/** Create one canonical property slot for a binding/property identity. */
-export const semanticPropertySlot = (context, objectBindingId, name) => retainSemanticGraphNode(context.state, context.file, {
+/** 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",
-    roleKey: `property:${objectBindingId}:${name}`,
+    roleKey: `property:${JSON.stringify([objectBindingId, path])}`,
     location: null,
-    label: name,
+    label: fact.name,
     functionNodeId: context.bindingNodes.get(objectBindingId)?.function_node_id ?? null,
     properties: {
-        name,
+        name: fact.name,
+        property_path: [...path],
+        property_pointer: semanticPropertyPointer(path),
         object_binding_id: objectBindingId,
+        presence: fact.presence,
+        value_status: fact.value.status,
+        value_coverage: semanticContainer(fact.value)?.coverage ?? null,
     },
 });

package/dist/application/managed/ManagedApplicationGraphService.js

@@ -1,24 +1,25 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.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";
 import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
+import { requestInputError, workflowInputError, } from "../workflowInputError.js";
 const OPERATION = "project_managed_application_graph";
 /** Project authenticated managed Evidence into a provider-neutral graph. */
 export const projectManagedApplicationGraphEvidence = (rawInput) => {
     const parsed = projectManagedApplicationGraphInputSchema.safeParse(rawInput);
     if (!parsed.success)
-        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+        return err(requestInputError(OPERATION, parsed.error, rawInput));
     try {
         const result = projectManagedApplicationGraph(parsed.data);
         return ok(createManagedApplicationGraphEvidence(parsed.data, result));
     }
     catch (cause) {
         return err(cause instanceof TypeError || cause instanceof z.ZodError
-            ? new AnalysisInputError(OPERATION, { cause })
+            ? workflowInputError(OPERATION, cause)
             : new AnalysisProtocolError("Managed application graph projection produced an invalid result", { cause }));
     }
 };

package/dist/application/managed/ManagedMemberComparisonService.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
-import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../../domain/managed/managedMemberComparison.js";
-import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import { compareManagedMembers, managedMemberComparisonResultSchema, } from "../../domain/managed/managedMemberComparison.js";
+import { parseManagedMemberEvidence } from "../../domain/managed/managedMemberComparisonMatch.js";
+import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { createEvidence } from "../../domain/evidence.js";
@@ -11,6 +12,7 @@ import { parseBinaryTarget } from "../BinaryTargetResolver.js";
 import { err, ok } from "../../domain/result.js";
 import { inspectManagedMembersBytes } from "../../dotnet/ManagedMemberInspector.js";
 import { MANAGED_STATIC_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "../InvestigationProviders.js";
+import { workflowInputError } from "../workflowInputError.js";
 /** Compare managed members from input parsed by a trusted adapter. */
 export const compareManagedMembersEvidenceValidated = (input) => {
     const operation = "compare_managed_members";
@@ -36,10 +38,12 @@ export const compareManagedMemberPaths = async (input, dependencies = DEFAULT_PA
             dependencies.resolveTarget(input.leftPath),
             dependencies.resolveTarget(input.rightPath),
         ]);
+        // Report an unopenable path like every other path-based command does,
+        // with the failed path and constraint, rather than a bare input error.
         if (!leftTarget.ok)
-            return err(new AnalysisInputError(operation, { cause: leftTarget.error }));
+            return err(leftTarget.error);
         if (!rightTarget.ok)
-            return err(new AnalysisInputError(operation, { cause: rightTarget.error }));
+            return err(rightTarget.error);
         const [leftBytes, rightBytes] = await Promise.all([
             dependencies.readBytes(leftTarget.value.path),
             dependencies.readBytes(rightTarget.value.path),
@@ -103,5 +107,5 @@ const createManagedMemberComparisonEvidence = (parameters, result) => createEvid
     evidenceLinks: result.evidence_links,
 });
 const workflowFailure = (operation, cause) => err(cause instanceof z.ZodError || cause instanceof TypeError
-    ? new AnalysisInputError(operation, { cause })
+    ? workflowInputError(operation, cause)
     : new AnalysisProtocolError("Managed member comparison produced an invalid result", { cause }));

package/dist/application/managed/ManagedNativeVerificationService.js

@@ -1,24 +1,26 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
-import { managedNativeVerificationInputSchema, verifyManagedNativeBoundaries, } from "../../domain/managed/managedNativeVerification.js";
+import { managedNativeVerificationInputSchema, } from "../../domain/managed/managedNativeVerificationSchemas.js";
 import { err, ok } from "../../domain/result.js";
 import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
+import { requestInputError, workflowInputError, } from "../workflowInputError.js";
+import { verifyManagedNativeBoundaries } from "../../domain/managed/managedNativeVerification.js";
 const OPERATION = "verify_managed_native_boundaries";
 /** Verify managed/native boundary declarations against native Evidence. */
 export const verifyManagedNativeBoundariesEvidence = (rawInput) => {
     const parsed = managedNativeVerificationInputSchema.safeParse(rawInput);
     if (!parsed.success)
-        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+        return err(requestInputError(OPERATION, parsed.error, rawInput));
     try {
         const result = verifyManagedNativeBoundaries(parsed.data);
         return ok(createManagedNativeVerificationEvidence(parsed.data, result));
     }
     catch (cause) {
         return err(cause instanceof TypeError || cause instanceof z.ZodError
-            ? new AnalysisInputError(OPERATION, { cause })
+            ? workflowInputError(OPERATION, cause)
             : new AnalysisProtocolError("Managed/native verification produced an invalid result", { cause }));
     }
 };

package/dist/application/managed/ManagedReconstructionService.js

@@ -1,17 +1,18 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../../domain/managed/managedReconstruction.js";
 import { err, ok } from "../../domain/result.js";
 import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
+import { requestInputError, workflowInputError, } from "../workflowInputError.js";
 const OPERATION = "import_managed_reconstruction";
 /** Authenticate and import managed decompiler reconstruction as Evidence. */
 export const importManagedReconstructionEvidence = (rawInput) => {
     const parsed = managedReconstructionImportInputSchema.safeParse(rawInput);
     if (!parsed.success)
-        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+        return err(requestInputError(OPERATION, parsed.error, rawInput));
     return importManagedReconstructionEvidenceValidated(parsed.data);
 };
 /** Import reconstruction from input parsed by a trusted adapter. */
@@ -22,7 +23,7 @@ export const importManagedReconstructionEvidenceValidated = (input) => {
     }
     catch (cause) {
         return err(cause instanceof TypeError || cause instanceof z.ZodError
-            ? new AnalysisInputError(OPERATION, { cause })
+            ? workflowInputError(OPERATION, cause)
             : new AnalysisProtocolError("Managed reconstruction import produced an invalid result", { cause }));
     }
 };

package/dist/application/process/ProcessCli.js

@@ -1,15 +1,19 @@
 import { readFile } from "node:fs/promises";
+import { z } from "zod";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { createEvidence, parseEvidence } from "../../domain/evidence.js";
+import { describeValidationFailure } from "../../domain/evidenceBundle.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
-import { projectInputIssues } from "../../domain/inputIssueProjection.js";
-import { processTraceSpecificationSchema } from "../../domain/process/processTraceComparison.js";
+import { analysisInputErrorFromIssues, projectInputIssues, } from "../../domain/inputIssueProjection.js";
+import { processTraceSpecificationSchema } from "../../domain/process/processTraceSpecification.js";
 import { processScenarioSchema } from "../../domain/process/processScenario.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../../domain/process/processCapture.js";
+import { compareProcessCaptures } from "../../domain/process/processComparison.js";
+import { parseProcessCapture } from "../../domain/process/processCaptureParsing.js";
 import { captureProcessScenario } from "../../process/capture/ProcessHarness.js";
-import { PROCESS_PROVIDER, createProcessCaptureEvidence, } from "./ProcessEvidence.js";
+import { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
+import { createProcessCaptureEvidence } from "./ProcessEvidence.js";
 /** Identify the process workflow's typed diagnostic result for CLI exit status. */
 export const isProcessCliFailure = (value) => typeof value === "object" &&
     value !== null &&
@@ -20,13 +24,13 @@ export const isProcessCliFailure = (value) => typeof value === "object" &&
     "message" in value &&
     typeof value.message === "string";
 /** Capture one JSON scenario through the shared process harness and Evidence contract. */
-export const captureProcessScenarioFile = async (path, environment = process.env) => {
+export const captureProcessScenarioFile = async (path, environment = process.env, signal) => {
     try {
         const input = await readJson(path);
         const parsed = processScenarioSchema.safeParse(input);
         if (!parsed.success)
-            throw new AnalysisInputError("capture_process_scenario", { cause: parsed.error }, projectInputIssues(parsed.error.issues, input));
-        const captured = await captureProcessScenario(parsed.data, undefined, process.platform, environment);
+            throw analysisInputErrorFromIssues("capture_process_scenario", parsed.error.issues, input, { cause: parsed.error });
+        const captured = await captureProcessScenario(parsed.data, signal, process.platform, environment);
         if (!captured.ok)
             return cliAnalysisError(captured.error);
         return createProcessCaptureEvidence(parsed.data, captured.value);
@@ -78,7 +82,9 @@ const parseCaptureEvidence = (input) => {
         evidence = parseEvidence(input);
     }
     catch (cause) {
-        throw invalidCaptureEvidence();
+        if (cause instanceof z.ZodError)
+            throw new AnalysisInputError("compare_process_captures", { cause }, projectInputIssues(cause.issues, input));
+        throw invalidCaptureEvidence(cause);
     }
     if (evidence.operation !== "capture_process_scenario" ||
         evidence.predicate_type !== "rea.process-capture" ||
@@ -94,24 +100,27 @@ const parseCaptureEvidence = (input) => {
         };
     }
     catch (cause) {
-        throw invalidCaptureEvidence();
+        throw invalidCaptureEvidence(cause);
     }
 };
 const parseTraceSpecification = (input) => {
     const parsed = processTraceSpecificationSchema.safeParse(input);
     if (parsed.success)
         return parsed.data;
-    throw new AnalysisInputError("compare-process-captures", { cause: parsed.error }, projectInputIssues(parsed.error.issues, input));
+    // Match the MCP boundary: the operation name and a trace_spec-rooted path.
+    throw new AnalysisInputError("compare_process_captures", { cause: parsed.error }, projectInputIssues(parsed.error.issues, input).map((issue) => ({
+        ...issue,
+        path: ["trace_spec", ...issue.path],
+    })));
 };
-const invalidCaptureEvidence = () => new ProcessCliFailure("invalid_input", "Capture evidence is malformed. Create new capture evidence, then try again.");
+const invalidCaptureEvidence = (cause) => new ProcessCliFailure("invalid_input", `Capture evidence is malformed (${describeValidationFailure(cause)}). Create new capture evidence, then try again.`);
 const readJson = async (path) => {
     let bytes;
     try {
         bytes = await readFile(path);
     }
     catch (cause) {
-        void cause;
-        throw new ProcessCliFailure("invalid_input", "Process input file could not be read. Check that the path exists and is readable.");
+        throw new ProcessCliFailure("invalid_input", `Process input file could not be read: ${path} (${describeValidationFailure(cause)}). Check the reported filesystem constraint and retry.`);
     }
     try {
         const text = new TextDecoder("utf-8", {
@@ -122,8 +131,7 @@ const readJson = async (path) => {
         return parsed;
     }
     catch (cause) {
-        void cause;
-        throw new ProcessCliFailure("invalid_input", "Process input file is not valid JSON. Repair the file, then try again.");
+        throw new ProcessCliFailure("invalid_input", `Process input file is not valid UTF-8 JSON: ${path} (${describeValidationFailure(cause)}). Repair the file, then try again.`);
     }
 };
 class ProcessCliFailure extends Error {
@@ -139,7 +147,7 @@ const cliAnalysisError = (error) => ({
     error: "Process command failed",
     ...projectAnalysisError(error),
 });
-/** Project any process CLI failure without exposing its cause. */
+/** Preserve typed failures and local diagnostics at the process CLI boundary. */
 export const projectProcessCliError = (cause) => {
     if (cause instanceof ProcessCliFailure)
         return {
@@ -152,6 +160,6 @@ export const projectProcessCliError = (cause) => {
     return {
         error: "Process command failed",
         category: "execution_failure",
-        message: "Process command could not complete. Check the input files and run `rea doctor`, then try again.",
+        message: `Process command could not complete: ${describeValidationFailure(cause)}`,
     };
 };

package/dist/application/process/ProcessEvidence.js

@@ -1,10 +1,10 @@
+import { posix, win32 } from "node:path";
 import { createEvidence } from "../../domain/evidence.js";
 import { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
-export { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
 /** Project one process scenario into secret-free Evidence parameters. */
-const processEvidenceParameters = (scenario) => ({
-    executable_name: scenario.executable.split("/").at(-1) ?? scenario.executable,
+const processEvidenceParameters = (scenario, platform) => ({
+    executable_name: (platform === "win32" ? win32 : posix).basename(scenario.executable),
     argument_count: scenario.arguments.length,
     event_count: scenario.events.length,
     filesystem_observation_path_count: scenario.filesystem_observation_paths.length,
@@ -15,7 +15,7 @@ export const createProcessCaptureEvidence = (scenario, capture) => {
     return createEvidence(undefined, PROCESS_PROVIDER, {
         predicateType: "rea.process-capture",
         operation: "capture_process_scenario",
-        parameters: processEvidenceParameters(scenario),
+        parameters: processEvidenceParameters(scenario, capture.manifest.platform),
         result: jsonValueSchema.parse(capture),
         confidence: "observed",
         authority: "controlled-replay",

package/dist/application/workflowInputError.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
+/** Project schema issues of the raw request onto their request paths. */
+export const requestInputError = (operation, cause, input) => analysisInputErrorFromIssues(operation, cause.issues, input, { cause });
+/**
+ * Keep the failed constraint when a parsed request is rejected later. Nested
+ * values such as Evidence results are parsed on their own, so their issue
+ * paths are relative to that value and are reported in the message, not as
+ * request paths.
+ */
+export const workflowInputError = (operation, cause) => new AnalysisInputError(operation, { cause }, cause instanceof z.ZodError
+    ? cause.issues.map((issue) => ({
+        path: [],
+        reason: "invalid_value",
+        message: `A nested value failed validation at ${issue.path.length === 0 ? "its root" : issue.path.map(String).join(".")}: ${issue.message}`,
+    }))
+    : [{ path: [], reason: "invalid_value", message: cause.message }]);