rea-agents 3.2.1 → 4.0.0

package/dist/domain/processScenario.js

@@ -1,20 +1,12 @@
 import { createHash } from "node:crypto";
-import { isPathWithinRoot } from "./localPath.js";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { processReactiveScenarioSchema, } from "./processReactiveScenario.js";
-import { replayMachineSchema } from "./replayMachine.js";
 const positiveBudget = z.number().int().safe().positive();
 const timedEventBase = { at_ms: z.number().int().safe().nonnegative() };
-const environmentName = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u);
-const reservedEnvironment = new Set([
-    "HOME",
-    "TERM",
-    "REA_PROCESS_RUN_ID",
-    "REA_REPLAY_HTTP_URL",
-    "REA_REPLAY_WEBSOCKET_URL",
-    "REA_SHIM_LEDGER_URL",
-]);
+const environmentName = z
+    .string()
+    .regex(/^[^=\0]+$/u, "Environment names cannot contain '=' or NUL");
+const reservedEnvironment = new Set(["REA_PROCESS_RUN_ID"]);
 export const normalizationSchema = z.object({
     paths: z.boolean(),
     pids: z.boolean(),
@@ -25,13 +17,6 @@ export const normalizationSchema = z.object({
         replacement: z.string(),
     })),
 });
-const checkpointNameSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/u);
-const commandNameSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
-const outputChunkSchema = z.object({
-    at_ms: z.number().int().safe().nonnegative(),
-    stream: z.enum(["stdout", "stderr"]),
-    data: z.string(),
-});
 /** Compute a canonical SHA-256 commitment independent of object key order. */
 export const digestProcessCommitment = (value) => {
     const serialized = canonicalize(value);
@@ -39,51 +24,36 @@ export const digestProcessCommitment = (value) => {
         throw new TypeError("Process capture commitment is not canonical JSON");
     return createHash("sha256").update(serialized).digest("hex");
 };
-const reactiveScenarioCommitment = (scenario) => scenario === null
-    ? null
-    : {
-        ...scenario,
-        states: scenario.states.map((state) => ({
-            ...state,
-            on: state.on.map((transition) => ({
-                ...transition,
-                actions: transition.actions.map((action) => action.type === "send_input" && action.sensitive
-                    ? {
-                        ...action,
-                        data: `<redacted-input:${String(Buffer.byteLength(action.data))}-bytes>`,
-                    }
-                    : action),
-            })),
-        })),
-    };
-/** Build the secret-safe scenario projection committed by process-capture Evidence. */
+const committedScenarioEvents = (events, includeSensitiveInputLength) => events.map((event) => event.type === "input" && event.sensitive
+    ? {
+        ...event,
+        data: includeSensitiveInputLength
+            ? `<redacted-input:${String(Buffer.byteLength(event.data))}-bytes>`
+            : "<redacted-input>",
+    }
+    : event);
+/** Build the caller-selected scenario projection committed by process-capture Evidence. */
 export const processScenarioCommitment = (scenario, executableSha256) => ({
     ...scenario,
-    environment: Object.fromEntries(Object.entries(scenario.environment).map(([name, value]) => [
-        name,
-        scenario.secret_aliases.includes(name) ? "<redacted-secret>" : value,
-    ])),
-    reactive: reactiveScenarioCommitment(scenario.reactive),
+    events: committedScenarioEvents(scenario.events, true),
     executable_sha256: executableSha256 ?? null,
 });
-/** Project observation settings shared by authority and reconstruction. */
+/** Project observation settings shared by capture and reconstruction. */
 export const processComparisonContract = (scenario) => ({
     working_directory: scenario.working_directory,
-    inherit_environment: scenario.inherit_environment,
-    secret_aliases: scenario.secret_aliases,
-    network_access: scenario.network_access,
-    filesystem_roots: scenario.filesystem_roots,
+    environment: scenario.environment,
+    ambient_environment: "unknown",
+    filesystem_observation_paths: scenario.filesystem_observation_paths,
     terminal: scenario.terminal,
-    checkpoints: scenario.checkpoints,
-    events: scenario.events,
+    // Input bytes are intentionally absent from compatibility identity. Their
+    // redacted observations remain unknown, so equal commitments never imply
+    // that two secret values were the same.
+    events: committedScenarioEvents(scenario.events, false),
     timeout_ms: scenario.timeout_ms,
     idle_timeout_ms: scenario.idle_timeout_ms,
     settle_ms: scenario.settle_ms,
     limits: scenario.limits,
     normalization: scenario.normalization,
-    command_shims: scenario.command_shims,
-    replay: scenario.replay,
-    reactive: reactiveScenarioCommitment(scenario.reactive),
 });
 /**
  * Boundary schema for one bounded process experiment.
@@ -91,14 +61,11 @@ export const processComparisonContract = (scenario) => ({
  */
 export const processScenarioSchema = z
     .object({
-    executable: z.string().startsWith("/"),
+    executable: z.string().min(1),
     arguments: z.array(z.string()).default([]),
-    working_directory: z.string().startsWith("/"),
+    working_directory: z.string().default("."),
     environment: z.record(environmentName, z.string()).default({}),
-    inherit_environment: z.array(environmentName).default([]),
-    secret_aliases: z.array(environmentName).default([]),
-    network_access: z.literal("host").default("host"),
-    filesystem_roots: z.array(z.string().startsWith("/")).default([]),
+    filesystem_observation_paths: z.array(z.string().min(1)).default([]),
     terminal: z
         .object({
         columns: z.number().int().min(1).max(65_535).default(80),
@@ -106,46 +73,6 @@ export const processScenarioSchema = z
         scrollback: z.number().int().min(0).default(1_000),
     })
         .default({ columns: 80, rows: 24, scrollback: 1_000 }),
-    checkpoints: z
-        .array(z.object({
-        name: checkpointNameSchema,
-        trigger: z.discriminatedUnion("type", [
-            z.object({
-                type: z.literal("time"),
-                at_ms: z.number().int().safe().nonnegative(),
-            }),
-            z.object({
-                type: z.literal("terminal_literal"),
-                value: z.string().min(1),
-                occurrence: positiveBudget.default(1),
-            }),
-            z.object({ type: z.literal("root_exit") }),
-            z.object({ type: z.literal("settled") }),
-        ]),
-    }))
-        .default([]),
-    command_shims: z
-        .array(z.object({
-        name: commandNameSchema,
-        routes: z
-            .array(z.object({
-            arguments: z.array(z.string()),
-            outputs: z.array(outputChunkSchema).default([]),
-            termination: z.discriminatedUnion("type", [
-                z.object({
-                    type: z.literal("exit"),
-                    code: z.number().int().min(0).max(255),
-                }),
-                z.object({
-                    type: z.literal("signal"),
-                    signal: z.enum(["SIGINT", "SIGTERM", "SIGKILL"]),
-                }),
-            ]),
-            max_calls: positiveBudget.default(1),
-        }))
-            .min(1),
-    }))
-        .default([]),
     events: z
         .array(z.discriminatedUnion("type", [
         z.object({
@@ -176,9 +103,6 @@ export const processScenarioSchema = z
         files: positiveBudget.default(10_000),
         file_bytes: positiveBudget.default(10_000_000),
         processes: positiveBudget.default(1_000),
-        protocol_events: positiveBudget.default(10_000),
-        protocol_body_bytes: positiveBudget.default(1_000_000),
-        connections: positiveBudget.default(100),
         filesystem_depth: z.number().int().safe().nonnegative().default(16),
     })
         .strict()
@@ -187,14 +111,11 @@ export const processScenarioSchema = z
         files: 10_000,
         file_bytes: 10_000_000,
         processes: 1_000,
-        protocol_events: 10_000,
-        protocol_body_bytes: 1_000_000,
-        connections: 100,
         filesystem_depth: 16,
     }),
     normalization: z
         .object({
-        paths: z.boolean().default(true),
+        paths: z.boolean().default(false),
         pids: z.boolean().default(true),
         ports: z.boolean().default(true),
         time_bucket_ms: positiveBudget.default(10),
@@ -206,47 +127,12 @@ export const processScenarioSchema = z
             .default([]),
     })
         .default({
-        paths: true,
+        paths: false,
         pids: true,
         ports: true,
         time_bucket_ms: 10,
         patterns: [],
     }),
-    replay: z
-        .object({
-        machine: replayMachineSchema.nullable().default(null),
-        http: z
-            .array(z.object({
-            method: z.string(),
-            path: z.string().startsWith("/"),
-            status: z.number().int().min(100).max(599),
-            body: z.string(),
-            request_headers: z.record(z.string(), z.string()).default({}),
-            request_body: z.string().optional(),
-            response_headers: z.record(z.string(), z.string()).default({}),
-            delay_ms: z.number().int().safe().nonnegative().default(0),
-            disconnect: z.boolean().default(false),
-            max_calls: positiveBudget.default(1),
-        }))
-            .default([]),
-        websocket_messages: z.array(z.string()).default([]),
-        websocket_connections: z
-            .array(z.object({
-            messages: z.array(z.object({
-                data: z.string(),
-                delay_ms: z.number().int().safe().nonnegative().default(0),
-            })),
-            disconnect_after: z.boolean().default(false),
-        }))
-            .default([]),
-    })
-        .default({
-        machine: null,
-        http: [],
-        websocket_messages: [],
-        websocket_connections: [],
-    }),
-    reactive: processReactiveScenarioSchema.nullable().default(null),
 })
     .strict()
     .superRefine((scenario, context) => {
@@ -261,18 +147,8 @@ export const processScenarioSchema = z
             });
         }
     }
-    const secrets = new Set(scenario.secret_aliases);
-    for (const alias of secrets) {
-        if (!(alias in scenario.environment)) {
-            context.addIssue({
-                code: "custom",
-                message: "secret alias has no environment value",
-                path: ["secret_aliases"],
-            });
-        }
-    }
     const explicit = new Set(Object.keys(scenario.environment));
-    for (const name of [...explicit, ...scenario.inherit_environment]) {
+    for (const name of explicit) {
         if (reservedEnvironment.has(name)) {
             context.addIssue({
                 code: "custom",
@@ -281,15 +157,6 @@ export const processScenarioSchema = z
             });
         }
     }
-    for (const name of scenario.inherit_environment) {
-        if (explicit.has(name)) {
-            context.addIssue({
-                code: "custom",
-                message: "an environment name cannot be explicit and inherited",
-                path: ["inherit_environment"],
-            });
-        }
-    }
     for (const event of scenario.events) {
         if (event.at_ms > scenario.timeout_ms) {
             context.addIssue({
@@ -299,74 +166,7 @@ export const processScenarioSchema = z
             });
         }
     }
-    const checkpointNames = scenario.checkpoints.map(({ name }) => name);
-    for (const [index, name] of checkpointNames.entries()) {
-        if (name === "before" || name === "after_settlement")
-            context.addIssue({
-                code: "custom",
-                message: "checkpoint name is reserved by the capture lifecycle",
-                path: ["checkpoints", index, "name"],
-            });
-    }
-    if (new Set(checkpointNames).size !== checkpointNames.length)
-        context.addIssue({
-            code: "custom",
-            message: "checkpoint names must be unique",
-            path: ["checkpoints"],
-        });
-    const shimNames = scenario.command_shims.map(({ name }) => name);
-    if (new Set(shimNames).size !== shimNames.length)
-        context.addIssue({
-            code: "custom",
-            message: "command shim names must be unique",
-            path: ["command_shims"],
-        });
-    if (scenario.replay.machine !== null &&
-        (scenario.replay.http.length > 0 ||
-            scenario.replay.websocket_messages.length > 0 ||
-            scenario.replay.websocket_connections.length > 0))
-        context.addIssue({
-            code: "custom",
-            message: "a replay machine cannot be combined with static HTTP or WebSocket scripts",
-            path: ["replay"],
-        });
 });
 const eventsOutOfOrder = (event, previous) => event !== undefined && previous !== undefined && event.at_ms < previous.at_ms;
 /** Parse untrusted process scenario input and apply safe default budgets. */
 export const parseProcessScenario = (input) => processScenarioSchema.parse(input);
-/** Evaluate scenario authority before any process or filesystem side effect occurs. */
-export const authorizeProcessScenario = (scenario, policy) => {
-    if (policy.status === "disabled")
-        return { allowed: false, reason: "process capture is disabled" };
-    if (scenario.network_access === "host" && policy.networkAccess === "none")
-        return {
-            allowed: false,
-            reason: "host network access is not approved by operator policy",
-        };
-    if (!policy.executableRoots.some((root) => isPathWithinRoot(root, scenario.executable))) {
-        return { allowed: false, reason: "executable is outside approved roots" };
-    }
-    if (!policy.workingRoots.some((root) => isPathWithinRoot(root, scenario.working_directory))) {
-        return {
-            allowed: false,
-            reason: "working directory is outside approved roots",
-        };
-    }
-    const requestedNames = [
-        ...Object.keys(scenario.environment),
-        ...scenario.inherit_environment,
-    ];
-    if (requestedNames.some((name) => !policy.allowedEnvironment.includes(name))) {
-        return {
-            allowed: false,
-            reason: "scenario requests an environment variable not allowed by policy",
-        };
-    }
-    if (scenario.filesystem_roots.some((path) => !policy.workingRoots.some((root) => isPathWithinRoot(root, path)))) {
-        return {
-            allowed: false,
-            reason: "filesystem root is outside approved roots",
-        };
-    }
-    return { allowed: true };
-};

package/dist/domain/processTraceDimensionProjection.js

@@ -10,14 +10,8 @@ export const dimensionsForTraceSources = (sources) => {
             dimensions.add("exit");
         else if (source === "filesystem")
             dimensions.add("filesystem");
-        else if (source === "http" ||
-            source === "websocket" ||
-            source === "replay_transition")
-            dimensions.add("protocol");
         else if (source === "process")
             dimensions.add("process");
-        else if (source === "shim")
-            dimensions.add("shim");
     }
     return dimensions;
 };
@@ -35,16 +29,7 @@ export const traceCoversObservedDimension = (dimension, sources, left, right) =>
             return sources.has("lifecycle");
         case "filesystem":
             return false;
-        case "protocol":
-            return ((![...left.protocol_events, ...right.protocol_events].some(({ protocol }) => protocol === "http") ||
-                sources.has("http")) &&
-                (![...left.protocol_events, ...right.protocol_events].some(({ protocol }) => protocol === "websocket") ||
-                    sources.has("websocket")) &&
-                (!any(left.replay_transitions, right.replay_transitions) ||
-                    sources.has("replay_transition")));
         case "process":
             return sources.has("process");
-        case "shim":
-            return sources.has("shim");
     }
 };

package/dist/domain/processTraceEvaluation.js

@@ -50,16 +50,10 @@ const scopesFor = (sources) => new Set([...sources].map((source) => {
         return "terminal";
     if (source === "lifecycle")
         return "exit";
-    if (source === "http" ||
-        source === "websocket" ||
-        source === "replay_transition")
-        return "protocol";
     if (source === "filesystem")
         return "filesystem";
     if (source === "process")
         return "process";
-    if (source === "shim")
-        return "shim";
     return "interaction";
 }));
 const unknownSide = () => ({

package/dist/domain/protocolCapture.js

@@ -51,7 +51,7 @@ export const protocolMessageSchema = z.strictObject({
     schema_hypotheses: z.array(schemaHypothesisSchema).default([]),
     /** Whether decoding was truncated. */
     truncated: z.boolean().default(false),
-    /** Whether credentials were detected and redacted. */
+    /** Whether the capture producer marked credentials as redacted. */
     credentials_redacted: z.boolean().default(false),
 });
 /** A captured protocol session with messages and inferred schemas. */
@@ -64,7 +64,7 @@ export const protocolCaptureSchema = z.strictObject({
     inferred_schema: z.array(schemaHypothesisSchema).default([]),
     /** Whether any message was truncated. */
     has_truncated: z.boolean().default(false),
-    /** Whether credentials were detected and redacted. */
+    /** Whether the capture producer marked credential content as redacted. */
     credentials_detected: z.boolean().default(false),
 });
 /** Classification of a byte sequence as a known protocol family. */
@@ -88,24 +88,6 @@ export function classifyProtocolFamily(contentType, path) {
     }
     return null;
 }
-/** Credential-like field names that should be redacted. */
-const CREDENTIAL_PATTERNS = [
-    "password",
-    "passwd",
-    "secret",
-    "token",
-    "api_key",
-    "apikey",
-    "authorization",
-    "auth",
-    "credential",
-    "private_key",
-];
-/** Check if a field path looks like it may contain credentials. */
-export function looksLikeCredential(path) {
-    const lower = path.toLowerCase();
-    return CREDENTIAL_PATTERNS.some((p) => lower.includes(p));
-}
 /** Decode a JSON-RPC message from raw payload bytes. */
 export function decodeJsonRpc(rawPayload) {
     const text = new TextDecoder().decode(rawPayload);
@@ -113,22 +95,12 @@ export function decodeJsonRpc(rawPayload) {
     const fields = [];
     if (typeof parsed === "object" && parsed !== null) {
         for (const [key, value] of Object.entries(parsed)) {
-            if (looksLikeCredential(key)) {
-                fields.push({
-                    path: key,
-                    wire_type: "json",
-                    value: "[REDACTED]",
-                    inferred: false,
-                });
-            }
-            else {
-                fields.push({
-                    path: key,
-                    wire_type: "json",
-                    value,
-                    inferred: false,
-                });
-            }
+            fields.push({
+                path: key,
+                wire_type: "json",
+                value,
+                inferred: false,
+            });
         }
     }
     return { decoded_fields: fields, truncated: false };

package/dist/domain/reconstructionCoverage.js

@@ -3,8 +3,9 @@ import canonicalize from "canonicalize";
 import { z } from "zod";
 import { evidenceBundleSchema, parseEvidenceBundle } from "./evidenceBundle.js";
 import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionCoverageRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
 const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
 const boundedTextSchema = z.string().trim().min(1);
 const authoritySchema = z.enum([

package/dist/domain/reconstructionObligationLedgerSchemas.js

@@ -1,8 +1,8 @@
-import canonicalize from "canonicalize";
 import { z } from "zod";
 import { evidenceBundleSchema } from "./evidenceBundle.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
 const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
 const textSchema = z.string().trim().min(1);
 export const obligationStatusSchema = z.enum([
@@ -202,7 +202,7 @@ const countBySchema = (key) => z.array(z.strictObject({
 }));
 export const reconstructionObligationLedgerSchema = z.strictObject({
     schema: z.literal("ReconstructionObligationLedger"),
-    ledger_id: z.string().regex(/^rol_[a-f0-9]{64}$/u),
+    ledger_id: prefixedDigestSchema("rol"),
     closure_digest: digestSchema,
     status: z.enum(["ready", "open", "failed", "unknown"]),
     coverage: z.strictObject({
@@ -241,11 +241,3 @@ export const reconstructionObligationLedgerInputSchema = z.strictObject({
     reviewed_obligations: z.array(reviewedReconstructionObligationSchema),
     manifest: reconstructionObligationManifestSchema,
 });
-/** Parse and canonically serialize one complete reconstruction obligation ledger. */
-export const serializeReconstructionObligationLedger = (input) => {
-    const ledger = reconstructionObligationLedgerSchema.parse(input);
-    const encoded = canonicalize(ledger);
-    if (encoded === undefined)
-        throw new TypeError("Reconstruction obligation ledger is not canonical JSON");
-    return encoded;
-};

package/dist/domain/reconstructionReadinessSchemas.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { evidenceBundleSchema } from "./evidenceBundle.js";
 import { reconstructionObligationLedgerSchema } from "./reconstructionObligationLedgerSchemas.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
 const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
 const boundedTextSchema = z.string().trim().min(1);
 export const readinessStatusSchema = z.enum([
@@ -221,7 +222,7 @@ const findingSchema = z.strictObject({
 });
 export const reconstructionReadinessReportSchema = z.strictObject({
     schema: z.literal("ReconstructionReadinessReport"),
-    report_id: z.string().regex(/^rr_[a-f0-9]{64}$/u),
+    report_id: prefixedDigestSchema("rr"),
     source_digest: digestSchema,
     report_digest: digestSchema,
     status: readinessStatusSchema,

package/dist/domain/reconstructionVerification.js

@@ -10,8 +10,9 @@ import { functionDossierSchema } from "./hopperValues.js";
 import { deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, processCaptureSchema, } from "./processCapture.js";
 import { reconstructionClaimResultSchema, reconstructionSpecificationSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
 import { reconstructionClaimUnknowns, reconstructionProbes, reconstructionUnknownHeads, } from "./reconstructionUnknowns.js";
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const evidenceIdSchema = prefixedDigestSchema("ev");
 export { reconstructionVerificationInputSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
 const providers = {
     behavioral: {
         operation: "compare_process_captures",

package/dist/domain/reconstructionVerificationSchemas.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const unknownIdSchema = z.string().regex(/^unk_[a-f0-9]{64}$/u);
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+import { PROCESS_COMPARISON_DIMENSIONS } from "./processComparison.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const unknownIdSchema = prefixedDigestSchema("unk");
 const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
 const titleSchema = z.string().trim().min(1);
 const verificationStatusSchema = z.enum(["pass", "fail", "unknown"]);
@@ -13,16 +15,7 @@ const commonClaim = {
 const behavioralClaimSchema = z.object({
     ...commonClaim,
     kind: z.literal("behavioral"),
-    dimension: z.enum([
-        "overall",
-        "terminal",
-        "interaction",
-        "exit",
-        "filesystem",
-        "protocol",
-        "process",
-        "shim",
-    ]),
+    dimension: z.enum(["overall", ...PROCESS_COMPARISON_DIMENSIONS]),
 });
 const functionClaimSchema = z.object({
     ...commonClaim,