rea-agents 3.2.0 → 4.0.0

package/dist/domain/processCaptureExample.js

@@ -8,8 +8,6 @@ const normalization = {
 };
 const scenario = { executable_sha256: "0".repeat(64) };
 const comparisonContract = {};
-const shimPlan = [];
-const replayPlan = {};
 /** Minimal valid process capture retained as a public contract example. */
 export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
     manifest: {
@@ -22,14 +20,10 @@ export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
         completed_at: "2026-01-01T00:00:00.001Z",
         scenario,
         comparison_contract: comparisonContract,
-        shim_plan: shimPlan,
-        replay_plan: replayPlan,
         full_scenario_sha256: digestProcessCommitment(scenario),
         comparison_contract_sha256: digestProcessCommitment(comparisonContract),
         executable_sha256: "0".repeat(64),
         normalization_sha256: digestProcessCommitment(normalization),
-        shim_plan_sha256: digestProcessCommitment(shimPlan),
-        replay_plan_sha256: digestProcessCommitment(replayPlan),
     },
     normalization,
     frames: [],
@@ -52,9 +46,6 @@ export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
             truncated: false,
         },
     ],
-    shim_events: [],
-    protocol_events: [],
-    replay_transitions: [],
     files_before: [],
     files_after: [],
     filesystem_effects: [],

package/dist/domain/processCaptureValidation.js

@@ -1,11 +1,8 @@
-import { validateProcessCaptureReactiveRun } from "./processCaptureReactiveValidation.js";
-import { replayMachineSchema } from "./replayMachine.js";
 import { digestProcessCommitment } from "./processScenario.js";
 const orderedTimestamps = (values) => values.every((value, index) => {
     const previous = values[index - 1];
     return previous === undefined || value.at_ms >= previous.at_ms;
 });
-const transitionsAreContiguous = (previous, current) => previous !== undefined && previous.state_after === current.state_before;
 const validateCommitments = (capture, require) => {
     const { manifest } = capture;
     require(manifest.scenario.executable_sha256 ===
@@ -14,8 +11,6 @@ const validateCommitments = (capture, require) => {
         ["full_scenario_sha256", manifest.scenario],
         ["comparison_contract_sha256", manifest.comparison_contract],
         ["normalization_sha256", capture.normalization],
-        ["shim_plan_sha256", manifest.shim_plan],
-        ["replay_plan_sha256", manifest.replay_plan],
     ])
         require(manifest[field] ===
             digestProcessCommitment(value), `manifest.${field}`, "commitment does not match its canonical value");
@@ -27,38 +22,27 @@ const validateOrdering = (capture, require) => {
         ["frames", capture.frames],
         ["rendered_frames", capture.rendered_frames],
         ["interaction_events", capture.interaction_events],
-        ["shim_events", capture.shim_events],
-        ["protocol_events", capture.protocol_events],
-        ["replay_transitions", capture.replay_transitions],
     ])
         require(values.every(({ sequence }, index) => sequence === index), name, "sequence values must be contiguous from zero");
     for (const [name, values] of [
         ["frames", capture.frames],
         ["rendered_frames", capture.rendered_frames],
         ["process_samples", capture.process_samples],
-        ["filesystem_checkpoints", capture.filesystem_checkpoints],
-        ["shim_events", capture.shim_events],
-        ["protocol_events", capture.protocol_events],
-        ["replay_transitions", capture.replay_transitions],
     ])
         require(orderedTimestamps(values), name, "timestamps must be ordered");
 };
-const journalCollectionSizes = (capture) => ({
-    frames: capture.frames.length,
-    rendered_frames: capture.rendered_frames.length,
-    interaction_events: capture.interaction_events.length,
-    lifecycle: 2,
-    process_samples: capture.process_samples.length,
-    filesystem_checkpoints: capture.filesystem_checkpoints.length,
-    shim_events: capture.shim_events.length,
-    protocol_events: capture.protocol_events.length,
-    replay_transitions: capture.replay_transitions.length,
-});
 const validateEventJournal = (capture, require) => {
     const journal = capture.event_journal ?? [];
     if (journal.length === 0)
         return;
-    const sizes = journalCollectionSizes(capture);
+    const sizes = {
+        frames: capture.frames.length,
+        rendered_frames: capture.rendered_frames.length,
+        interaction_events: capture.interaction_events.length,
+        lifecycle: 2,
+        process_samples: capture.process_samples.length,
+        filesystem_checkpoints: capture.filesystem_checkpoints.length,
+    };
     const references = new Set();
     for (const [position, entry] of journal.entries()) {
         require(entry.capture_order ===
@@ -74,128 +58,16 @@ const validateEventJournal = (capture, require) => {
         expectedSize, "event_journal", "nonempty journal must reference every captured observation");
 };
 const validateLifecycle = (capture, require) => {
-    const checkpointNames = capture.filesystem_checkpoints.map(({ name }) => name);
-    require(new Set(checkpointNames).size ===
-        checkpointNames.length, "filesystem_checkpoints", "checkpoint names must be unique");
-    require(checkpointNames[0] ===
-        "before", "filesystem_checkpoints", "first checkpoint must be before");
-    require(checkpointNames.at(-1) ===
-        "after_settlement", "filesystem_checkpoints", "last checkpoint must be after_settlement");
+    require(capture.filesystem_checkpoints.map(({ name }) => name).join(",") ===
+        "before,after_settlement", "filesystem_checkpoints", "capture must include initial and final filesystem snapshots");
+    require(orderedTimestamps(capture.filesystem_checkpoints), "filesystem_checkpoints", "filesystem snapshot times must be ordered");
     require(!capture.filesystem_checkpoints.some(({ truncated }) => truncated) ||
-        capture.truncated, "truncated", "checkpoint truncation must propagate to the capture");
+        capture.truncated, "truncated", "filesystem snapshot truncation must propagate to the capture");
     require(capture.exit.reason === "exited" ||
         capture.exit.code ===
             null, "exit", "deadline termination cannot declare a normal exit code");
 };
-const shimPlans = (capture) => capture.manifest.shim_plan.flatMap((shim) => typeof shim === "object" &&
-    shim !== null &&
-    "name" in shim &&
-    "routes" in shim &&
-    typeof shim.name === "string" &&
-    Array.isArray(shim.routes)
-    ? shim.routes.map((route, routeIndex) => ({
-        command: shim.name,
-        route,
-        routeIndex,
-    }))
-    : []);
-const validateShimEvents = (capture, require) => {
-    const plans = shimPlans(capture);
-    for (const event of capture.shim_events) {
-        const declared = plans.some(({ command, routeIndex }) => command === event.command && routeIndex === event.route_index);
-        require(event.outcome === "unmatched"
-            ? event.route_index === null
-            : declared, "shim_events", "shim event has no declared route");
-    }
-    for (const plan of plans) {
-        const maximum = typeof plan.route === "object" &&
-            plan.route !== null &&
-            "max_calls" in plan.route &&
-            typeof plan.route.max_calls === "number"
-            ? plan.route.max_calls
-            : 0;
-        const matches = capture.shim_events.filter((event) => event.command === plan.command &&
-            event.route_index === plan.routeIndex &&
-            event.outcome === "matched").length;
-        require(matches <=
-            maximum, "shim_events", "matched shim events exceed the declared route max_calls");
-    }
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-const machinePlan = (replayPlan) => {
-    const parsed = replayMachineSchema.safeParse(replayPlan["machine"]);
-    return parsed.success ? parsed.data : undefined;
-};
-const matchesHttpPlan = (value, event) => {
-    if (!isRecord(value))
-        return false;
-    const route = isRecord(value["trigger"]) ? value["trigger"] : value;
-    return ((route["protocol"] === undefined || route["protocol"] === "http") &&
-        route["method"] === event.method &&
-        route["path"] === event.path);
-};
-const validateMatchedHttpEvents = (capture, plans, require) => {
-    for (const event of capture.protocol_events) {
-        if (event.protocol !== "http" ||
-            event.direction !== "request" ||
-            event.outcome !== "matched")
-            continue;
-        require(plans.some((plan) => matchesHttpPlan(plan, event)), "protocol_events", "matched HTTP event has no declared replay route");
-    }
-};
-const validateReplayEvents = (capture, require) => {
-    const replayPlan = capture.manifest.replay_plan;
-    const routes = Array.isArray(replayPlan["http"]) ? replayPlan["http"] : [];
-    const machine = machinePlan(replayPlan);
-    require(replayPlan["machine"] === undefined ||
-        replayPlan["machine"] === null ||
-        machine !==
-            undefined, "manifest.replay_plan.machine", "replay machine does not satisfy its declared schema");
-    validateMatchedHttpEvents(capture, [...routes, ...(machine?.transitions ?? [])], require);
-    const plans = new Map((machine?.transitions ?? []).map((transition) => [
-        transition.id,
-        transition,
-    ]));
-    const transitionUses = new Map();
-    const stateVisits = new Map();
-    if (machine !== undefined)
-        stateVisits.set(machine.initial_state, 1);
-    require(machine === undefined ||
-        capture.replay_transitions.length <=
-            machine.max_transitions, "replay_transitions", "replay transition journal exceeds the declared machine limit");
-    for (const [index, transition] of capture.replay_transitions.entries()) {
-        const plan = plans.get(transition.transition_id);
-        require(plan !==
-            undefined, "replay_transitions", "replay transition has no declared machine transition");
-        if (plan === undefined)
-            continue;
-        require(transition.state_before === plan.from &&
-            transition.state_after ===
-                plan.to, "replay_transitions", "replay transition states do not match the declared transition");
-        require(JSON.stringify(transition.sensitive_aliases) ===
-            JSON.stringify(plan.captures
-                .filter(({ sensitive }) => sensitive)
-                .map(({ variable }) => variable)
-                .sort()), "replay_transitions", "replay transition sensitive aliases do not match the declared captures");
-        const uses = (transitionUses.get(plan.id) ?? 0) + 1;
-        transitionUses.set(plan.id, uses);
-        require(uses <=
-            plan.max_uses, "replay_transitions", "replay transition journal exceeds the transition use limit");
-        const visits = (stateVisits.get(transition.state_after) ?? 0) + 1;
-        stateVisits.set(transition.state_after, visits);
-        const state = machine?.states.find(({ name }) => name === transition.state_after);
-        require(state === undefined ||
-            visits <=
-                state.max_visits, "replay_transitions", "replay transition journal exceeds the state visit limit");
-        if (index === 0)
-            require(transition.state_before ===
-                machine?.initial_state, "replay_transitions", "first replay transition does not start at the declared initial state");
-        const previous = capture.replay_transitions[index - 1];
-        if (index > 0)
-            require(transitionsAreContiguous(previous, transition), "replay_transitions", "replay transition states are not contiguous");
-    }
-};
-/** Recompute v4 commitments and cross-field invariants without side effects. */
+/** Recompute commitments and cross-field invariants without side effects. */
 export const collectProcessCaptureIssues = (capture) => {
     const issues = [];
     const require = (condition, path, message) => {
@@ -206,8 +78,5 @@ export const collectProcessCaptureIssues = (capture) => {
     validateOrdering(capture, require);
     validateEventJournal(capture, require);
     validateLifecycle(capture, require);
-    validateShimEvents(capture, require);
-    validateReplayEvents(capture, require);
-    validateProcessCaptureReactiveRun(capture, require);
     return issues;
 };

package/dist/domain/processComparison.js

@@ -19,9 +19,7 @@ export const PROCESS_COMPARISON_DIMENSIONS = [
     "interaction",
     "exit",
     "filesystem",
-    "protocol",
     "process",
-    "shim",
 ];
 /** Derive the overall comparison status from every process dimension. */
 export const deriveProcessComparisonStatus = (dimensions) => {
@@ -39,9 +37,7 @@ export const processCaptureComparisonSchema = z
     interaction: comparisonStatusSchema,
     exit: comparisonStatusSchema,
     filesystem: comparisonStatusSchema,
-    protocol: comparisonStatusSchema,
     process: comparisonStatusSchema,
-    shim: comparisonStatusSchema,
     first_divergence: z.discriminatedUnion("status", [
         z.object({ status: z.literal("none") }),
         z.object({ status: z.literal("unknown"), reason: z.string() }),
@@ -52,9 +48,7 @@ export const processCaptureComparisonSchema = z
                 "interaction",
                 "exit",
                 "filesystem",
-                "protocol",
                 "process",
-                "shim",
             ]),
             index: z.number().int().nonnegative(),
             left_at_ms: z.number().int().nonnegative().nullable(),
@@ -89,14 +83,7 @@ const terminalObservations = (capture) => [
         return left.kind === "raw" ? -1 : 1;
     return left.sequence - right.sequence;
 });
-const filesystemObservations = (capture) => [
-    ...capture.filesystem_checkpoints,
-    {
-        name: "final",
-        files: capture.files_after,
-        effects: capture.filesystem_effects,
-    },
-];
+const filesystemObservations = (capture) => capture.filesystem_checkpoints;
 const sameJsonValue = (left, right) => {
     const encodedLeft = canonicalize(left);
     return encodedLeft !== undefined && encodedLeft === canonicalize(right);
@@ -112,12 +99,8 @@ export const processDimensionObservations = (capture, dimension) => {
             return [{ ...capture.exit, settlement: capture.settlement }];
         case "filesystem":
             return filesystemObservations(capture);
-        case "protocol":
-            return [...capture.protocol_events, ...capture.replay_transitions];
         case "process":
             return capture.process_samples;
-        case "shim":
-            return capture.shim_events;
     }
 };
 const classifyCollection = (left, right) => {
@@ -184,9 +167,7 @@ const truncatedComparison = () => ({
     interaction: "truncated",
     exit: "truncated",
     filesystem: "truncated",
-    protocol: "truncated",
     process: "truncated",
-    shim: "truncated",
     first_divergence: {
         status: "unknown",
         reason: "At least one capture is truncated.",
@@ -222,9 +203,7 @@ const applyTraceVerdict = (dimensions, specification, trace, captures) => {
         interaction: statusFor("interaction"),
         exit: statusFor("exit"),
         filesystem: statusFor("filesystem"),
-        protocol: statusFor("protocol"),
         process: statusFor("process"),
-        shim: statusFor("shim"),
     };
 };
 const compareDimensions = (left, right, sameNormalization) => {
@@ -240,9 +219,7 @@ const compareDimensions = (left, right, sameNormalization) => {
                 ? "unchanged"
                 : "changed",
         filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right)),
-        protocol: classify("protocol", [...left.protocol_events, ...left.replay_transitions], [...right.protocol_events, ...right.replay_transitions]),
         process: classify("process", left.process_samples, right.process_samples),
-        shim: classify("shim", left.shim_events, right.shim_events),
     };
 };
 /**
@@ -292,8 +269,9 @@ export const compareProcessCaptures = (left, right, options = {}) => {
                     reason: "Residual unknowns prevent proving that no divergence occurred.",
                 }
                 : observedFirstDivergence;
+    const observedStatus = deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension]));
     return {
-        status: deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension])),
+        status: observedStatus,
         ...dimensions,
         first_divergence: firstDivergence,
         ...(trace === undefined ? {} : { trace }),

package/dist/domain/processObservation.js

@@ -8,10 +8,6 @@ export const processObservationSourceSchema = z.enum([
     "lifecycle",
     "process",
     "filesystem",
-    "http",
-    "websocket",
-    "shim",
-    "replay_transition",
 ]);
 /** Stable raw-record location within one Process Capture observation journal. */
 export const processObservationLocationSchema = z.strictObject({
@@ -22,9 +18,6 @@ export const processObservationLocationSchema = z.strictObject({
         "lifecycle",
         "process_samples",
         "filesystem_checkpoints",
-        "shim_events",
-        "protocol_events",
-        "replay_transitions",
     ]),
     index: z.number().int().nonnegative(),
     capture_order: z.number().int().nonnegative(),
@@ -69,12 +62,6 @@ export const processObservationSubject = (source, value) => {
         "name" in value &&
         typeof value.name === "string")
         return `checkpoint:${value.name}`;
-    if (source === "shim" &&
-        "command" in value &&
-        typeof value.command === "string")
-        return "route_index" in value && typeof value.route_index === "number"
-            ? `shim:${value.command}:route:${String(value.route_index)}`
-            : `shim:${value.command}:unmatched`;
     return null;
 };
 const projectedRecord = (capture, location) => {
@@ -117,22 +104,6 @@ const projectedRecord = (capture, location) => {
                     source: "filesystem",
                     value: capture.filesystem_checkpoints[location.index],
                 };
-            case "shim_events":
-                return {
-                    source: "shim",
-                    value: capture.shim_events[location.index],
-                };
-            case "protocol_events": {
-                const event = capture.protocol_events[location.index];
-                return event === undefined
-                    ? null
-                    : { source: event.protocol, value: event };
-            }
-            case "replay_transitions":
-                return {
-                    source: "replay_transition",
-                    value: capture.replay_transitions[location.index],
-                };
         }
     })();
     if (projected === null || projected.value === undefined)