rea-agents 6.3.0 → 6.4.0

package/dist/domain/native/nativeInstruction.js

@@ -12,6 +12,27 @@ const reference = z.strictObject({
     indirect: z.boolean(),
     computed: z.boolean(),
     operand_index: z.number().int(),
+    source_address: z.string().min(1).nullable().optional(),
+    data: z.boolean().nullable().optional(),
+    read: z.boolean().nullable().optional(),
+    write: z.boolean().nullable().optional(),
+    primary: z
+        .boolean()
+        .nullable()
+        .optional()
+        .describe("Provider primary-reference status, not proof of literal addressing or a runtime access. Null or omission means unavailable."),
+    provenance: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("Provider subsystem reporting this reference; null or omission means unavailable."),
+    source: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("Provider reference origin, such as analysis, default, imported or user_defined; null or omission means unavailable."),
 });
 /** Provider-decoded facts for one instruction; operand tokens preserve their native ordering. */
 export const nativeInstructionSchema = z.strictObject({

package/dist/domain/native/nativeMetadataRecovery.js

@@ -4,6 +4,8 @@ const relatedType = z.strictObject({ address, type: z.string().nullable() });
 /** Runtime-format metadata recovered in an analysis image, with explicit inference boundaries. */
 export const nativeMetadataRecoverySchema = z.strictObject({
     format: z.literal("dotnet-nativeaot"),
+    /** Identifies parser-only facts without claiming Ghidra defined a DataType. */
+    source: z.enum(["analysis-database", "read-only-derived-overlay"]).optional(),
     status: z.enum(["complete", "partial"]),
     header_address: address,
     format_major: z.number().int().nonnegative(),
@@ -21,18 +23,25 @@ export const nativeMetadataRecoverySchema = z.strictObject({
         procedure_name: z.string().nullable(),
         basis: z.literal("method-table-pointer"),
     })),
-    derived_memory: z.strictObject({
+    derived_memory: z
+        .strictObject({
         address,
         size_bytes: z.number().int().nonnegative(),
         sha256: z.string().regex(/^[a-f0-9]{64}$/u),
         file_offset: z.null(),
-    }),
+    })
+        .nullable(),
+    truncated: z.boolean().optional(),
+    virtual_slots_omitted: z.number().int().nonnegative().optional(),
+    interfaces_omitted: z.number().int().nonnegative().optional(),
+    output_budget_bytes: z.number().int().nonnegative().optional(),
     diagnostics: z.array(z.string()),
     limitations: z.array(z.string()),
 });
 /** Discover a recovered runtime format and reusable type identities from the loaded image. */
 export const nativeMetadataRecoverySummarySchema = z.strictObject({
     format: z.literal("dotnet-nativeaot"),
+    analysis_mode: z.literal("read-only-derived-overlay").optional(),
     status: z.enum(["complete", "partial", "not_applicable"]),
     reason: z.string().nullable(),
     analysis_artifact_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
@@ -42,12 +51,76 @@ export const nativeMetadataRecoverySummarySchema = z.strictObject({
     format_minor: z.number().int().nonnegative().nullable(),
     method_tables: z.number().int().nonnegative(),
     types: z.array(relatedType),
-    derived_memory: nativeMetadataRecoverySchema.shape.derived_memory.nullable(),
+    frozen_strings: z
+        .array(z.strictObject({ address, value: z.string() }))
+        .optional(),
+    truncated: z.boolean().optional(),
+    types_omitted: z.number().int().nonnegative().optional(),
+    frozen_strings_omitted: z.number().int().nonnegative().optional(),
+    output_budget_bytes: z.number().int().nonnegative().optional(),
+    derived_overlay: z
+        .strictObject({
+        address,
+        size_bytes: z.number().int().nonnegative(),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    })
+        .nullable()
+        .optional(),
+    derived_memory: nativeMetadataRecoverySchema.shape.derived_memory,
     coverage: z
         .strictObject({
-        frozen_object_candidates: z.number().int().nonnegative(),
-        frozen_objects_annotated: z.number().int().nonnegative(),
-        basis: z.literal("rehydrated-pointer-candidates-and-committed-instance-types"),
+        frozen_object_candidates: z.number().int().nonnegative().optional(),
+        frozen_objects_annotated: z.number().int().nonnegative().optional(),
+        pointer_candidates_examined: z.number().int().nonnegative().optional(),
+        pointer_slots_examined: z.number().int().nonnegative().optional(),
+        scan_bytes_examined: z.number().int().nonnegative().optional(),
+        scan_bytes_omitted: z.number().int().nonnegative().optional(),
+        rtr_signature_scan_bytes_examined: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional(),
+        rtr_signature_scan_bytes_omitted: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional(),
+        method_table_validation_items_examined: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional(),
+        work_units_examined: z.number().int().nonnegative().optional(),
+        method_tables_recovered: z.number().int().nonnegative().optional(),
+        frozen_string_candidates: z.number().int().nonnegative().optional(),
+        frozen_scan_bytes_examined: z.number().int().nonnegative().optional(),
+        frozen_scan_bytes_omitted: z.number().int().nonnegative().optional(),
+        frozen_string_data_bytes_examined: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional(),
+        source_bytes_examined: z.number().int().nonnegative().optional(),
+        source_bytes_omitted: z.number().int().nonnegative().optional(),
+        source_byte_budget_bytes: z.number().int().nonnegative().optional(),
+        work_budget_units: z.number().int().nonnegative().optional(),
+        working_memory_budget_bytes: z.number().int().nonnegative().optional(),
+        working_memory_bytes_peak: z.number().int().nonnegative().optional(),
+        truncation_reason: z
+            .enum([
+            "source-byte-budget",
+            "work-unit-budget",
+            "working-memory-budget",
+            "response-budget",
+        ])
+            .optional(),
+        basis: z.enum([
+            "rehydrated-pointer-candidates-and-committed-instance-types",
+            "raw-image-pointer-scan",
+            "raw-image-and-rehydrated-pointer-scan",
+            "unsupported-layout",
+            "no-rtr-header",
+        ]),
     })
         .nullable(),
     diagnostics: z.array(z.string()),

package/dist/domain/native/peResources.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+const uint = z.number().int().min(0).max(0xffffffff);
+const range = z.strictObject({ offset: uint, bytes: uint });
+const identity = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("id"), id: uint }),
+    z.strictObject({
+        kind: z.literal("name"),
+        name: z.string(),
+        utf16le_hex: z.string().regex(/^(?:[0-9a-f]{4})*$/),
+        location: range,
+    }),
+]);
+/** Complete bounded inspection of a caller-selected PE image, without execution. */
+export const inspectPeResourcesInputSchema = z.strictObject({
+    path: z.string().min(1).describe("Absolute filesystem path to a PE image"),
+    max_file_bytes: z
+        .number()
+        .int()
+        .min(64)
+        .max(536870912)
+        .default(67108864)
+        .describe("Maximum stable artifact bytes to read (default 64 MiB)"),
+    max_entries: z
+        .number()
+        .int()
+        .min(1)
+        .max(65536)
+        .default(4096)
+        .describe("Maximum resource directory entries to examine; exceeding the budget fails without partial success"),
+});
+/** Original file/RVA locations and resource identities; icon edges are static relationships. */
+export const peResourcesSchema = z.strictObject({
+    artifact: z.strictObject({
+        path: z.string().min(1),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/),
+        bytes: uint,
+    }),
+    format: z.enum(["pe32", "pe32-plus"]),
+    machine: uint,
+    directory: z
+        .strictObject({
+        rva: uint,
+        location: range,
+        data_directory_location: range,
+    })
+        .nullable(),
+    directories: z.array(z.strictObject({
+        location: range,
+        characteristics: uint,
+        timestamp: uint,
+        major_version: uint,
+        minor_version: uint,
+        named_entries: uint,
+        id_entries: uint,
+    })),
+    resources: z.array(z.strictObject({
+        index: uint,
+        type: identity,
+        name: identity,
+        language: identity,
+        entry_locations: z.array(range).length(3),
+        data_entry_location: range,
+        code_page: uint,
+        reserved: uint,
+        payload: z.strictObject({
+            rva: uint,
+            location: range,
+            sha256: z.string().regex(/^[a-f0-9]{64}$/),
+        }),
+    })),
+    icon_groups: z.array(z.strictObject({
+        resource_index: uint,
+        images: z.array(z.strictObject({
+            location: range,
+            width: uint,
+            height: uint,
+            color_count: uint,
+            reserved: uint,
+            planes: uint,
+            bit_count: uint,
+            declared_bytes: uint,
+            resource_id: uint,
+            candidate_resource_indices: z.array(uint),
+            same_language_resource_index: uint.nullable(),
+            size_matches: z.boolean().nullable(),
+        })),
+    })),
+    coverage: z.strictObject({
+        status: z.literal("complete"),
+        examined_entries: uint,
+        resources: uint,
+    }),
+    limitations: z.array(z.string()),
+});

package/dist/domain/nativeConvention.js

@@ -0,0 +1,33 @@
+/** Path-segment conventions. These are inferences, not observations of runtime behavior. */
+const foldSegment = (segment) => segment.toLocaleLowerCase("en-US");
+const REACT_NATIVE_SEGMENTS = new Set([
+    "react.framework",
+    "reactnative.framework",
+    "libreactnative.so",
+    "libreactnativejni.so",
+    "libhermes_executor.so",
+    "libhermes.so",
+    "hermes.framework",
+]);
+const FLUTTER_SEGMENTS = new Set(["libflutter.so", "flutter.framework"]);
+const UNITY_SEGMENTS = new Set(["libunity.so", "unityframework.framework"]);
+/**
+ * A runtime family named by one filename or directory segment.
+ * Only recognized complete library and framework names establish a convention.
+ */
+export const nativeRuntimeConvention = (path) => {
+    for (const segment of path.split("/")) {
+        const folded = foldSegment(segment);
+        if (REACT_NATIVE_SEGMENTS.has(folded))
+            return "react-native";
+        if (FLUTTER_SEGMENTS.has(folded))
+            return "flutter";
+        if (UNITY_SEGMENTS.has(folded))
+            return "unity";
+    }
+    return null;
+};
+/** Swift runtime libraries are `libswift*.dylib` segments, not every dynamic library. */
+export const isSwiftRuntimeLibrary = (path) => path
+    .split("/")
+    .some((segment) => /^libswift.+\.dylib$/u.test(foldSegment(segment)));

package/dist/domain/process/processCapture.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { jsonValueSchema } from "../jsonValue.js";
 import { normalizationSchema } from "./processScenario.js";
-import { collectProcessCaptureIssues } from "./processCaptureValidation.js";
+import { collectProcessCaptureIssues, finalizationAgreementIssue, finalizationConsistencyIssue, finalizationManifestIssue, } from "./processCaptureValidation.js";
 import { filesystemCoverageSchema, processCaptureTruncationDetailsSchema, } from "./processCaptureCoverage.js";
 /** Capture collection whose members participate in global observation order. */
 export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
@@ -88,6 +88,40 @@ const processSettlementSchema = z.discriminatedUnion("state", [
     }),
 ]);
 const unverifiedCleanupProcessesSchema = z.array(z.strictObject({ pid: z.number().int().positive(), reason: z.string() }));
+const processCaptureFinalizationSchema = z
+    .strictObject({
+    requested_ms: z.number().int().safe().positive(),
+    elapsed_ms: z.number().int().nonnegative().nullable(),
+    exit_code: z.number().int().nonnegative().nullable(),
+    signals: z
+        .array(z.strictObject({
+        signal: z.enum(["SIGTERM", "SIGKILL"]),
+        sent_at_ms: z.number().int().nonnegative(),
+        delivery: z.enum([
+            "signaled",
+            "gone",
+            "identity-changed",
+            "unverified",
+        ]),
+        reason: z.string().min(1).optional(),
+    }))
+        .min(1),
+})
+    .superRefine((finalization, context) => {
+    if (finalization.exit_code !== null && finalization.elapsed_ms === null)
+        context.addIssue({
+            code: "custom",
+            path: ["exit_code"],
+            message: "finalization exit_code requires an observed exit",
+        });
+    for (const [index, attempt] of finalization.signals.entries())
+        if (attempt.reason !== undefined && attempt.delivery !== "unverified")
+            context.addIssue({
+                code: "custom",
+                path: ["signals", index, "reason"],
+                message: "finalization reason is only allowed for an unverified delivery",
+            });
+});
 const processCaptureShapeSchema = z.strictObject({
     manifest: z.strictObject({
         rea_version: z.string().min(1),
@@ -145,6 +179,7 @@ const processCaptureShapeSchema = z.strictObject({
         code: z.number().int().nullable(),
         signal: z.number().int().nullable(),
         reason: z.enum(["exited", "timeout", "idle_timeout"]),
+        finalization: processCaptureFinalizationSchema.optional(),
     }),
     settlement: z.discriminatedUnion("state", [
         z.object({
@@ -221,7 +256,9 @@ const incompleteProcessCaptureObservationsSchema = z.strictObject({
         code: z.number().int().nullable(),
         signal: z.number().int().nullable(),
         reason: z.enum(["exited", "timeout", "idle_timeout", "cancelled"]),
+        finalization: processCaptureFinalizationSchema.optional(),
     })),
+    finalization: partialObservationFieldSchema(processCaptureFinalizationSchema).optional(),
     settlement: partialObservationFieldSchema(z.strictObject({
         state: z.enum(["quiesced", "alive_at_deadline", "unverifiable"]),
         elapsed_ms: z.number().int().nonnegative(),
@@ -265,6 +302,59 @@ export const partialProcessCaptureObservationSchema = z
             path: ["execution_failure"],
             message: "partial observations require incomplete cleanup or an execution failure",
         });
+    const observedExit = "capture" in partial
+        ? partial.capture.exit
+        : partial.observations.exit.state === "available"
+            ? partial.observations.exit.value
+            : undefined;
+    const observedFinalization = "observations" in partial &&
+        partial.observations.finalization?.state === "available"
+        ? partial.observations.finalization.value
+        : undefined;
+    const committedManifest = "capture" in partial
+        ? partial.capture.manifest
+        : partial.observations.manifest.state === "available"
+            ? partial.observations.manifest.value
+            : undefined;
+    const manifestFinalizationIssue = finalizationManifestIssue(committedManifest?.scenario, committedManifest?.comparison_contract);
+    const exitFinalizationIssue = manifestFinalizationIssue ??
+        (observedExit === undefined
+            ? undefined
+            : finalizationConsistencyIssue(observedExit, committedManifest?.scenario, committedManifest?.comparison_contract));
+    const incompleteFinalizationIssue = manifestFinalizationIssue ??
+        (observedFinalization === undefined
+            ? undefined
+            : finalizationConsistencyIssue(observedExit === undefined
+                ? undefined
+                : { reason: observedExit.reason, signal: observedExit.signal }, committedManifest?.scenario, committedManifest?.comparison_contract, { finalization: observedFinalization, allowNullElapsedMs: true }));
+    if (exitFinalizationIssue !== undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["exit"],
+            message: exitFinalizationIssue,
+        });
+    if (incompleteFinalizationIssue !== undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["finalization"],
+            message: incompleteFinalizationIssue,
+        });
+    const agreementIssue = finalizationAgreementIssue(observedExit?.finalization, observedFinalization);
+    if (agreementIssue !== undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["finalization"],
+            message: agreementIssue,
+        });
+    if ("observations" in partial &&
+        partial.observations.exit.state === "unavailable" &&
+        observedFinalization !== undefined &&
+        observedFinalization?.elapsed_ms !== null)
+        context.addIssue({
+            code: "custom",
+            path: ["finalization"],
+            message: "finalization elapsed_ms must be null when the exit observation is unavailable",
+        });
     if ("observations" in partial) {
         const { observations } = partial;
         if (![

package/dist/domain/process/processCaptureExample.js

@@ -106,3 +106,27 @@ export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
         temporary_root: "removed",
     },
 };
+const finalizedScenario = { ...scenario, finalization_ms: 1_500 };
+const finalizedComparisonContract = { finalization_ms: 1_500 };
+/** Valid capture of a timeout that finalized: SIGTERM delivered, exit observed. */
+export const FINALIZED_PROCESS_CAPTURE_EXAMPLE = {
+    ...EMPTY_PROCESS_CAPTURE_EXAMPLE,
+    manifest: {
+        ...EMPTY_PROCESS_CAPTURE_EXAMPLE.manifest,
+        scenario: finalizedScenario,
+        comparison_contract: finalizedComparisonContract,
+        full_scenario_sha256: digestProcessCommitment(finalizedScenario),
+        comparison_contract_sha256: digestProcessCommitment(finalizedComparisonContract),
+    },
+    exit: {
+        code: null,
+        signal: 0,
+        reason: "timeout",
+        finalization: {
+            requested_ms: 1_500,
+            elapsed_ms: 12,
+            exit_code: 0,
+            signals: [{ signal: "SIGTERM", sent_at_ms: 0, delivery: "signaled" }],
+        },
+    },
+};

package/dist/domain/process/processCaptureValidation.js

@@ -64,6 +64,83 @@ const validateEventJournal = (capture, require) => {
     require(journal.length ===
         expectedSize, "event_journal", "nonempty journal must reference every captured observation");
 };
+/**
+ * The committed comparison contract carries `finalization_ms` exactly when the
+ * committed scenario does, with the same value. Independent of the exit, so a
+ * partial capture with an unavailable exit is still checked.
+ */
+export const finalizationManifestIssue = (committedScenario, committedComparison) => committedScenario !== undefined &&
+    committedComparison !== undefined &&
+    committedScenario["finalization_ms"] !==
+        committedComparison["finalization_ms"]
+    ? "comparison_contract finalization_ms must match the committed scenario"
+    : undefined;
+/** Ensure incomplete exit and sibling finalization observations preserve one fact. */
+export const finalizationAgreementIssue = (exitFinalization, observedFinalization) => exitFinalization !== undefined &&
+    observedFinalization !== undefined &&
+    JSON.stringify(exitFinalization) !== JSON.stringify(observedFinalization)
+    ? "exit finalization and finalization observation must agree"
+    : undefined;
+/**
+ * Cross-field rule for `exit.finalization`, shared by complete and partial
+ * captures. Returns the violated rule, or undefined when the record is
+ * consistent.
+ */
+export const finalizationConsistencyIssue = (exit, committedScenario, committedComparison, options) => {
+    const manifestIssue = finalizationManifestIssue(committedScenario, committedComparison);
+    if (manifestIssue !== undefined)
+        return manifestIssue;
+    const finalization = exit?.finalization ?? options?.finalization;
+    if (finalization === undefined) {
+        // A deadline that fired under a committed interval must have attempted
+        // finalization; cancellation before the deadline legitimately has none.
+        const committed = committedScenario?.["finalization_ms"];
+        return (exit?.reason === "timeout" || exit?.reason === "idle_timeout") &&
+            typeof committed === "number" &&
+            committed > 0
+            ? "a deadline exit under a committed finalization_ms requires finalization evidence"
+            : undefined;
+    }
+    if (exit?.reason === "exited")
+        return "finalization requires a deadline exit reason";
+    const first = finalization.signals[0];
+    if (first?.signal !== "SIGTERM")
+        return "finalization signals must start with SIGTERM";
+    const killIndexes = finalization.signals.flatMap(({ signal }, index) => signal === "SIGKILL" ? [index] : []);
+    if (killIndexes.length > 1 ||
+        (killIndexes[0] !== undefined &&
+            killIndexes[0] !== finalization.signals.length - 1))
+        return "finalization may contain at most one final SIGKILL";
+    if (!finalization.signals.every(({ sent_at_ms }, index) => {
+        const previous = finalization.signals[index - 1];
+        return previous === undefined || sent_at_ms >= previous.sent_at_ms;
+    }))
+        return "finalization signal attempt times must not decrease";
+    if (finalization.signals.filter(({ signal }) => signal === "SIGTERM").length !==
+        1)
+        return "finalization must attempt SIGTERM exactly once";
+    const kill = finalization.signals.find(({ signal }) => signal === "SIGKILL");
+    if (kill !== undefined &&
+        kill.sent_at_ms < finalization.requested_ms &&
+        exit !== undefined &&
+        exit.reason !== "cancelled")
+        return "finalization SIGKILL cannot precede the requested interval";
+    if (finalization.elapsed_ms === null && options?.allowNullElapsedMs !== true)
+        return "finalization requires an observed elapsed_ms";
+    if (finalization.exit_code !== null &&
+        exit?.signal !== undefined &&
+        exit.signal !== null &&
+        exit.signal !== 0)
+        return "finalization exit_code requires an exit not caused by a signal";
+    if (finalization.elapsed_ms !== null &&
+        finalization.elapsed_ms <
+            (finalization.signals.at(-1)?.sent_at_ms ?? first.sent_at_ms))
+        return "finalization elapsed_ms cannot precede the last signal attempt";
+    if (committedScenario !== undefined &&
+        committedScenario["finalization_ms"] !== finalization.requested_ms)
+        return "finalization must match the committed finalization_ms";
+    return undefined;
+};
 const validateLifecycle = (capture, require) => {
     require(capture.filesystem_checkpoints.map(({ name }) => name).join(",") ===
         "before,after_settlement", "filesystem_checkpoints", "capture must include initial and final filesystem snapshots");
@@ -73,6 +150,8 @@ const validateLifecycle = (capture, require) => {
     require(capture.exit.reason === "exited" ||
         capture.exit.code ===
             null, "exit", "deadline termination cannot declare a normal exit code");
+    const finalizationIssue = finalizationConsistencyIssue(capture.exit, capture.manifest.scenario, capture.manifest.comparison_contract);
+    require(finalizationIssue === undefined, "exit", finalizationIssue ?? "");
 };
 const validateCoverage = (capture, require) => {
     const details = capture.truncation_details;

package/dist/domain/process/processScenario.js

@@ -2,6 +2,12 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 const positiveBudget = z.number().int().safe().positive();
+/**
+ * Maximum xterm backing cells for one visible-plus-scrollback buffer. Each
+ * xterm BufferLine stores three Uint32 words per cell (12 MB at this cap),
+ * before row objects, serialization strings, and retained frame copies.
+ */
+export const PROCESS_TERMINAL_CELL_BUDGET = 1_000_000;
 const timedEventBase = { at_ms: z.number().int().safe().nonnegative() };
 const reservedRunIdEnvironmentName = "REA_PROCESS_RUN_ID";
 const ENVIRONMENT_NAME_CHARACTER = "[^=\\x00]";
@@ -34,6 +40,7 @@ const environmentName = z
 const childProcessString = z
     .string()
     .regex(/^[^\x00]*$/u, "Values passed to operating-system APIs cannot contain NUL");
+const fitsProcessTerminalCellBudget = (columns, rows, scrollback) => rows + scrollback <= Math.floor(PROCESS_TERMINAL_CELL_BUDGET / columns);
 export const normalizationSchema = z.object({
     paths: z.boolean(),
     pids: z.boolean(),
@@ -60,11 +67,17 @@ const committedScenarioEvents = (events, includeSensitiveInputLength) => events.
     }
     : event);
 /** Build the caller-selected scenario projection committed by process-capture Evidence. */
-export const processScenarioCommitment = (scenario, executableSha256) => ({
-    ...scenario,
-    events: committedScenarioEvents(scenario.events, true),
-    executable_sha256: executableSha256 ?? null,
-});
+export const processScenarioCommitment = (scenario, executableSha256) => {
+    // A zero interval is today's immediate kill; leaving it out keeps the
+    // committed identity of every scenario that predates the field unchanged.
+    const { finalization_ms: finalizationMs, ...committed } = scenario;
+    return {
+        ...committed,
+        ...(finalizationMs > 0 ? { finalization_ms: finalizationMs } : {}),
+        events: committedScenarioEvents(scenario.events, true),
+        executable_sha256: executableSha256 ?? null,
+    };
+};
 /** Project observation settings shared by capture and reconstruction. */
 export const processComparisonContract = (scenario) => ({
     working_directory: scenario.working_directory,
@@ -79,11 +92,18 @@ export const processComparisonContract = (scenario) => ({
     timeout_ms: scenario.timeout_ms,
     idle_timeout_ms: scenario.idle_timeout_ms,
     settle_ms: scenario.settle_ms,
+    ...(scenario.finalization_ms > 0
+        ? { finalization_ms: scenario.finalization_ms }
+        : {}),
     limits: scenario.limits,
     normalization: scenario.normalization,
     ...(scenario.normalization.ports
         ? { port_normalization_version: "contextual-endpoints-v2" }
         : {}),
+    ...(scenario.normalization.patterns.length > 0
+        ? { pattern_normalization_version: "literal-replacements-v1" }
+        : {}),
+    rendered_line_format: "trailing-spaces-trimmed-v1",
 });
 /**
  * Boundary schema for one bounded process experiment.
@@ -102,8 +122,9 @@ export const processScenarioSchema = z
         .strictObject({
         columns: z.number().int().min(1).max(65_535).default(80),
         rows: z.number().int().min(1).max(65_535).default(24),
-        scrollback: z.number().int().min(0).default(1_000),
+        scrollback: z.number().int().safe().nonnegative().default(1_000),
     })
+        .describe("The visible terminal and scrollback together must use at most 1,000,000 xterm renderer cells: columns × (rows + scrollback). Resize events use the same scrollback and limit.")
         .default({ columns: 80, rows: 24, scrollback: 1_000 }),
     events: z
         .array(z.discriminatedUnion("type", [
@@ -129,6 +150,13 @@ export const processScenarioSchema = z
     timeout_ms: positiveBudget.default(30_000),
     idle_timeout_ms: positiveBudget.default(30_000),
     settle_ms: z.number().int().safe().nonnegative().default(100),
+    finalization_ms: z
+        .number()
+        .int()
+        .safe()
+        .nonnegative()
+        .default(0)
+        .describe("Milliseconds a target may keep running after SIGTERM when timeout_ms or idle_timeout_ms fires, before SIGKILL; 0 sends SIGKILL immediately. Both signals reach the captured root only while its launch-time start identity still matches; cancellation ends the run at once."),
     limits: z
         .strictObject({
         output_bytes: positiveBudget.default(1_000_000),
@@ -169,6 +197,23 @@ export const processScenarioSchema = z
     }),
 })
     .superRefine((scenario, context) => {
+    // Each budget is a safe integer, but their sum is not checked anywhere
+    // else. BigInt keeps the comparison exact beyond the representable range.
+    const lifecycleBudget = BigInt(scenario.timeout_ms) +
+        BigInt(scenario.finalization_ms) +
+        BigInt(scenario.settle_ms);
+    if (lifecycleBudget > BigInt(Number.MAX_SAFE_INTEGER))
+        context.addIssue({
+            code: "custom",
+            message: `timeout_ms + finalization_ms + settle_ms must stay at or below ${String(Number.MAX_SAFE_INTEGER)} ms, the largest total exactly representable as a JavaScript number`,
+            path: ["timeout_ms"],
+        });
+    if (!fitsProcessTerminalCellBudget(scenario.terminal.columns, scenario.terminal.rows, scenario.terminal.scrollback))
+        context.addIssue({
+            code: "custom",
+            path: ["terminal"],
+            message: `terminal columns × (rows + scrollback) must not exceed ${String(PROCESS_TERMINAL_CELL_BUDGET)} renderer cells`,
+        });
     for (let index = 1; index < scenario.events.length; index += 1) {
         const event = scenario.events[index];
         const previous = scenario.events[index - 1];
@@ -180,7 +225,14 @@ export const processScenarioSchema = z
             });
         }
     }
-    for (const event of scenario.events) {
+    for (const [index, event] of scenario.events.entries()) {
+        if (event.type === "resize" &&
+            !fitsProcessTerminalCellBudget(event.columns, event.rows, scenario.terminal.scrollback))
+            context.addIssue({
+                code: "custom",
+                path: ["events", index],
+                message: `resize event at ${String(event.at_ms)} ms exceeds the ${String(PROCESS_TERMINAL_CELL_BUDGET)}-cell renderer budget with the selected scrollback`,
+            });
         if (event.at_ms > scenario.timeout_ms) {
             context.addIssue({
                 code: "custom",

package/dist/domain/propertyListKeys.js

@@ -2,7 +2,9 @@ import { parse } from "plist";
 /** The dictionary key REA results cannot carry: validation strips it. */
 const PROTOTYPE_KEY = "__proto__";
 /** Limitation for results whose source plist held `__proto__` entries. */
-export const omittedPrototypeKeysLimitation = (count) => `${String(count)} dictionary ${count === 1 ? "entry" : "entries"} keyed __proto__ ${count === 1 ? "was" : "were"} omitted because REA results cannot represent that key.`;
+export const omittedPrototypeKeysLimitation = (count) => count === null
+    ? "Dictionary entries keyed __proto__ were omitted because REA results cannot represent that key."
+    : `${String(count)} dictionary ${count === 1 ? "entry" : "entries"} keyed __proto__ ${count === 1 ? "was" : "were"} omitted because REA results cannot represent that key.`;
 const withoutKey = (value, key) => {
     let omitted = 0;
     const strip = (item) => {