rea-agents 3.0.0 → 3.2.0

package/dist/domain/javascriptReplay.js

@@ -1,11 +1,10 @@
 import { z } from "zod";
 import { evidenceEnvelopeSchema } from "./evidence.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const absolutePathSchema = z.string().startsWith("/").max(4096);
+const absolutePathSchema = z.string().startsWith("/");
 const aliasSchema = z
     .string()
     .min(1)
-    .max(256)
     .regex(/^[A-Za-z0-9_./:@-]+$/u);
 const replayModuleSchema = z
     .object({
@@ -13,25 +12,20 @@ const replayModuleSchema = z
     path: absolutePathSchema,
     format: z.enum(["esm", "commonjs-factory"]),
     role: z.enum(["module", "stub"]).default("module"),
-    dependencies: z
-        .record(z.string().min(1).max(256), aliasSchema)
-        .refine((value) => Object.keys(value).length <= 128, {
-        message: "Replay modules may declare at most 128 dependencies",
-    })
-        .default({}),
+    dependencies: z.record(z.string().min(1), aliasSchema).default({}),
 })
     .strict();
 const replaySideSchema = z
     .object({
-    modules: z.array(replayModuleSchema).min(1).max(128),
+    modules: z.array(replayModuleSchema).min(1),
     entry_alias: aliasSchema,
-    entry_export: z.string().min(1).max(256).default("default"),
+    entry_export: z.string().min(1).default("default"),
 })
     .strict();
 const explicitCaseSchema = z
     .object({
-    case_id: z.string().min(1).max(128),
-    arguments: z.array(z.json()).max(16),
+    case_id: z.string().min(1),
+    arguments: z.array(z.json()),
 })
     .strict();
 const generatorSchema = z
@@ -42,58 +36,58 @@ const generatorSchema = z
         "clipboard-boundaries",
     ]),
     seed: z.number().int().min(0).max(0xffff_ffff),
-    count: z.number().int().min(1).max(64),
+    count: z.number().int().safe().min(1),
 })
     .strict();
 const replayLimitsSchema = z
     .object({
-    wall_time_ms: z.number().int().min(100).max(10_000).default(3_000),
+    wall_time_ms: z.number().int().safe().min(1).default(3_000),
     memory_bytes: z
         .number()
         .int()
-        .min(16 * 1024 * 1024)
-        .max(512 * 1024 * 1024)
+        .safe()
+        .positive()
         .default(128 * 1024 * 1024),
-    tasks: z.number().int().min(1).max(32).default(8),
-    cpu_quota_percent: z.number().int().min(1).max(100).default(50),
+    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()
-        .min(1024 * 1024)
-        .max(64 * 1024 * 1024)
+        .safe()
+        .min(1)
         .default(16 * 1024 * 1024),
     module_bytes: z
         .number()
         .int()
+        .safe()
         .min(1)
-        .max(16 * 1024 * 1024)
         .default(4 * 1024 * 1024),
     input_bytes: z
         .number()
         .int()
+        .safe()
         .min(1)
-        .max(1024 * 1024)
         .default(256 * 1024),
     protocol_bytes: z
         .number()
         .int()
-        .min(1024 * 1024)
-        .max(64 * 1024 * 1024)
+        .safe()
+        .min(1)
         .default(16 * 1024 * 1024),
     output_bytes: z
         .number()
         .int()
+        .safe()
         .min(1)
-        .max(4 * 1024 * 1024)
         .default(512 * 1024),
     stderr_bytes: z
         .number()
         .int()
+        .safe()
         .min(0)
-        .max(256 * 1024)
         .default(32 * 1024),
-    result_depth: z.number().int().min(1).max(64).default(16),
-    result_nodes: z.number().int().min(1).max(100_000).default(10_000),
+    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
@@ -105,12 +99,10 @@ const determinismSchema = z
     platform: z.literal("linux").default("linux"),
 })
     .strict();
-export const controlledReplayInputSchema = z
-    .object({
-    mode: z.enum(["plan", "execute"]),
+const controlledReplayInputShape = {
     left: replaySideSchema,
     right: replaySideSchema.optional(),
-    cases: z.array(explicitCaseSchema).max(128).default([]),
+    cases: z.array(explicitCaseSchema).default([]),
     generator: generatorSchema.optional(),
     determinism: determinismSchema.default({
         clock_iso: "2000-01-01T00:00:00.000Z",
@@ -133,18 +125,30 @@ export const controlledReplayInputSchema = z
         result_depth: 16,
         result_nodes: 10_000,
     }),
-    approved: z.boolean().default(false),
-    plan_digest: digestSchema.optional(),
     reproducer_export: z
-        .object({
+        .strictObject({
         path: absolutePathSchema,
-        approved: z.boolean(),
         include_sources: z.boolean().default(false),
     })
-        .strict()
         .optional(),
-})
-    .strict()
+};
+/** 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({
@@ -152,19 +156,6 @@ export const controlledReplayInputSchema = z
             path: ["cases"],
             message: "At least one explicit or generated case is required",
         });
-    if (value.cases.length + (value.generator?.count ?? 0) > 128)
-        context.addIssue({
-            code: "custom",
-            path: ["generator", "count"],
-            message: "Explicit and generated replay cases must total at most 128",
-        });
-    if (value.mode === "execute" &&
-        (value.approved !== true || value.plan_digest === undefined))
-        context.addIssue({
-            code: "custom",
-            path: ["approved"],
-            message: "Execution requires literal approval and a plan digest",
-        });
 });
 const moduleCommitmentSchema = z
     .object({
@@ -193,7 +184,6 @@ const runtimeFileIdentitySchema = z
     .strict();
 const replayPlanSchema = z
     .object({
-    schema_version: z.literal(1),
     plan_digest: digestSchema,
     policy_version: z.literal("linux-bwrap-systemd-v1"),
     policy_sha256: digestSchema,
@@ -201,7 +191,7 @@ const replayPlanSchema = z
     filesystem: z
         .object({
         host_writes: z.literal(false),
-        private_tmpfs_bytes: z.number().int(),
+        private_tmpfs_bytes: z.number().int().nonnegative(),
     })
         .strict(),
     runtime: z
@@ -249,43 +239,52 @@ const replayPlanSchema = z
         .object({
         path: z.string().min(1),
         include_sources: z.boolean(),
-        authority: z.literal("evidence_write"),
     })
         .strict()
         .nullable(),
 })
     .strict();
-const replayOutcomeSchema = z
-    .object({
+const replayOutcomeFacts = {
     case_id: z.string(),
-    outcome: z.enum([
-        "return",
-        "exception",
-        "serialization_error",
-        "denied",
-        "timeout",
-        "oom",
-        "crash",
-        "cancelled",
-        "protocol_error",
-    ]),
-    value: z.json().optional(),
-    exception: z
-        .object({
-        name: z.string(),
-        message: z.string(),
-        stack: z.string().nullable(),
-    })
-        .strict()
-        .optional(),
     input_sha256: digestSchema,
-    output_sha256: digestSchema.nullable(),
-    truncated: z.boolean(),
+};
+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({
-    schema_version: z.literal(1),
     plan_digest: digestSchema,
     outcomes: z.array(replayOutcomeSchema),
     comparison: z
@@ -337,25 +336,25 @@ export const replayExecutionResultSchema = z
 export const replayEvidenceSchema = evidenceEnvelopeSchema
     .omit({ normalized_result: true })
     .extend({ normalized_result: replayExecutionResultSchema });
-export const controlledReplayOutputSchema = z
-    .object({
-    phase: z.enum(["plan", "execute"]),
-    plan: replayPlanSchema.nullable(),
-    source_evidence: z.array(replayEvidenceSchema),
-    evidence: replayEvidenceSchema.nullable(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if ((value.phase === "plan" &&
-        (value.plan === null ||
-            value.evidence !== null ||
-            value.source_evidence.length !== 0)) ||
-        (value.phase === "execute" &&
-            (value.plan !== null ||
-                value.evidence === null ||
-                value.source_evidence.length === 0)))
-        context.addIssue({
-            code: "custom",
-            message: "Replay output phase does not match its payload",
-        });
+/** 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/javascriptRuntimeLoadState.js

@@ -3,21 +3,16 @@ import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeSc
 /** Classify static code presence without claiming bundled module execution. */
 export const classifyStaticLoadStates = (layers, runtimeEntities, matches, options) => {
     const states = [];
-    let totalStates = 0;
     for (const layer of layers) {
         const projection = classifyLayer(layer, runtimeEntities, matches, {
             reconciliationComplete: options.reconciliationComplete,
-            maximumStates: Math.max(0, options.maximumStates - states.length),
         });
-        totalStates += projection.total;
         states.push(...projection.states);
     }
-    return { states, omittedStates: totalStates - states.length };
+    return { states, omittedStates: 0 };
 };
 const classifyLayer = (layer, runtimeEntities, matches, options) => {
     const nodes = layer.graph.nodes.filter(isLoadStateNode);
-    if (options.maximumStates === 0)
-        return { states: [], total: nodes.length };
     const direct = new Map();
     for (const match of matches)
         if (match.status === "matched" &&
@@ -31,7 +26,7 @@ const classifyLayer = (layer, runtimeEntities, matches, options) => {
         layer.graph.coverage.status === "complete" &&
         scopedEntities.length > 0 &&
         scopedEntities.every(({ capture }) => captureScriptsComplete(capture.evidence.evidence_id, runtimeEntities));
-    const states = nodes.slice(0, options.maximumStates).map((node) => {
+    const states = nodes.map((node) => {
         const runtimeNodeIds = uniqueSorted(direct.get(node.node_id) ?? []);
         if (runtimeNodeIds.length > 0)
             return state(layer, node, {
@@ -60,7 +55,7 @@ const classifyLayer = (layer, runtimeEntities, matches, options) => {
                 : "static-or-runtime-coverage-incomplete",
         });
     });
-    return { states, total: nodes.length };
+    return { states };
 };
 const residentNodes = (layer, directlyLoaded) => {
     const nodeKinds = new Map(layer.graph.nodes.map(({ node_id: id, kind }) => [id, kind]));

package/dist/domain/javascriptRuntimeObservation.js

@@ -1,147 +1,89 @@
-import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
-import { browserEndpointSchema, browserOriginSchema, } from "./browserObservation.js";
-const boundedTextSchema = z.string().min(1).max(4_096);
-const runtimeFileRootsSchema = z
-    .array(z
-    .string()
-    .min(1)
-    .max(16_384)
-    .refine(isAbsolute, "Runtime file roots must be absolute paths")
-    .overwrite(resolve))
-    .max(32)
-    .overwrite((roots) => [...new Set(roots)].sort())
-    .default([]);
-const runtimeOriginsSchema = z
-    .array(browserOriginSchema)
-    .max(32)
-    .overwrite((origins) => [...new Set(origins)].sort())
-    .default([]);
-const approvedRuntimeScope = {
+import { browserEndpointSchema } from "./browserObservation.js";
+const observationTextSchema = z.string().min(1);
+const runtimeEndpoint = {
     inspector_endpoint: browserEndpointSchema,
-    allowed_file_roots: runtimeFileRootsSchema,
-    allowed_origins: runtimeOriginsSchema,
-    approved: z.literal(true),
 };
-const requireRuntimeScope = (input, context) => {
-    if (input.allowed_file_roots.length === 0 &&
-        input.allowed_origins.length === 0)
-        context.addIssue({
-            code: "custom",
-            path: ["allowed_file_roots"],
-            message: "At least one exact file root or HTTP(S) origin is required",
-        });
-};
-/** Input for listing approved Node/Electron V8 Inspector targets. */
-export const listJavaScriptRuntimeTargetsInputSchema = z
-    .strictObject({
-    ...approvedRuntimeScope,
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(200).default(100),
-})
-    .superRefine(requireRuntimeScope);
+/** Input for listing targets exposed by an explicit Node/Electron Inspector endpoint. */
+export const listJavaScriptRuntimeTargetsInputSchema = z.strictObject({
+    ...runtimeEndpoint,
+});
 export const javascriptRuntimeKindSchema = z.enum([
     "node",
     "electron-main",
     "electron-preload",
     "electron-renderer",
 ]);
-export const javascriptRuntimeObservationLimitsSchema = z.strictObject({
-    max_events: z.number().int().min(1).max(50_000).default(10_000),
-    max_scripts: z.number().int().min(1).max(10_000).default(2_000),
-    max_execution_contexts: z.number().int().min(1).max(5_000).default(1_000),
-    max_location_bytes: z.number().int().min(64).max(65_536).default(16_384),
-    max_total_metadata_bytes: z
-        .number()
-        .int()
-        .min(1_024)
-        .max(32 * 1_024 * 1_024)
-        .default(4 * 1_024 * 1_024),
-});
+const observedJavaScriptRuntimeKindSchema = javascriptRuntimeKindSchema.or(z.literal("unknown"));
 /** Input for one bounded, attach-only V8 Inspector observation. */
-export const observeJavaScriptRuntimeInputSchema = z
-    .strictObject({
-    ...approvedRuntimeScope,
-    target_id: z.string().trim().min(1).max(256),
-    runtime_kind: javascriptRuntimeKindSchema,
-    observation_ms: z.number().int().min(0).max(10_000).default(100),
-    limits: javascriptRuntimeObservationLimitsSchema.default({
-        max_events: 10_000,
-        max_scripts: 2_000,
-        max_execution_contexts: 1_000,
-        max_location_bytes: 16_384,
-        max_total_metadata_bytes: 4 * 1_024 * 1_024,
-    }),
-})
-    .superRefine(requireRuntimeScope);
+/** Input for one passive attach-only V8 Inspector observation. */
+export const observeJavaScriptRuntimeInputSchema = z.strictObject({
+    ...runtimeEndpoint,
+    target_id: z.string().trim().min(1),
+    runtime_kind: javascriptRuntimeKindSchema.optional(),
+    observation_ms: z.number().int().min(0).default(100),
+});
 export const javascriptRuntimeVersionSchema = z.strictObject({
-    product: z.string().min(1).max(1_024),
-    protocol_version: z.string().min(1).max(100),
-    v8_version: z.string().max(1_024).nullable(),
+    product: z.string().min(1),
+    protocol_version: z.string().min(1),
+    v8_version: z.string().nullable(),
 });
 export const javascriptRuntimeLocationSchema = z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("file"),
-        file_path: z.string().min(1).max(16_384),
+        file_path: z.string().min(1),
+        authority: z.literal("scope-fallback").optional(),
     }),
     z.strictObject({
         kind: z.literal("url"),
-        origin: z.string().min(1).max(2_048),
-        sanitized_url: z.string().min(1).max(65_536),
+        origin: z.string().min(1),
+        sanitized_url: z.string().min(1),
     }),
     z.strictObject({
         kind: z.literal("builtin"),
-        specifier: z.string().min(1).max(4_096),
+        specifier: z.string().min(1),
     }),
 ]);
 const javascriptRuntimeTargetSchema = z.strictObject({
-    target_id: z.string().min(1).max(256),
-    protocol_type: z.string().min(1).max(100),
+    target_id: z.string().min(1),
+    protocol_type: z.string().min(1),
     attached: z.boolean(),
     location: javascriptRuntimeLocationSchema,
 });
-/** Root/origin-filtered V8 Inspector target inventory. */
+/** Complete V8 Inspector target inventory exposed by the selected endpoint. */
 export const javascriptRuntimeTargetListSchema = z.strictObject({
-    schema_version: z.literal(1),
     runtime: javascriptRuntimeVersionSchema,
-    targets: z.strictObject({
-        items: z.array(javascriptRuntimeTargetSchema),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-        has_more: z.boolean(),
-    }),
+    targets: z.array(javascriptRuntimeTargetSchema),
     excluded: z.strictObject({
-        outside_file_roots: z.number().int().min(0),
-        outside_origins: z.number().int().min(0),
         unsupported_location: z.number().int().min(0),
         unconnectable: z.number().int().min(0),
     }),
-    limitations: z.array(boundedTextSchema).max(100),
+    limitations: z.array(observationTextSchema),
 });
 const javascriptRuntimeScriptSchema = z.strictObject({
     script_key: z.string().regex(/^v8_script_[a-f0-9]{64}$/u),
     location: javascriptRuntimeLocationSchema,
-    execution_context_key: z.string().max(64).nullable(),
-    cdp_hash: z.string().max(512).nullable(),
+    execution_context_key: z.string().nullable(),
+    cdp_hash: z.string().nullable(),
     length: z.number().int().min(0),
     is_module: z.boolean(),
     status: z.literal("observed-loaded"),
 });
 const javascriptRuntimeContextSchema = z.strictObject({
-    context_key: z.string().min(1).max(64),
+    context_key: z.string().min(1),
     state: z.enum(["created", "destroyed", "cleared"]),
-    name: z.string().max(1_024).nullable(),
-    origin: z.string().max(4_096).nullable(),
+    name: z.string().nullable(),
+    origin: z.string().nullable(),
 });
 /** Deterministic passive script/context snapshot from one bounded window. */
 export const javascriptRuntimeObservationSchema = z.strictObject({
-    schema_version: z.literal(1),
     runtime: javascriptRuntimeVersionSchema,
     target: javascriptRuntimeTargetSchema.extend({
-        runtime_kind: javascriptRuntimeKindSchema,
-        runtime_kind_authority: z.literal("caller-declared-unverified"),
+        runtime_kind: observedJavaScriptRuntimeKindSchema,
+        runtime_kind_authority: z.enum([
+            "caller-declared-unverified",
+            "not-declared",
+        ]),
     }),
     capture: z.strictObject({
         observation_ms: z.number().int().min(0),
@@ -150,21 +92,19 @@ export const javascriptRuntimeObservationSchema = z.strictObject({
         events_dropped: z.number().int().min(0),
         metadata_bytes_retained: z.number().int().min(0),
         truncated: z.boolean(),
-        truncation_reasons: z.array(boundedTextSchema).max(20),
+        truncation_reasons: z.array(observationTextSchema),
     }),
     scripts: z.strictObject({
         items: z.array(javascriptRuntimeScriptSchema),
         observed_total: z.number().int().min(0),
         excluded: z.strictObject({
-            outside_file_roots: z.number().int().min(0),
-            outside_origins: z.number().int().min(0),
             unsupported_location: z.number().int().min(0),
             invalid_protocol_value: z.number().int().min(0),
         }),
     }),
     execution_contexts: z.array(javascriptRuntimeContextSchema),
-    directly_observed: z.array(boundedTextSchema).max(20),
-    unavailable_without_instrumentation: z.array(boundedTextSchema).max(20),
-    unknowns: z.array(boundedTextSchema).max(100),
-    limitations: z.array(boundedTextSchema).max(100),
+    directly_observed: z.array(observationTextSchema),
+    unavailable_without_instrumentation: z.array(observationTextSchema),
+    unknowns: z.array(observationTextSchema),
+    limitations: z.array(observationTextSchema),
 });

package/dist/domain/javascriptRuntimeReconciliation.js

@@ -11,16 +11,14 @@ export const reconcileJavaScriptRuntime = (input) => {
     const parsed = reconcileJavaScriptRuntimeInputSchema.parse(input);
     const layers = parseStaticLayers(parsed.static_layers);
     const captures = parseRuntimeCaptures(parsed.runtime_observations);
-    const runtime = projectRuntimeCaptures(captures, parsed.limits.max_runtime_entities);
+    const runtime = projectRuntimeCaptures(captures);
     const candidates = collectStaticRuntimeCandidates(layers);
     const matching = reconcileRuntimeEntities({
         entities: runtime.entities,
         candidates,
         layers,
-        maximumItems: parsed.limits.max_reconciliation_items,
     });
     const loadStates = classifyStaticLoadStates(layers, runtime.entities, matching.items, {
-        maximumStates: parsed.limits.max_static_load_states,
         reconciliationComplete: runtime.omittedEntities === 0 && matching.omittedItems === 0,
     });
     const graph = buildReconciledApplicationGraph({