rea-agents 3.2.1 → 4.0.0

package/dist/domain/javascriptReplay.js

@@ -1,360 +0,0 @@
-import { z } from "zod";
-import { evidenceEnvelopeSchema } from "./evidence.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const absolutePathSchema = z.string().startsWith("/");
-const aliasSchema = z
-    .string()
-    .min(1)
-    .regex(/^[A-Za-z0-9_./:@-]+$/u);
-const replayModuleSchema = z
-    .object({
-    alias: aliasSchema,
-    path: absolutePathSchema,
-    format: z.enum(["esm", "commonjs-factory"]),
-    role: z.enum(["module", "stub"]).default("module"),
-    dependencies: z.record(z.string().min(1), aliasSchema).default({}),
-})
-    .strict();
-const replaySideSchema = z
-    .object({
-    modules: z.array(replayModuleSchema).min(1),
-    entry_alias: aliasSchema,
-    entry_export: z.string().min(1).default("default"),
-})
-    .strict();
-const explicitCaseSchema = z
-    .object({
-    case_id: z.string().min(1),
-    arguments: z.array(z.json()),
-})
-    .strict();
-const generatorSchema = z
-    .object({
-    preset: z.enum([
-        "parser-boundaries",
-        "sanitizer-boundaries",
-        "clipboard-boundaries",
-    ]),
-    seed: z.number().int().min(0).max(0xffff_ffff),
-    count: z.number().int().safe().min(1),
-})
-    .strict();
-const replayLimitsSchema = z
-    .object({
-    wall_time_ms: z.number().int().safe().min(1).default(3_000),
-    memory_bytes: z
-        .number()
-        .int()
-        .safe()
-        .positive()
-        .default(128 * 1024 * 1024),
-    tasks: z.number().int().safe().min(1).default(8),
-    cpu_quota_percent: z.number().int().safe().min(1).default(50),
-    tmpfs_bytes: z
-        .number()
-        .int()
-        .safe()
-        .min(1)
-        .default(16 * 1024 * 1024),
-    module_bytes: z
-        .number()
-        .int()
-        .safe()
-        .min(1)
-        .default(4 * 1024 * 1024),
-    input_bytes: z
-        .number()
-        .int()
-        .safe()
-        .min(1)
-        .default(256 * 1024),
-    protocol_bytes: z
-        .number()
-        .int()
-        .safe()
-        .min(1)
-        .default(16 * 1024 * 1024),
-    output_bytes: z
-        .number()
-        .int()
-        .safe()
-        .min(1)
-        .default(512 * 1024),
-    stderr_bytes: z
-        .number()
-        .int()
-        .safe()
-        .min(0)
-        .default(32 * 1024),
-    result_depth: z.number().int().safe().min(1).default(16),
-    result_nodes: z.number().int().safe().min(1).default(10_000),
-})
-    .strict();
-const determinismSchema = z
-    .object({
-    clock_iso: z.iso.datetime().default("2000-01-01T00:00:00.000Z"),
-    random_seed: z.number().int().min(0).max(0xffff_ffff).default(0),
-    locale: z.literal("en-US").default("en-US"),
-    timezone: z.literal("UTC").default("UTC"),
-    platform: z.literal("linux").default("linux"),
-})
-    .strict();
-const controlledReplayInputShape = {
-    left: replaySideSchema,
-    right: replaySideSchema.optional(),
-    cases: z.array(explicitCaseSchema).default([]),
-    generator: generatorSchema.optional(),
-    determinism: determinismSchema.default({
-        clock_iso: "2000-01-01T00:00:00.000Z",
-        random_seed: 0,
-        locale: "en-US",
-        timezone: "UTC",
-        platform: "linux",
-    }),
-    limits: replayLimitsSchema.default({
-        wall_time_ms: 3_000,
-        memory_bytes: 128 * 1024 * 1024,
-        tasks: 8,
-        cpu_quota_percent: 50,
-        tmpfs_bytes: 16 * 1024 * 1024,
-        module_bytes: 4 * 1024 * 1024,
-        input_bytes: 256 * 1024,
-        protocol_bytes: 16 * 1024 * 1024,
-        output_bytes: 512 * 1024,
-        stderr_bytes: 32 * 1024,
-        result_depth: 16,
-        result_nodes: 10_000,
-    }),
-    reproducer_export: z
-        .strictObject({
-        path: absolutePathSchema,
-        include_sources: z.boolean().default(false),
-    })
-        .optional(),
-};
-/** Parse a replay request that can only construct a plan. */
-export const controlledReplayPlanInputSchema = z.strictObject({
-    ...controlledReplayInputShape,
-    mode: z.literal("plan"),
-});
-/** Parse a replay request carrying the digest for one exact plan. */
-export const controlledReplayExecutionInputSchema = z.strictObject({
-    ...controlledReplayInputShape,
-    mode: z.literal("execute"),
-    plan_digest: digestSchema,
-});
-/** Parse a controlled replay request into its legal plan or execution state. */
-export const controlledReplayInputSchema = z
-    .discriminatedUnion("mode", [
-    controlledReplayPlanInputSchema,
-    controlledReplayExecutionInputSchema,
-])
-    .superRefine((value, context) => {
-    if (value.cases.length === 0 && value.generator === undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["cases"],
-            message: "At least one explicit or generated case is required",
-        });
-});
-const moduleCommitmentSchema = z
-    .object({
-    alias: aliasSchema,
-    canonical_path: z.string().min(1),
-    format: z.enum(["esm", "commonjs-factory"]),
-    role: z.enum(["module", "stub"]),
-    byte_count: z.number().int().min(0),
-    sha256: digestSchema,
-    dependencies: z.record(z.string(), aliasSchema),
-})
-    .strict();
-const runtimeIdentitySchema = z
-    .object({
-    path: z.string().min(1),
-    version: z.string().min(1),
-    sha256: digestSchema,
-})
-    .strict();
-const runtimeFileIdentitySchema = z
-    .object({
-    source_path: z.string().min(1),
-    destination_path: z.string().min(1),
-    sha256: digestSchema,
-})
-    .strict();
-const replayPlanSchema = z
-    .object({
-    plan_digest: digestSchema,
-    policy_version: z.literal("linux-bwrap-systemd-v1"),
-    policy_sha256: digestSchema,
-    network: z.literal("none"),
-    filesystem: z
-        .object({
-        host_writes: z.literal(false),
-        private_tmpfs_bytes: z.number().int().nonnegative(),
-    })
-        .strict(),
-    runtime: z
-        .object({
-        executable: runtimeIdentitySchema,
-        worker: runtimeIdentitySchema,
-        read_only_files: z.array(runtimeFileIdentitySchema).min(1),
-    })
-        .strict(),
-    sandbox: z
-        .object({
-        bubblewrap: runtimeIdentitySchema,
-        systemd_run: runtimeIdentitySchema,
-        systemctl: runtimeIdentitySchema,
-        shell: runtimeIdentitySchema,
-        seccomp_sha256: digestSchema,
-    })
-        .strict(),
-    left: z
-        .object({
-        modules: z.array(moduleCommitmentSchema),
-        entry_alias: aliasSchema,
-        entry_export: z.string(),
-    })
-        .strict(),
-    right: z
-        .object({
-        modules: z.array(moduleCommitmentSchema),
-        entry_alias: aliasSchema,
-        entry_export: z.string(),
-    })
-        .strict()
-        .optional(),
-    cases: z.array(z
-        .object({
-        case_id: z.string(),
-        arguments: z.array(z.json()),
-        sha256: digestSchema,
-    })
-        .strict()),
-    determinism: determinismSchema,
-    limits: replayLimitsSchema,
-    effects: z.array(z.string()),
-    reproducer_export: z
-        .object({
-        path: z.string().min(1),
-        include_sources: z.boolean(),
-    })
-        .strict()
-        .nullable(),
-})
-    .strict();
-const replayOutcomeFacts = {
-    case_id: z.string(),
-    input_sha256: digestSchema,
-};
-const replayExceptionSchema = z
-    .object({
-    name: z.string(),
-    message: z.string(),
-    stack: z.string().nullable(),
-})
-    .strict();
-const replayOutcomeSchema = z.discriminatedUnion("outcome", [
-    z.strictObject({
-        ...replayOutcomeFacts,
-        outcome: z.literal("return"),
-        value: z.json(),
-        output_sha256: digestSchema,
-        truncated: z.literal(false),
-    }),
-    z.strictObject({
-        ...replayOutcomeFacts,
-        outcome: z.enum(["exception", "serialization_error", "denied"]),
-        exception: z.object(replayExceptionSchema.shape).strict(),
-        output_sha256: digestSchema,
-        truncated: z.literal(false),
-    }),
-    z.strictObject({
-        ...replayOutcomeFacts,
-        outcome: z.enum(["timeout", "oom", "crash", "cancelled"]),
-        output_sha256: z.null(),
-        truncated: z.literal(false),
-    }),
-    z.strictObject({
-        ...replayOutcomeFacts,
-        outcome: z.literal("protocol_error"),
-        output_sha256: z.null(),
-        truncated: z.literal(true),
-    }),
-]);
-export const replayExecutionResultSchema = z
-    .object({
-    plan_digest: digestSchema,
-    outcomes: z.array(replayOutcomeSchema),
-    comparison: z
-        .array(z
-        .object({
-        case_id: z.string(),
-        status: z.enum(["equal", "changed", "unknown"]),
-        left_index: z.number().int(),
-        right_index: z.number().int(),
-    })
-        .strict())
-        .optional(),
-    stderr: z.string(),
-    termination: z.enum([
-        "completed",
-        "timeout",
-        "oom",
-        "crash",
-        "cancelled",
-        "protocol_error",
-    ]),
-    cleanup: z
-        .object({
-        state: z.enum(["complete", "incomplete"]),
-        residual_resources: z.array(z.string()),
-    })
-        .strict(),
-    limitations: z.array(z.string()),
-    reproducer: z
-        .discriminatedUnion("state", [
-        z
-            .object({
-            state: z.literal("written"),
-            path: z.string(),
-            sha256: digestSchema,
-        })
-            .strict(),
-        z
-            .object({
-            state: z.literal("failed"),
-            path: z.string(),
-            error: z.string(),
-        })
-            .strict(),
-    ])
-        .nullable(),
-})
-    .strict();
-export const replayEvidenceSchema = evidenceEnvelopeSchema
-    .omit({ normalized_result: true })
-    .extend({ normalized_result: replayExecutionResultSchema });
-/** A replay plan result with no claimed runtime observation. */
-export const controlledReplayPlanOutputSchema = z.strictObject({
-    phase: z.literal("plan"),
-    plan: replayPlanSchema,
-    source_evidence: z
-        .array(replayEvidenceSchema)
-        .length(0)
-        .brand(),
-    evidence: z.null(),
-});
-/** An executed replay result with its required source and aggregate Evidence. */
-export const controlledReplayExecutionOutputSchema = z.strictObject({
-    phase: z.literal("execute"),
-    plan: z.null(),
-    source_evidence: z.array(replayEvidenceSchema).min(1),
-    evidence: replayEvidenceSchema,
-});
-/** Parse replay output into its legal plan or execution state. */
-export const controlledReplayOutputSchema = z.discriminatedUnion("phase", [
-    controlledReplayPlanOutputSchema,
-    controlledReplayExecutionOutputSchema,
-]);

package/dist/domain/managedRuntimeCorrelation.js

@@ -1,181 +0,0 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { z } from "zod";
-import { evidenceSchema, parseEvidence } from "./evidence.js";
-import { cliMetadataGuidSchema, managedMemberInspectionSchema, } from "./managedArtifact.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
-const boundedTextSchema = z.string().min(1);
-const managedRuntimeEffectSchema = z.enum([
-    "attach",
-    "load",
-    "debugger",
-    "reflection",
-    "instrumentation",
-]);
-const managedRuntimeHostSchema = z.strictObject({
-    os: z.enum(["linux", "macos", "windows"]),
-    clr_family: z.enum(["dotnet", "dotnet-framework", "mono", "unknown"]),
-    architecture: z.enum(["x86", "x86_64", "arm", "arm64"]),
-});
-const managedRuntimeBoundsSchema = z.strictObject({
-    timeout_ms: z.number().int().min(1).default(5_000),
-    max_threads: z.number().int().min(1).default(32),
-    max_output_bytes: z.number().int().min(0).default(65_536),
-    allow_network: z.literal(false).default(false),
-    allow_ui: z.literal(false).default(false),
-});
-export const managedRuntimeCorrelationInputSchema = z.strictObject({
-    static_members: evidenceSchema,
-    method: z.strictObject({
-        token: tokenSchema,
-        signature_sha256: digestSchema,
-        normalized_il_sha256: digestSchema.nullable(),
-    }),
-    requested_effect: managedRuntimeEffectSchema,
-    host: managedRuntimeHostSchema,
-    bounds: managedRuntimeBoundsSchema.default({
-        timeout_ms: 5_000,
-        max_threads: 32,
-        max_output_bytes: 65_536,
-        allow_network: false,
-        allow_ui: false,
-    }),
-});
-export const managedRuntimeCorrelationResultSchema = z.strictObject({
-    correlation_id: z.string().regex(/^mrc_[a-f0-9]{64}$/u),
-    phase: z.literal("admission-plan"),
-    executed: z.literal(false),
-    authority_model: z.strictObject({
-        capability: z.literal("managed_runtime"),
-        permission_grant_id: z.string().min(1),
-        default_enabled: z.literal(false),
-        per_call_approval_required: z.literal(true),
-    }),
-    static_observation: z.strictObject({
-        evidence_id: evidenceIdSchema,
-        artifact_sha256: digestSchema,
-        artifact_path: z.string().min(1),
-        byte_length: z.number().int().min(0),
-        module_name: z.string().nullable(),
-        mvid: cliMetadataGuidSchema.nullable(),
-        metadata_status: z.enum(["absent", "complete", "partial", "malformed"]),
-    }),
-    method_lock: z.strictObject({
-        token: tokenSchema,
-        declaring_type: z.string().nullable(),
-        name: z.string(),
-        signature_sha256: digestSchema,
-        normalized_il_sha256: digestSchema.nullable(),
-        body_sha256: digestSchema.nullable(),
-        il_size: z.number().int().min(0),
-        body_status: z.enum([
-            "present",
-            "partial",
-            "absent",
-            "malformed",
-            "too-large",
-        ]),
-        exact_build_required: z.literal(true),
-    }),
-    requested_runtime: z.strictObject({
-        effect: managedRuntimeEffectSchema,
-        host: managedRuntimeHostSchema,
-        executable_path: z.string().min(1),
-        network: z.literal("none"),
-        filesystem: z.literal("owned-artifacts-only"),
-    }),
-    effect_taxonomy: z.strictObject({
-        attaches_process: z.boolean(),
-        loads_target: z.boolean(),
-        uses_debugger: z.boolean(),
-        uses_reflection: z.boolean(),
-        instruments_code: z.boolean(),
-        invokes_target_code: z.literal(false),
-    }),
-    bounds: managedRuntimeBoundsSchema,
-    unsupported_until_executor_exists: z.literal(true),
-    evidence_links: z.array(evidenceIdSchema).length(1),
-    limitations: z.array(boundedTextSchema),
-});
-const sha256 = (value) => {
-    const serialized = canonicalize(value);
-    if (serialized === undefined)
-        throw new TypeError("Managed runtime correlation canonicalization failed");
-    return createHash("sha256").update(serialized).digest("hex");
-};
-/** Authenticate static managed Evidence and build a non-executing runtime plan. */
-export const planManagedRuntimeCorrelation = (input, executablePath, permissionGrantId) => {
-    const staticEvidence = parseEvidence(input.static_members);
-    if (staticEvidence.operation !== "inspect_managed_members")
-        throw new TypeError("Evidence operation is not inspect_managed_members");
-    const members = managedMemberInspectionSchema.parse(staticEvidence.normalized_result);
-    const method = members.methods.find((item) => item.token === input.method.token &&
-        item.signature.raw_sha256 === input.method.signature_sha256 &&
-        item.body.status === "present" &&
-        item.body.normalized_il_sha256 !== null &&
-        input.method.normalized_il_sha256 !== null &&
-        item.body.normalized_il_sha256 === input.method.normalized_il_sha256);
-    if (method === undefined)
-        throw new TypeError("Requested method lock does not match a static managed member observation");
-    const withoutId = {
-        phase: "admission-plan",
-        executed: false,
-        authority_model: {
-            capability: "managed_runtime",
-            permission_grant_id: permissionGrantId,
-            default_enabled: false,
-            per_call_approval_required: true,
-        },
-        static_observation: {
-            evidence_id: staticEvidence.evidence_id,
-            artifact_sha256: members.artifact.sha256,
-            artifact_path: members.artifact.path,
-            byte_length: members.artifact.byte_length,
-            module_name: members.module?.name ?? null,
-            mvid: members.module?.mvid ?? null,
-            metadata_status: members.metadata.status,
-        },
-        method_lock: {
-            token: method.token,
-            declaring_type: method.declaring_type,
-            name: method.name,
-            signature_sha256: method.signature.raw_sha256,
-            normalized_il_sha256: method.body.normalized_il_sha256,
-            body_sha256: method.body.il_sha256,
-            il_size: method.body.il_size,
-            body_status: method.body.status,
-            exact_build_required: true,
-        },
-        requested_runtime: {
-            effect: input.requested_effect,
-            host: input.host,
-            executable_path: executablePath,
-            network: "none",
-            filesystem: "owned-artifacts-only",
-        },
-        effect_taxonomy: effectTaxonomy(input.requested_effect),
-        bounds: input.bounds,
-        unsupported_until_executor_exists: true,
-        evidence_links: [staticEvidence.evidence_id],
-        limitations: [
-            "This operation admits and records a runtime-correlation plan only; it did not attach, load, debug, reflect, instrument, invoke, or execute target code.",
-            "Runtime agreement would be a separate runtime observation and would not retroactively turn static inference into a byte observation.",
-            "The exact artifact SHA-256, MVID, method signature, and normalized IL shape must match before any future executor can run.",
-            "Network and UI effects are not admitted by this contract.",
-        ],
-    };
-    return managedRuntimeCorrelationResultSchema.parse({
-        ...withoutId,
-        correlation_id: `mrc_${sha256(withoutId)}`,
-    });
-};
-const effectTaxonomy = (effect) => ({
-    attaches_process: effect === "attach",
-    loads_target: effect === "load" || effect === "reflection",
-    uses_debugger: effect === "debugger",
-    uses_reflection: effect === "reflection",
-    instruments_code: effect === "instrumentation",
-    invokes_target_code: false,
-});

package/dist/domain/nodeRuntimeCharacterization.js

@@ -1,63 +0,0 @@
-import { z } from "zod";
-import { controlledReplayExecutionOutputSchema, controlledReplayPlanInputSchema, controlledReplayPlanOutputSchema, } from "./javascriptReplay.js";
-import { javascriptExportInstrumentationInputSchema, javascriptExportTransformationManifestSchema, } from "./javascriptExportInstrumentation.js";
-import { runtimeCharacterizationPlanSchema } from "./runtimeCharacterization.js";
-import { evidenceRecordSchema } from "./evidence.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const nodeCharacterizationExpectedEffectSchema = z.enum([
-    "pure",
-    "observation-only",
-]);
-const nodeRuntimeCharacterizationPlanSchema = runtimeCharacterizationPlanSchema.extend({
-    expected_effect: nodeCharacterizationExpectedEffectSchema,
-});
-export const nodeCharacterizationPreparationInputSchema = z
-    .strictObject({
-    selected_alias: z.string().min(1),
-    expected_effect: nodeCharacterizationExpectedEffectSchema,
-    instrumentation: javascriptExportInstrumentationInputSchema,
-    replay: controlledReplayPlanInputSchema,
-})
-    .superRefine((input, context) => {
-    const selected = input.replay.left.modules.filter(({ alias }) => alias === input.selected_alias);
-    if (selected.length !== 1 ||
-        selected[0]?.path !== input.instrumentation.artifact_path ||
-        selected[0]?.format !== "commonjs-factory")
-        context.addIssue({
-            code: "custom",
-            path: ["selected_alias"],
-            message: "Selected alias must identify exactly one commonjs-factory instrumented artifact",
-        });
-    if (input.replay.left.entry_alias !== input.selected_alias)
-        context.addIssue({
-            code: "custom",
-            path: ["replay", "left", "entry_alias"],
-            message: "Instrumented alias must be the characterization entry",
-        });
-    if (input.replay.left.entry_export !==
-        input.instrumentation.selection.export_name)
-        context.addIssue({
-            code: "custom",
-            path: ["replay", "left", "entry_export"],
-            message: "Replay entry export must match the instrumented export",
-        });
-});
-export const nodeCharacterizationExecutionInputSchema = z.strictObject({
-    approved_plan_sha256: digestSchema,
-    preparation: nodeCharacterizationPreparationInputSchema,
-});
-export const nodeCharacterizationPreparationOutputSchema = z.strictObject({
-    phase: z.literal("preparation"),
-    plan: nodeRuntimeCharacterizationPlanSchema,
-    transformation: javascriptExportTransformationManifestSchema,
-    transformation_evidence: evidenceRecordSchema,
-    replay: controlledReplayPlanOutputSchema,
-});
-export const nodeCharacterizationExecutionOutputSchema = z.strictObject({
-    phase: z.literal("execution"),
-    plan: nodeRuntimeCharacterizationPlanSchema,
-    transformation: javascriptExportTransformationManifestSchema,
-    transformation_evidence: evidenceRecordSchema,
-    evidence: evidenceRecordSchema,
-    replay: controlledReplayExecutionOutputSchema,
-});