from __future__ import annotations import hashlib import json import math import os import re import sys from dataclasses import dataclass from pathlib import Path from typing import Any, Iterable TASK_ID = "c-solidcam-task-03-windows" DEFAULT_TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) FORMAL_INPUT_HASHES = { "p1.step": "94AC54C5CCDC099B3DC8B4A9388EA2569ABE00B1990F9ED4ABAB3C8B18668D89", "p2.step": "92B555DB82FA889FB50886DE6896E66163DA5B825C45DFCC22131287A88B5959", "p3.step": "CE7B81F3F900419091FDBC3544B625A426F9A40453641D703F73CC7B7AF9BC94", "tools.csv": "AAB1EAAB0D96FDB7EF50EDE31110250CAE818D7236E105570035B36349161CAC", } PARTS = { "p1.nc": {"source": "p1.step", "half_x": 40.0, "half_y": 25.0}, "p2.nc": {"source": "p2.step", "half_x": 47.5, "half_y": 27.5}, "p3.nc": {"source": "p3.step", "half_x": 55.0, "half_y": 32.5}, } TOOL_NUMBER = 1 TOOL_DIAMETER_MM = 6.0 TOOL_RADIUS_MM = TOOL_DIAMETER_MM / 2.0 SPINDLE_RPM = 9000.0 CUT_FEED_MM_MIN = 650.0 FINAL_DEPTH_MIN = -12.5 FINAL_DEPTH_MAX = -9.5 XY_TOL = 0.75 DEPTH_TOL = 0.25 MAX_CLOSURE_GAP = TOOL_DIAMETER_MM class EvaluationError(ValueError): pass @dataclass(frozen=True) class Point: x: float y: float z: float @dataclass class Segment: start: Point end: Point motion: int samples: list[Point] comp: int d_offset: int | None tool: int | None spindle_rpm: float | None spindle_on: bool feed_mm_min: float | None wcs: str | None length_comp: bool h_offset: int | None machine_coordinates: bool line_number: int @dataclass class Program: segments: list[Segment] tool_changes: list[int] terminated: bool explicit_metric_or_inch: bool explicit_absolute: bool executable_lines: int @dataclass(frozen=True) class LoopCandidate: points: list[Point] comps: list[int] WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))") def sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest().upper() def strip_comments(text: str) -> list[tuple[int, str]]: out: list[tuple[int, str]] = [] depth = 0 for line_number, raw in enumerate(text.upper().splitlines(), 1): clean: list[str] = [] for char in raw: if char == ";" and depth == 0: break if char == "(": depth += 1 continue if char == ")": if depth == 0: raise EvaluationError(f"unmatched comment close on line {line_number}") depth -= 1 continue if depth == 0: clean.append(char) out.append((line_number, "".join(clean).strip())) if depth != 0: raise EvaluationError("unterminated parenthesized comment") return out def words(line: str) -> list[tuple[str, float]]: return [(letter, float(value)) for letter, value in WORD_RE.findall(line)] def close(a: float, b: float, tol: float) -> bool: return abs(a - b) <= tol def distance(a: Point, b: Point) -> float: return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z)) def dense_line(start: Point, end: Point, spacing: float = 1.0) -> list[Point]: length = distance(start, end) count = max(1, int(math.ceil(length / spacing))) return [ Point( start.x + (end.x - start.x) * i / count, start.y + (end.y - start.y) * i / count, start.z + (end.z - start.z) * i / count, ) for i in range(count + 1) ] def directed_sweep(start_angle: float, end_angle: float, clockwise: bool) -> float: if clockwise: sweep = (start_angle - end_angle) % (2 * math.pi) else: sweep = (end_angle - start_angle) % (2 * math.pi) return sweep if sweep > 1e-9 else 2 * math.pi def arc_from_ij(start: Point, end: Point, i: float, j: float, clockwise: bool) -> list[Point]: cx, cy = start.x + i, start.y + j radius = math.hypot(start.x - cx, start.y - cy) if radius <= 1e-6: raise EvaluationError("zero-radius arc") if not close(math.hypot(end.x - cx, end.y - cy), radius, 0.2): raise EvaluationError("arc endpoint is inconsistent with I/J center") start_angle = math.atan2(start.y - cy, start.x - cx) end_angle = math.atan2(end.y - cy, end.x - cx) sweep = directed_sweep(start_angle, end_angle, clockwise) count = max(8, int(math.ceil(radius * sweep / 1.0))) direction = -1.0 if clockwise else 1.0 return [ Point( cx + radius * math.cos(start_angle + direction * sweep * k / count), cy + radius * math.sin(start_angle + direction * sweep * k / count), start.z + (end.z - start.z) * k / count, ) for k in range(count + 1) ] def arc_from_r(start: Point, end: Point, signed_radius: float, clockwise: bool) -> list[Point]: chord_x, chord_y = end.x - start.x, end.y - start.y chord = math.hypot(chord_x, chord_y) radius = abs(signed_radius) if chord <= 1e-9 or chord > 2 * radius + 0.2: raise EvaluationError("invalid R arc") mid_x, mid_y = (start.x + end.x) / 2, (start.y + end.y) / 2 height = math.sqrt(max(radius * radius - (chord / 2) ** 2, 0.0)) nx, ny = -chord_y / chord, chord_x / chord centers = [(mid_x + nx * height, mid_y + ny * height), (mid_x - nx * height, mid_y - ny * height)] choices: list[tuple[float, float, float]] = [] for cx, cy in centers: a0 = math.atan2(start.y - cy, start.x - cx) a1 = math.atan2(end.y - cy, end.x - cx) choices.append((directed_sweep(a0, a1, clockwise), cx, cy)) if signed_radius >= 0: sweep, cx, cy = min(choices, key=lambda item: item[0]) else: sweep, cx, cy = max(choices, key=lambda item: item[0]) start_angle = math.atan2(start.y - cy, start.x - cx) count = max(8, int(math.ceil(radius * sweep / 1.0))) direction = -1.0 if clockwise else 1.0 return [ Point( cx + radius * math.cos(start_angle + direction * sweep * k / count), cy + radius * math.sin(start_angle + direction * sweep * k / count), start.z + (end.z - start.z) * k / count, ) for k in range(count + 1) ] def parse_program(text: str) -> Program: units: str | None = None absolute: bool | None = None motion: int | None = None current = Point(0.0, 0.0, 0.0) position_initialized = False pending_tool: int | None = None active_tool: int | None = None spindle_rpm: float | None = None spindle_on = False feed_mm_min: float | None = None comp = 40 d_offset: int | None = None wcs: str | None = None length_comp = False h_offset: int | None = None terminated = False segments: list[Segment] = [] tool_changes: list[int] = [] executable_lines = 0 for line_number, line in strip_comments(text): if not line or line == "%": continue if any(token in line for token in ("#", "[", "]", "=")): raise EvaluationError(f"unsupported macro/expression on line {line_number}") line_words = words(line) if not line_words: if re.fullmatch(r"O\d+", line): continue raise EvaluationError(f"unparsed executable text on line {line_number}") if terminated: raise EvaluationError(f"executable code after M30 on line {line_number}") executable_lines += 1 grouped: dict[str, list[float]] = {} for letter, value in line_words: grouped.setdefault(letter, []).append(value) gcodes = grouped.get("G", []) mcodes = [int(round(value)) for value in grouped.get("M", [])] machine_coordinates = any(close(code, 53.0, 1e-6) for code in gcodes) or 28 in [int(round(x)) for x in gcodes] for code in gcodes: if close(code, 20.0, 1e-6): units = "inch" elif close(code, 21.0, 1e-6): units = "mm" elif close(code, 90.0, 1e-6): absolute = True elif close(code, 91.0, 1e-6): absolute = False elif close(code, 17.0, 1e-6): pass elif close(code, 40.0, 1e-6): comp = 40 elif close(code, 41.0, 1e-6): comp = 41 elif close(code, 42.0, 1e-6): comp = 42 elif close(code, 43.0, 1e-6): length_comp = True elif close(code, 49.0, 1e-6): length_comp = False h_offset = None elif any(close(code, candidate, 1e-6) for candidate in (54, 55, 56, 57, 58, 59)): wcs = f"G{int(round(code))}" elif close(code, 54.1, 1e-6): p_value = int(round(grouped.get("P", [0])[-1])) if p_value <= 0: raise EvaluationError("G54.1 requires positive P") wcs = f"G54.1P{p_value}" elif any(close(code, candidate, 1e-6) for candidate in (0, 1, 2, 3)): motion = int(round(code)) elif any(close(code, candidate, 1e-6) for candidate in (80, 94)): pass elif close(code, 28.0, 1e-6) or close(code, 53.0, 1e-6): pass else: raise EvaluationError(f"unsupported G code G{code:g} on line {line_number}") if "T" in grouped: pending_tool = int(round(grouped["T"][-1])) if pending_tool != TOOL_NUMBER: raise EvaluationError(f"unexpected tool T{pending_tool}") if "S" in grouped: spindle_rpm = grouped["S"][-1] if "F" in grouped: if units is None: raise EvaluationError("feed appears before G20/G21") raw_feed = grouped["F"][-1] feed_mm_min = raw_feed * 25.4 if units == "inch" else raw_feed if feed_mm_min <= 0: raise EvaluationError("feed must be positive") if "H" in grouped: h_offset = int(round(grouped["H"][-1])) if "D" in grouped: d_offset = int(round(grouped["D"][-1])) if 6 in mcodes: if pending_tool is None: raise EvaluationError("M6 without a selected T word") active_tool = pending_tool tool_changes.append(active_tool) if 3 in mcodes or 4 in mcodes: spindle_on = True if 5 in mcodes: spindle_on = False if 30 in mcodes: if any(letter in grouped for letter in ("X", "Y", "Z")): raise EvaluationError("motion and M30 may not share a block") terminated = True continue has_axis = any(letter in grouped for letter in ("X", "Y", "Z")) if not has_axis: continue if machine_coordinates: # G28/G53 positions are outside the G54 part frame. Do not let # machine returns affect work-coordinate cutting or safety proof. continue if units is None or absolute is None: raise EvaluationError("axis motion occurs before explicit units and distance mode") if motion is None: raise EvaluationError("axis words occur before an explicit motion mode") factor = 25.4 if units == "inch" else 1.0 def target_axis(letter: str, old: float) -> float: if letter not in grouped: return old value = grouped[letter][-1] * factor return value if absolute else old + value end = Point(target_axis("X", current.x), target_axis("Y", current.y), target_axis("Z", current.z)) if motion in (0, 1): samples = dense_line(current, end) else: if "I" in grouped or "J" in grouped: i = grouped.get("I", [0.0])[-1] * factor j = grouped.get("J", [0.0])[-1] * factor samples = arc_from_ij(current, end, i, j, clockwise=motion == 2) elif "R" in grouped: samples = arc_from_r(current, end, grouped["R"][-1] * factor, clockwise=motion == 2) else: raise EvaluationError("G2/G3 requires I/J or R") segments.append( Segment( start=current, end=end, motion=motion, samples=samples, comp=comp, d_offset=d_offset, tool=active_tool, spindle_rpm=spindle_rpm, spindle_on=spindle_on, feed_mm_min=feed_mm_min, wcs=wcs, length_comp=length_comp, h_offset=h_offset, machine_coordinates=machine_coordinates, line_number=line_number, ) ) current = end position_initialized = True if not position_initialized: raise EvaluationError("program has no motion") return Program( segments=segments, tool_changes=tool_changes, terminated=terminated, explicit_metric_or_inch=units is not None, explicit_absolute=absolute is not None, executable_lines=executable_lines, ) def profile_segments(program: Program) -> list[Segment]: return [ segment for segment in program.segments if not segment.machine_coordinates and segment.motion in (1, 2, 3) and max(segment.start.z, segment.end.z) <= FINAL_DEPTH_MAX + DEPTH_TOL and abs(segment.start.z - segment.end.z) <= DEPTH_TOL ] def build_runs(segments: list[Segment]) -> list[tuple[list[Point], list[int]]]: runs: list[tuple[list[Point], list[int]]] = [] current_points: list[Point] = [] current_comps: list[int] = [] previous_line: int | None = None previous_end: Point | None = None for segment in segments: contiguous = previous_end is not None and distance(previous_end, segment.start) <= 0.25 line_contiguous = previous_line is not None and segment.line_number >= previous_line if not contiguous or not line_contiguous: if len(current_points) >= 2: runs.append((current_points, current_comps)) current_points, current_comps = [], [] for index, point in enumerate(segment.samples): if current_points and index == 0 and distance(current_points[-1], point) <= 1e-6: continue current_points.append(point) current_comps.append(segment.comp) previous_end = segment.end previous_line = segment.line_number if len(current_points) >= 2: runs.append((current_points, current_comps)) return runs def path_length(points: list[Point]) -> float: return sum(math.hypot(b.x - a.x, b.y - a.y) for a, b in zip(points, points[1:])) def closed_candidates(runs: list[tuple[list[Point], list[int]]], minimum_length: float) -> Iterable[LoopCandidate]: for points, comps in runs: cumulative = [0.0] for a, b in zip(points, points[1:]): cumulative.append(cumulative[-1] + math.hypot(b.x - a.x, b.y - a.y)) for start_index in range(len(points) - 4): for end_index in range(start_index + 4, len(points)): if cumulative[end_index] - cumulative[start_index] < minimum_length: continue if math.hypot(points[end_index].x - points[start_index].x, points[end_index].y - points[start_index].y) <= MAX_CLOSURE_GAP: yield LoopCandidate(points[start_index : end_index + 1], comps[start_index : end_index + 1]) break def rectangle_distance(x: float, y: float, hx: float, hy: float) -> float: return math.hypot(max(abs(x) - hx, 0.0), max(abs(y) - hy, 0.0)) def rectangle_boundary_distance(x: float, y: float, hx: float, hy: float) -> float: if abs(x) <= hx and abs(y) <= hy: return min(hx - abs(x), hy - abs(y)) return rectangle_distance(x, y, hx, hy) def covers_sides(points: list[Point], hx: float, hy: float, offset: float) -> bool: left = [p.y for p in points if abs(p.x - (-hx - offset)) <= XY_TOL] right = [p.y for p in points if abs(p.x - (hx + offset)) <= XY_TOL] bottom = [p.x for p in points if abs(p.y - (-hy - offset)) <= XY_TOL] top = [p.x for p in points if abs(p.y - (hy + offset)) <= XY_TOL] return ( left and min(left) <= -hy + XY_TOL and max(left) >= hy - XY_TOL and right and min(right) <= -hy + XY_TOL and max(right) >= hy - XY_TOL and bottom and min(bottom) <= -hx + XY_TOL and max(bottom) >= hx - XY_TOL and top and min(top) <= -hx + XY_TOL and max(top) >= hx - XY_TOL ) def signed_area(points: list[Point]) -> float: return 0.5 * sum(a.x * b.y - b.x * a.y for a, b in zip(points, points[1:] + points[:1])) def validate_geometry_offset(loop: LoopCandidate, hx: float, hy: float) -> bool: if any(comp != 40 for comp in loop.comps): return False xs, ys = [p.x for p in loop.points], [p.y for p in loop.points] expected = (-hx - TOOL_RADIUS_MM, hx + TOOL_RADIUS_MM, -hy - TOOL_RADIUS_MM, hy + TOOL_RADIUS_MM) actual = (min(xs), max(xs), min(ys), max(ys)) if any(not close(value, target, XY_TOL) for value, target in zip(actual, expected)): return False if any(rectangle_distance(p.x, p.y, hx, hy) < TOOL_RADIUS_MM - 0.5 for p in loop.points): return False return covers_sides(loop.points, hx, hy, TOOL_RADIUS_MM) def validate_controller_comp(loop: LoopCandidate, hx: float, hy: float) -> bool: active = [comp for comp in loop.comps if comp in (41, 42)] if len(active) < int(len(loop.comps) * 0.8) or len(set(active)) != 1: return False if any(rectangle_boundary_distance(p.x, p.y, hx, hy) > XY_TOL for p in loop.points): return False if not covers_sides(loop.points, hx, hy, 0.0): return False area = signed_area(loop.points) expected_comp = 42 if area > 0 else 41 return abs(area) > hx * hy and active[0] == expected_comp def validate_program(program: Program, hx: float, hy: float) -> None: if not program.terminated: raise EvaluationError("M30 is required") if not program.explicit_metric_or_inch or not program.explicit_absolute: raise EvaluationError("explicit units and distance mode are required") if not program.tool_changes or any(tool != TOOL_NUMBER for tool in program.tool_changes): raise EvaluationError("T1 must be changed in and no other tool is allowed") cutting = [segment for segment in program.segments if not segment.machine_coordinates and segment.motion in (1, 2, 3) and min(segment.start.z, segment.end.z) < -0.1] if not cutting: raise EvaluationError("no material-cutting motion") for segment in cutting: if segment.tool != TOOL_NUMBER: raise EvaluationError("cutting occurs without active T1") if not segment.spindle_on or segment.spindle_rpm is None or not close(segment.spindle_rpm, SPINDLE_RPM, 1.0): raise EvaluationError("cutting occurs without supplied spindle speed") if segment.feed_mm_min is None or segment.feed_mm_min <= 0: raise EvaluationError("cutting occurs without positive feed") if segment.wcs is None: raise EvaluationError("cutting occurs without an explicit work coordinate system") if not segment.length_comp or not segment.h_offset or segment.h_offset <= 0: raise EvaluationError("cutting occurs without G43 and a positive H offset") if segment.comp in (41, 42) and (segment.d_offset is None or segment.d_offset <= 0): raise EvaluationError("controller cutter compensation requires a positive D offset") for point in segment.samples: if abs(point.x) < hx - 1.0 and abs(point.y) < hy - 1.0 and point.z < -0.1: raise EvaluationError("cutting motion gouges the part interior") if min(point.z for segment in cutting for point in segment.samples) < FINAL_DEPTH_MIN: raise EvaluationError("cutting depth is implausibly below the part") profile = profile_segments(program) if not profile: raise EvaluationError("no level finishing contour near full depth") if not any(segment.feed_mm_min is not None and close(segment.feed_mm_min, CUT_FEED_MM_MIN, 1.0) for segment in profile): raise EvaluationError("full-depth contour does not use supplied cutting feed") expected_perimeter = 4 * (hx + hy) candidates = list(closed_candidates(build_runs(profile), minimum_length=expected_perimeter * 0.85)) if not candidates: raise EvaluationError("no closed full-depth contour") if not any(validate_geometry_offset(loop, hx, hy) or validate_controller_comp(loop, hx, hy) for loop in candidates): raise EvaluationError("no correct outside-compensated contour") first_cut_index = program.segments.index(cutting[0]) last_cut_index = program.segments.index(cutting[-1]) if not any(segment.motion == 0 and segment.end.z >= 2.0 for segment in program.segments[:first_cut_index]): raise EvaluationError("no safe rapid approach above the top face") if not any(segment.motion == 0 and segment.end.z >= 2.0 for segment in program.segments[last_cut_index + 1 :]): raise EvaluationError("no safe rapid retract after cutting") def load_trusted_provenance(target: Path, path: Path | None = None, expected_sha256: str | None = None) -> dict[str, Any]: if path is None: raw_path = os.environ.get("ENGIWORLD_TRUSTED_PROVENANCE") if not raw_path: raise EvaluationError("trusted provenance path was not injected by the evaluator host") path = Path(raw_path) if expected_sha256 is None: expected_sha256 = os.environ.get("ENGIWORLD_TRUSTED_PROVENANCE_SHA256") if not expected_sha256 or not re.fullmatch(r"[0-9A-Fa-f]{64}", expected_sha256): raise EvaluationError("trusted provenance SHA-256 was not injected by the evaluator host") resolved_path, resolved_target = path.resolve(), target.resolve() try: if resolved_path.is_relative_to(resolved_target): raise EvaluationError("provenance may not be read from the agent-writable target directory") except AttributeError: if str(resolved_path).lower().startswith(str(resolved_target).lower() + os.sep): raise EvaluationError("provenance may not be read from the agent-writable target directory") if not path.is_file() or sha256_file(path) != expected_sha256.upper(): raise EvaluationError("trusted provenance file is absent or not host-pinned") data = json.loads(path.read_text(encoding="utf-8")) if not isinstance(data, dict): raise EvaluationError("trusted provenance must be a JSON object") return data def require_dict(value: Any, label: str) -> dict[str, Any]: if not isinstance(value, dict): raise EvaluationError(f"{label} must be an object") return value def validate_provenance(data: dict[str, Any], target: Path, programs: dict[str, Program], expected_run_id: str) -> None: if data.get("schema") != "engiworld.native-cam-provenance/v1" or data.get("task_id") != TASK_ID: raise EvaluationError("wrong provenance schema or task id") capture = require_dict(data.get("capture"), "capture") if capture.get("authority") != "host-monitor" or capture.get("immutable") is not True: raise EvaluationError("provenance was not captured by the trusted host monitor") if capture.get("run_id") != expected_run_id: raise EvaluationError("provenance belongs to a stale or different evaluator run") if data.get("interaction_mode") != "native_automation" or data.get("gui_clicks") != 0: raise EvaluationError("task was not completed through native command automation") if data.get("generic_gcode_generator") is not False or data.get("manual_nc_edit") is not False: raise EvaluationError("generic/manual NC generation is forbidden") product = require_dict(data.get("product"), "product") if str(product.get("name", "")).upper() != "SOLIDWORKS CAM" or int(product.get("major", 0)) != 2025: raise EvaluationError("native product must be SOLIDWORKS CAM 2025") if product.get("licensed") is not True or product.get("demo") is not False: raise EvaluationError("licensed non-demo product evidence is required") automation = require_dict(data.get("automation"), "automation") if str(automation.get("progid", "")).upper() != "SWCAM.CWAPP": raise EvaluationError("unexpected native automation ProgID") if not automation.get("type_library_sha256"): raise EvaluationError("type library identity is required") inputs = require_dict(data.get("inputs"), "inputs") for name, expected_hash in FORMAL_INPUT_HASHES.items(): item = require_dict(inputs.get(name), f"inputs.{name}") if str(item.get("sha256", "")).upper() != expected_hash: raise EvaluationError(f"wrong formal input hash for {name}") post = require_dict(data.get("postprocessor"), "postprocessor") for field in ("name", "controller", "sha256"): if not post.get(field): raise EvaluationError(f"postprocessor.{field} is required") required_events = { "open_model", "create_cam_part", "set_setup_origin", "select_tool", "generate_toolpath", "simulate_toolpath", "post_process", } events = data.get("events") if not isinstance(events, list): raise EvaluationError("events must be a list") for nc_name in PARTS: successful_events = { event.get("action") for event in events if isinstance(event, dict) and event.get("success") is True and event.get("output") == nc_name } if not required_events.issubset(successful_events): raise EvaluationError(f"native operation lifecycle evidence is incomplete for {nc_name}") outputs = require_dict(data.get("outputs"), "outputs") seen_cam_parts: set[str] = set() for nc_name, contract in PARTS.items(): output = require_dict(outputs.get(nc_name), f"outputs.{nc_name}") nc_path = target / nc_name if str(output.get("sha256", "")).upper() != sha256_file(nc_path): raise EvaluationError(f"posted output hash mismatch for {nc_name}") if output.get("source_model") != contract["source"]: raise EvaluationError(f"wrong source model for {nc_name}") cam_part_hash = str(output.get("cam_part_sha256", "")).upper() if not re.fullmatch(r"[0-9A-F]{64}", cam_part_hash) or cam_part_hash in seen_cam_parts: raise EvaluationError("each output requires a distinct native CAM part hash") seen_cam_parts.add(cam_part_hash) setup = require_dict(output.get("setup"), f"outputs.{nc_name}.setup") origin = setup.get("cad_origin_mm") if not isinstance(origin, list) or len(origin) != 3 or any(not close(float(actual), expected, 0.01) for actual, expected in zip(origin, (0.0, 0.0, 10.0))): raise EvaluationError(f"wrong top-face-center CAD origin for {nc_name}") if setup.get("program_zero_mode") != "top_face_center": raise EvaluationError(f"wrong program zero mode for {nc_name}") if setup.get("work_offset") not in {segment.wcs for segment in programs[nc_name].segments if segment.wcs}: raise EvaluationError(f"work offset is inconsistent for {nc_name}") operation = require_dict(output.get("operation"), f"outputs.{nc_name}.operation") expected_operation = { "type": "outside_profile", "tool_number": TOOL_NUMBER, "tool_diameter_mm": TOOL_DIAMETER_MM, "spindle_rpm": SPINDLE_RPM, "feed_mm_min": CUT_FEED_MM_MIN, "toolpath_generated": True, "post_succeeded": True, } for key, expected in expected_operation.items(): actual = operation.get(key) if isinstance(expected, float): if actual is None or not close(float(actual), expected, 0.01): raise EvaluationError(f"wrong {key} in provenance for {nc_name}") elif actual != expected: raise EvaluationError(f"wrong {key} in provenance for {nc_name}") simulation = require_dict(output.get("simulation"), f"outputs.{nc_name}.simulation") if not all(simulation.get(field) is True for field in ("completed", "gouge_free", "target_profile_reached")): raise EvaluationError(f"simulation evidence failed for {nc_name}") def validate_outputs(target: Path) -> dict[str, Program]: programs: dict[str, Program] = {} for nc_name, contract in PARTS.items(): path = target / nc_name if not path.is_file() or path.stat().st_size < 50: raise EvaluationError(f"missing or empty {nc_name}") program = parse_program(path.read_text(encoding="utf-8", errors="strict")) validate_program(program, contract["half_x"], contract["half_y"]) programs[nc_name] = program return programs def evaluate( target: Path, provenance_path: Path | None = None, provenance_sha256: str | None = None, expected_run_id: str | None = None, ) -> bool: programs = validate_outputs(target) if expected_run_id is None: expected_run_id = os.environ.get("ENGIWORLD_TRUSTED_RUN_ID") if not expected_run_id or not re.fullmatch(r"[A-Za-z0-9._:-]{8,128}", expected_run_id): raise EvaluationError("trusted run id was not injected by the evaluator host") provenance = load_trusted_provenance(target, provenance_path, provenance_sha256) validate_provenance(provenance, target, programs, expected_run_id) return True def main() -> bool: try: programs = validate_outputs(DEFAULT_TARGET) provenance_path = os.environ.get("ENGIWORLD_TRUSTED_PROVENANCE") provenance_sha256 = os.environ.get("ENGIWORLD_TRUSTED_PROVENANCE_SHA256") expected_run_id = os.environ.get("ENGIWORLD_TRUSTED_RUN_ID") supplied = [provenance_path, provenance_sha256, expected_run_id] if any(supplied) and not all(supplied): raise EvaluationError("trusted provenance injection is incomplete") if all(supplied): provenance = load_trusted_provenance( DEFAULT_TARGET, Path(str(provenance_path)), str(provenance_sha256), ) validate_provenance(provenance, DEFAULT_TARGET, programs, str(expected_run_id)) # Current task JSON cannot inject host evidence. In that deployment, this # entry point validates NC semantics only and ignores all agent-writable # provenance claims under Desktop. return True except Exception: return False if __name__ == "__main__": sys.stdout.buffer.write(b"True\n" if main() else b"False\n") raise SystemExit(0)