rea-agents 6.0.0 → 6.2.0

package/dist/domain/managed/managedApplicationGraph.js

@@ -1,13 +1,14 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { evidenceSchema, parseEvidence } from "../evidence.js";
+import { evidenceSchema } from "../evidence.js";
 import { createJavaScriptApplicationGraph, javascriptApplicationGraphSchema, } from "../javascript/javascriptApplicationGraph.js";
 import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "./managedArtifact.js";
 import { assessManagedGraphOmissions, managedGraphEvidenceCoverage, managedGraphResultCoverage, } from "./managedApplicationGraphCoverage.js";
 import { addArtifactNode, addArtifactIdentityNodes, addBoundaryNodes, addMemberNodes, } from "./managedApplicationGraphNodes.js";
 import { digestSchema } from "../digests.js";
 import { prefixedDigestSchema } from "../digests.js";
+import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const textSchema = z.string().min(1);
 /** Authenticated managed Evidence records projected into the application graph. */
@@ -121,20 +122,14 @@ export const projectManagedApplicationGraph = (input) => {
 const parseManagedInputs = (input) => ({
     artifact: input.managed_artifact === undefined
         ? null
-        : parseManagedEvidence(input.managed_artifact, "inspect_managed_artifact", managedArtifactInspectionSchema),
+        : parseManagedInspectionEvidence(input.managed_artifact, "inspect_managed_artifact", managedArtifactInspectionSchema),
     members: input.managed_members === undefined
         ? null
-        : parseManagedEvidence(input.managed_members, "inspect_managed_members", managedMemberInspectionSchema),
+        : parseManagedInspectionEvidence(input.managed_members, "inspect_managed_members", managedMemberInspectionSchema),
     boundaries: input.managed_native_boundaries === undefined
         ? null
-        : parseManagedEvidence(input.managed_native_boundaries, "inspect_managed_native_boundaries", managedNativeBoundaryInspectionSchema),
+        : parseManagedInspectionEvidence(input.managed_native_boundaries, "inspect_managed_native_boundaries", managedNativeBoundaryInspectionSchema),
 });
-const parseManagedEvidence = (rawEvidence, operation, schema) => {
-    const evidence = parseEvidence(rawEvidence);
-    if (evidence.operation !== operation)
-        throw new TypeError(`Evidence operation is not ${operation}`);
-    return { evidence, result: schema.parse(evidence.normalized_result) };
-};
 const chooseArtifact = (parsed) => {
     const result = parsed.artifact?.result ??
         parsed.members?.result ??
@@ -164,6 +159,11 @@ const projectionLimitations = (parsed, omissions) => [
             "Managed member Evidence was not supplied; type, method, and field nodes are absent.",
         ]
         : []),
+    ...(parsed.artifact === null
+        ? [
+            "Managed artifact Evidence was not supplied; assembly identity observations are absent.",
+        ]
+        : []),
     ...(parsed.boundaries === null
         ? [
             "Managed native-boundary Evidence was not supplied; P/Invoke and native-implementation nodes are absent.",

package/dist/domain/managed/managedArtifact.js

@@ -413,7 +413,8 @@ export const managedNativeBoundaryInspectionSchema = z.object({
         requires_artifact_sha256: digestSchema,
         requires_mvid: cliMetadataGuidSchema.nullable(),
     }),
-    cli_native: z.object({
+    cli_native: z
+        .object({
         il_only: z.boolean(),
         requires_32bit: z.boolean(),
         strong_name_signed: z.boolean(),
@@ -421,7 +422,8 @@ export const managedNativeBoundaryInspectionSchema = z.object({
         ready_to_run_signature: z.boolean(),
         managed_native_header_rva: z.number().int().min(0).max(0xffff_ffff),
         managed_native_header_size: z.number().int().min(0).max(0xffff_ffff),
-    }),
+    })
+        .nullable(),
     module_refs: z.array(managedModuleReferenceSchema),
     pinvoke_imports: z.array(managedNativeImportSchema),
     native_implementations: z.array(managedNativeImplementationSchema),
@@ -429,8 +431,8 @@ export const managedNativeBoundaryInspectionSchema = z.object({
         module_ref_count: z.number().int().min(0),
         pinvoke_import_count: z.number().int().min(0),
         native_implementation_count: z.number().int().min(0),
-        ready_to_run: z.boolean(),
-        mixed_mode_or_native_header: z.boolean(),
+        ready_to_run: z.boolean().nullable(),
+        mixed_mode_or_native_header: z.boolean().nullable(),
     }),
     coverage: z.object({
         state: z.enum(["complete", "partial", "unavailable"]),

package/dist/domain/managed/managedInspectionEvidence.js

@@ -0,0 +1,16 @@
+import { parseEvidence } from "../evidence.js";
+/**
+ * Parse managed inspection Evidence and bind its artifact to any available subject.
+ * A null subject remains valid and means there is no digest to cross-check.
+ */
+export const parseManagedInspectionEvidence = (rawEvidence, operation, schema) => {
+    const evidence = parseEvidence(rawEvidence);
+    if (evidence.operation !== operation)
+        throw new TypeError(`Evidence operation is not ${operation}`);
+    const result = schema.parse(evidence.normalized_result);
+    const artifactSha256 = result.artifact.sha256;
+    const subjectSha256 = evidence.subject?.digest.sha256;
+    if (subjectSha256 !== undefined && artifactSha256 !== subjectSha256)
+        throw new TypeError(`Managed Evidence ${operation} (${evidence.evidence_id}) subject SHA-256 ${subjectSha256} does not match normalized artifact SHA-256 ${artifactSha256}`);
+    return { evidence, result };
+};

package/dist/domain/managed/managedMemberComparison.js

@@ -165,18 +165,12 @@ export const managedMemberComparisonResultSchema = z.strictObject({
 });
 /** Compare managed members with constrained exact and structural identities. */
 export const compareManagedMembers = (left, right) => {
-    const leftCoverage = {
-        sourceComplete: left.result.coverage.state === "complete",
-    };
-    const rightCoverage = {
-        sourceComplete: right.result.coverage.state === "complete",
-    };
     const { methodMatches, fieldMatches } = keyMembers(left, right);
     const itemContext = {
         leftEvidenceId: left.evidenceId,
         rightEvidenceId: right.evidenceId,
-        leftComplete: leftCoverage.sourceComplete,
-        rightComplete: rightCoverage.sourceComplete,
+        leftComplete: left.result.metadata.status === "complete",
+        rightComplete: right.result.metadata.status === "complete",
     };
     const methodItems = buildMethodItems(methodMatches, itemContext);
     const fieldItems = buildFieldItems(fieldMatches, itemContext);
@@ -212,4 +206,3 @@ export const compareManagedMembers = (left, right) => {
     };
     return managedMemberComparisonResultSchema.parse(result);
 };
-export { parseManagedMemberEvidence } from "./managedMemberComparisonMatch.js";

package/dist/domain/managed/managedMemberComparisonMatch.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { parseEvidence } from "../evidence.js";
 import { managedMemberInspectionSchema, } from "./managedArtifact.js";
+import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
 export const sha256 = (value) => {
     const serialized = canonicalize(value);
     if (serialized === undefined)
@@ -10,9 +10,7 @@ export const sha256 = (value) => {
 };
 const keyMethod = (item) => ({
     item,
-    exactKey: item.signature.parse_status === "decoded" &&
-        item.body.status === "present" &&
-        item.body.normalized_il_sha256 !== null
+    exactKey: item.body.status === "present" && item.body.normalized_il_sha256 !== null
         ? stableKey([
             "method-exact",
             item.signature.raw_sha256,
@@ -173,11 +171,9 @@ export const keyMembers = (left, right) => ({
     fieldMatches: matchFields(left.result.fields.map(keyField), right.result.fields.map(keyField)),
 });
 export const parseManagedMemberEvidence = (evidence) => {
-    const parsed = parseEvidence(evidence);
-    if (parsed.operation !== "inspect_managed_members")
-        throw new TypeError("Evidence operation is not inspect_managed_members");
+    const parsed = parseManagedInspectionEvidence(evidence, "inspect_managed_members", managedMemberInspectionSchema);
     return {
-        evidenceId: parsed.evidence_id,
-        result: managedMemberInspectionSchema.parse(parsed.normalized_result),
+        evidenceId: parsed.evidence.evidence_id,
+        result: parsed.result,
     };
 };

package/dist/domain/managed/managedNativeVerification.js

@@ -1,27 +1,19 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { parseEvidence } from "../evidence.js";
 import { managedNativeBoundaryInspectionSchema, } from "./managedArtifact.js";
+import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
 import { managedNativeVerificationResultSchema, } from "./managedNativeVerificationSchemas.js";
 import { buildVerificationResult, collectNativeSymbols, verifyPinvoke, } from "./managedNativeVerificationMatch.js";
-export { managedNativeVerificationInputSchema, } from "./managedNativeVerificationSchemas.js";
-export { managedNativeVerificationResultSchema };
 const sha256 = (value) => {
     const serialized = canonicalize(value);
     if (serialized === undefined)
         throw new TypeError("Managed/native verification canonicalization failed");
     return createHash("sha256").update(serialized).digest("hex");
 };
-const managedBoundaryFromInput = (input) => {
-    const managedEvidence = parseEvidence(input.managed_boundaries);
-    if (managedEvidence.operation !== "inspect_managed_native_boundaries")
-        throw new TypeError("Evidence operation is not inspect_managed_native_boundaries");
-    return managedNativeBoundaryInspectionSchema.parse(managedEvidence.normalized_result);
-};
+const parseManagedBoundary = (input) => parseManagedInspectionEvidence(input.managed_boundaries, "inspect_managed_native_boundaries", managedNativeBoundaryInspectionSchema);
 /** Verify managed P/Invoke declarations against authenticated native Evidence. */
 export const verifyManagedNativeBoundaries = (input) => {
-    const managed = managedBoundaryFromInput(input);
-    const managedEvidence = parseEvidence(input.managed_boundaries);
+    const { evidence: managedEvidence, result: managed } = parseManagedBoundary(input);
     const native = collectNativeSymbols(input.native_observations);
     const verifiedPinvokes = managed.pinvoke_imports.map((item) => verifyPinvoke({
         item,

package/dist/domain/managed/managedNativeVerificationMatch.js

@@ -71,16 +71,22 @@ const sameSymbolName = (expected, native) => expected ===
         : native.name);
 const normalizeModule = (value) => basename(value)
     .toLowerCase()
-    .replace(/^lib/u, "")
     .replace(/\.(dll|dylib|so|node|exe)$/u, "");
+const nativeModuleIdentities = (value) => {
+    const filename = basename(value).toLowerCase();
+    const stem = normalizeModule(filename);
+    const identities = new Set([stem]);
+    if (/\.(dylib|so)$/u.test(filename) && stem.startsWith("lib"))
+        identities.add(stem.slice("lib".length));
+    return identities;
+};
 const moduleCompatible = (scope, symbol) => {
     if (scope === null)
         return true;
     const expected = normalizeModule(scope);
     return [symbol.module_name, symbol.module_path]
         .filter((value) => value !== null)
-        .map(normalizeModule)
-        .some((value) => value === expected);
+        .some((value) => nativeModuleIdentities(value).has(expected));
 };
 const candidateNames = (managed) => {
     const names = new Set([managed.import_name]);

package/dist/domain/native/binaryLayout.js

@@ -1,11 +1,10 @@
 import { z } from "zod";
+import { CANONICAL_BASE64_PATTERN } from "../stringPatterns.js";
 const unsignedHex = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]{0,15})$/);
 const index = z.number().int().nonnegative();
 const scalar = z.union([z.string(), z.number().int()]);
 const range = z.strictObject({ offset: unsignedHex, bytes: unsignedHex });
-const canonicalBase64 = z
-    .string()
-    .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$/);
+const canonicalBase64 = z.string().regex(CANONICAL_BASE64_PATTERN);
 const name = z.strictObject({
     display: z.string(),
     bytes_base64: canonicalBase64.nullable(),

package/dist/domain/native/fileOffsetPartialObservation.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/native/nativeApiBoundary.js

@@ -71,7 +71,7 @@ const inferredJumpTableSchema = z
     dispatch_address: z.string().min(1),
     data_sources: z.array(jumpTableDataSourceSchema),
     mappings: z.array(jumpTableMappingSchema),
-    default_targets: z.array(jumpTableDefaultTargetSchema).default([]),
+    default_targets: z.array(jumpTableDefaultTargetSchema),
     limitations: z.array(z.string()),
 })
     .strict();

package/dist/domain/native/nativeCallObservation.js

@@ -1,14 +1,16 @@
 import { z } from "zod";
+import { localPathStringSchema } from "../localPath.js";
 const hexSchema = z.string().regex(/^0x[0-9a-f]+$/u);
-/** Objective-C class names and selectors never contain spaces or brackets. */
-const objcName = z
+const nativeString = z
     .string()
+    .regex(/^[^\u0000]*$/u, "Native launch and breakpoint strings cannot contain NUL");
+/** Objective-C class names and selectors never contain spaces or brackets. */
+const objcName = nativeString
     .min(1)
-    .regex(/^[^\s[\]]+$/u, "Use the bare name without spaces or brackets");
+    .regex(/^[^\s\x5b\x5d]+$/u, "Use the bare name without spaces or brackets");
 const functionBreakpoint = {
     kind: z.literal("function"),
-    name: z
-        .string()
+    name: nativeString
         .min(1)
         .describe("Exact symbol name, such as `open`, a C++ or mangled Swift symbol, or `-[NSString length]`."),
 };
@@ -20,8 +22,7 @@ const objcMethodBreakpoint = {
 export const nativeCallBreakpointSchema = z.discriminatedUnion("kind", [
     z.strictObject({
         ...functionBreakpoint,
-        module: z
-            .string()
+        module: nativeString
             .min(1)
             .optional()
             .describe("Image file name that defines the symbol, such as `libsystem_kernel.dylib`; omit to match every image."),
@@ -40,15 +41,17 @@ export const nativeCallBreakpointSchema = z.discriminatedUnion("kind", [
  */
 export const nativeCallObservationInputSchema = z.strictObject({
     breakpoints: z.array(nativeCallBreakpointSchema).min(1),
-    arguments: z.array(z.string()).default([]),
+    arguments: z.array(nativeString).default([]),
     environment: z
         .record(z
         .string()
         .min(1)
-        .regex(/^[^=\0]+$/u, "Environment names cannot contain '=' or NUL"), z.string().regex(/^[^\0]*$/u, "Environment values cannot contain NUL"))
+        .regex(/^[^=\u0000]+$/u, "Environment names cannot contain '=' or NUL"), z
+        .string()
+        .regex(/^[^\u0000]*$/u, "Environment values cannot contain NUL"))
         .default({})
         .describe("Overrides on top of the environment REA runs with."),
-    working_directory: z.string().min(1).optional(),
+    working_directory: localPathStringSchema.optional(),
     duration_ms: z
         .number()
         .int()
@@ -100,10 +103,13 @@ export const nativeCallEventSchema = z.strictObject({
     registers: z.array(z.strictObject({ name: z.string(), value: hexSchema })),
     backtrace: z.array(nativeCodeLocationSchema),
 });
-const capturedOutputSchema = z.strictObject({
+/** Retained native output with explicit stream completeness and byte counts. */
+export const nativeCapturedOutputSchema = z.strictObject({
     text: z.string(),
+    /** Bytes observed by the bridge, not a total when complete is false. */
     bytes: z.number().int().nonnegative(),
     truncated: z.boolean(),
+    complete: z.boolean(),
 });
 /** Observed calls, the process lifecycle, and breakpoint resolution. */
 export const nativeCallObservationResultSchema = z.strictObject({
@@ -112,7 +118,21 @@ export const nativeCallObservationResultSchema = z.strictObject({
         sha256: z.string().regex(/^[0-9a-f]{64}$/u),
         architecture: z.string(),
         arguments: z.array(z.string()),
+        environment: z.record(z.string(), z.string()),
         working_directory: z.string().nullable(),
+        launch_identity: z.strictObject({
+            /** A pathname hash does not verify the bytes mapped into the process. */
+            loaded_image_sha256: z.null(),
+            file_device: z.string().nullable(),
+            file_inode: z.string().nullable(),
+            selected_file_sha256: z
+                .string()
+                .regex(/^[0-9a-f]{64}$/u)
+                .nullable(),
+            module_path: z.string().nullable(),
+            module_uuid: z.string().nullable(),
+            stable: z.boolean(),
+        }),
     }),
     debugger: z.strictObject({
         path: z.string(),
@@ -126,14 +146,15 @@ export const nativeCallObservationResultSchema = z.strictObject({
             "duration-elapsed",
             "event-limit",
             "stop-limit",
+            "resource-limit",
         ]),
         exit_status: z.number().int().nullable(),
         exit_description: z.string().nullable(),
         /** REA confirmed the process is gone when observation ended. */
         terminated: z.boolean(),
         elapsed_ms: z.number().nonnegative(),
-        stdout: capturedOutputSchema,
-        stderr: capturedOutputSchema,
+        stdout: nativeCapturedOutputSchema,
+        stderr: nativeCapturedOutputSchema,
         /** Signal and exception stops LLDB reported; the process continued past each. */
         other_stops: z.array(z.string()),
     }),
@@ -157,6 +178,9 @@ export const nativeCallObservationResultSchema = z.strictObject({
     coverage: z.strictObject({
         status: z.enum(["complete", "partial"]),
         event_limit_reached: z.boolean(),
+        resource_limit_reached: z.boolean(),
+        /** Aggregate breakpoint-location metadata exhausted its retained-byte budget. */
+        breakpoint_locations_truncated: z.boolean().optional(),
         /** Requests that matched no code in any image loaded while observing. */
         unresolved_breakpoints: z.array(z.number().int().nonnegative()),
     }),

package/dist/domain/native/nativeCallPartialObservation.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { nativeCallEventSchema, nativeCapturedOutputSchema, } from "./nativeCallObservation.js";
+/** Native call evidence retained when observation fails before a full result. */
+export const nativeCallPartialObservationSchema = z.strictObject({
+    kind: z.literal("native-call-observation"),
+    target: z.strictObject({
+        path: z.string(),
+        sha256: z.string().regex(/^[0-9a-f]{64}$/u),
+        architecture: z.string(),
+        arguments: z.array(z.string()),
+        environment: z.record(z.string(), z.string()),
+        working_directory: z.string().nullable(),
+    }),
+    process: z.strictObject({
+        pid: z.number().int().positive().nullable(),
+        stdout: nativeCapturedOutputSchema.nullable(),
+        stderr: nativeCapturedOutputSchema.nullable(),
+        other_stops: z.array(z.string()),
+    }),
+    debugger: z.strictObject({ version: z.string().nullable() }),
+    events: z.array(nativeCallEventSchema),
+    coverage: z.strictObject({
+        status: z.literal("partial"),
+        reason: z.enum([
+            "cancelled",
+            "timeout",
+            "tracer-failure",
+            "capture-failure",
+            "cleanup-failure",
+        ]),
+    }),
+    limitations: z.array(z.string()),
+});

package/dist/domain/native/nativeInstruction.js

@@ -54,6 +54,13 @@ export const nativeInstructionSchema = z.strictObject({
         conditional: z.boolean(),
         computed: z.boolean(),
         direct_destinations: z.array(z.string()),
+        classification_evidence: z
+            .array(z.strictObject({
+            source: z.string().min(1),
+            value: z.string().min(1),
+        }))
+            .optional()
+            .describe("Observed provider facts used to classify flow; older captures or other providers may omit them."),
     }),
     references: z.array(reference),
     limitations: z.array(z.string()),

package/dist/domain/native/recordedCrash.js

@@ -1,11 +1,10 @@
 import { z } from "zod";
+import { CANONICAL_BASE64_PATTERN } from "../stringPatterns.js";
 import { recordedNoteCoverageIssues } from "./recordedCrashNoteCoverage.js";
 const hex = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]{0,15})$/);
 const index = z.number().int().nonnegative();
 const signed32 = z.number().int().min(-2147483648).max(2147483647);
-const base64 = z
-    .string()
-    .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$/);
+const base64 = z.string().regex(CANONICAL_BASE64_PATTERN);
 const range = z.strictObject({ offset: hex, bytes: hex });
 const diagnostics = z.strictObject({
     stdout: z.string(),

package/dist/domain/offsetDateTime.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+/**
+ * ISO-8601 date-time that requires an explicit UTC offset.
+ *
+ * `z.string().datetime({ offset: true })` emits Zod's offset class as `[+-]`.
+ * Annex B and `u` mode accept that, but ECMA-262 `v` mode rejects the
+ * unescaped `-`, so any tool whose schema carries the pattern is unusable for a
+ * client that compiles advertised patterns — schema compilation happens before
+ * arguments are supplied, so the whole tools request fails rather than one call.
+ *
+ * The accepted set is identical to the Zod validator; only the offset class
+ * escapes `-`, as `\x2d`, because an escaped `-` inside a character class is
+ * removed by `oxlint --fix` as a useless escape.
+ */
+export const offsetDateTimeSchema = z
+    .string()
+    .regex(/^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z|(?:[+\x2d](?:[01]\d|2[0-3]):[0-5]\d)))$/u, "Use an ISO-8601 date-time with an explicit UTC offset");

package/dist/domain/process/processCapture.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { jsonValueSchema } from "../jsonValue.js";
 import { normalizationSchema } from "./processScenario.js";
 import { collectProcessCaptureIssues } from "./processCaptureValidation.js";
-export * from "./processScenario.js";
+import { processCaptureTruncationDetailsSchema, } from "./processCaptureCoverage.js";
 /** Capture collection whose members participate in global observation order. */
 export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
     "frames",
@@ -59,6 +59,13 @@ const fileEffectSchema = z.discriminatedUnion("status", [
         before: fileStateSchema,
         after: fileStateSchema,
     }),
+    z.object({
+        path: z.string(),
+        status: z.literal("unknown"),
+        before: fileStateSchema.nullable(),
+        after: fileStateSchema.nullable(),
+        reason: z.string().min(1),
+    }),
 ]);
 /** Exact serialized shape of a process capture. */
 const processSettlementSchema = z.discriminatedUnion("state", [
@@ -73,6 +80,7 @@ const processSettlementSchema = z.discriminatedUnion("state", [
         cleanup_outcome: z.enum(["cleaned", "failed"]),
     }),
 ]);
+const unverifiedCleanupProcessesSchema = z.array(z.strictObject({ pid: z.number().int().positive(), reason: z.string() }));
 const processCaptureShapeSchema = z.strictObject({
     manifest: z.strictObject({
         rea_version: z.string().min(1),
@@ -94,10 +102,6 @@ const processCaptureShapeSchema = z.strictObject({
             .string()
             .regex(/^[a-f0-9]{64}$/u)
             .nullable(),
-        legacy_executable_sha256: z
-            .string()
-            .regex(/^[a-f0-9]{64}$/u)
-            .optional(),
         executable_identity: z.strictObject({
             state: z.enum(["path_metadata_unchanged", "unknown"]),
             reason: z.string().nullable(),
@@ -109,6 +113,7 @@ const processCaptureShapeSchema = z.strictObject({
         sequence: z.number().int().nonnegative(),
         at_ms: z.number().int().nonnegative(),
         data: z.string(),
+        raw_data: z.string().optional(),
     })),
     rendered_frames: z.array(z.object({
         sequence: z.number().int().nonnegative(),
@@ -161,17 +166,16 @@ const processCaptureShapeSchema = z.strictObject({
         effects: z.array(fileEffectSchema),
         truncated: z.boolean(),
     })),
-    event_journal: z
-        .array(z.object({
+    event_journal: z.array(z.object({
         capture_order: z.number().int().nonnegative(),
         collection: z.enum(PROCESS_CAPTURE_EVENT_COLLECTIONS),
         index: z.number().int().nonnegative(),
-    }))
-        .default([]),
+    })),
     files_before: z.array(fileStateSchema),
     files_after: z.array(fileStateSchema),
     filesystem_effects: z.array(fileEffectSchema),
     truncated: z.boolean(),
+    truncation_details: processCaptureTruncationDetailsSchema.optional(),
     limitations: z.array(z.string()),
     residual_unknowns: z.array(z.object({
         scope: z.enum([
@@ -189,11 +193,13 @@ const processCaptureShapeSchema = z.strictObject({
     cleanup: z.object({
         owned_process_group: z.literal("verified"),
         temporary_root: z.literal("removed"),
+        unverified_processes: unverifiedCleanupProcessesSchema.optional(),
     }),
 });
 const processCleanupResourceSchema = z.strictObject({
     state: z.enum(["cleaned", "failed", "unverified", "not_required"]),
     reason: z.string().nullable(),
+    unverified_processes: unverifiedCleanupProcessesSchema.optional(),
 });
 const partialObservationFieldSchema = (value) => z.discriminatedUnion("state", [
     z.strictObject({ state: z.literal("available"), value }),
@@ -244,18 +250,19 @@ const completedCaptureObservationSchema = z.strictObject({
 const incompleteCaptureObservationSchema = z.strictObject({
     observations: incompleteProcessCaptureObservationsSchema,
 });
-/** Validated, non-comparable process observations attached to cleanup errors. */
+/** Validated, non-comparable process observations attached to execution or cleanup errors. */
 export const partialProcessCaptureObservationSchema = z
     .union([
     completedCaptureObservationSchema.extend(partialObservationMetadataSchema.shape),
     incompleteCaptureObservationSchema.extend(partialObservationMetadataSchema.shape),
 ])
     .superRefine((partial, context) => {
-    if (!Object.values(partial.cleanup).some(({ state }) => state === "failed" || state === "unverified"))
+    const cleanupIncomplete = Object.values(partial.cleanup).some(({ state }) => state === "failed" || state === "unverified");
+    if (!cleanupIncomplete && partial.execution_failure === null)
         context.addIssue({
             code: "custom",
-            path: ["cleanup"],
-            message: "partial observations require incomplete resource cleanup",
+            path: ["execution_failure"],
+            message: "partial observations require incomplete cleanup or an execution failure",
         });
     if ("observations" in partial) {
         const { observations } = partial;
@@ -311,6 +318,4 @@ export const processCaptureSchema = processCaptureShapeSchema
             message: issue.message,
         });
 })
-    .describe("The capture must preserve its canonical scenario, comparison, and normalization SHA-256 commitments; ordered capture timestamps and contiguous sequence numbers; before and final filesystem snapshots with truncation propagated; and exit-code consistency with deadline termination. When parsing older input without an event journal, REA supplies an empty journal; empty journals are valid. A non-empty journal must reference every captured observation exactly once with unique in-range references. These cross-field invariants are checked by REA after capture.");
-export { parseProcessCapture } from "./processCaptureParsing.js";
-export { compareProcessCaptures, comparisonStatusSchema, deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, } from "./processComparison.js";
+    .describe("The capture must preserve its canonical scenario, comparison, and normalization SHA-256 commitments; ordered capture timestamps and contiguous sequence numbers; before and final filesystem snapshots with truncation propagated; and exit-code consistency with deadline termination. The event journal is required; empty journals are valid. A non-empty journal must reference every captured observation exactly once with unique in-range references. These cross-field invariants are checked by REA after capture.");

package/dist/domain/process/processCaptureCoverage.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+const byteRetentionSchema = z.strictObject({
+    budget_bytes: z.number().int().nonnegative(),
+    observed_bytes: z.number().int().nonnegative(),
+    retained_bytes: z.number().int().nonnegative(),
+    observed_frames: z.number().int().nonnegative(),
+    retained_frames: z.number().int().nonnegative(),
+});
+/** Filesystem enumeration and whole-file digest coverage for one checkpoint. */
+export const filesystemCoverageSchema = z.strictObject({
+    files_limit: z.number().int().nonnegative(),
+    depth_limit: z.number().int().nonnegative(),
+    enumeration_truncated: z.boolean(),
+    enumeration_reasons: z.array(z.enum(["files_limit", "depth_limit", "identity_changed"])),
+    hash_budget_bytes: z.number().int().nonnegative(),
+    hashed_bytes: z.number().int().nonnegative(),
+    hash_omissions: z.array(z.strictObject({
+        path: z.string(),
+        size_bytes: z.number().int().nonnegative(),
+        remaining_budget_bytes: z.number().int().nonnegative(),
+        reason: z.enum(["file_bytes_budget", "file_changed_or_short_read"]),
+    })),
+});
+/** Actual budget accounting; rendered bytes count state and visible lines, not JSON. */
+export const processCaptureTruncationDetailsSchema = z.strictObject({
+    raw_terminal: byteRetentionSchema.describe("UTF-8 bytes of original PTY chunks; whole chunks are retained or omitted."),
+    rendered_terminal: byteRetentionSchema.describe("Cumulative UTF-8 bytes of serialized state plus visible lines, evaluated from retained PTY input; whole frames are retained or omitted."),
+    filesystem_before: filesystemCoverageSchema,
+    filesystem_after: filesystemCoverageSchema,
+    process: z.strictObject({
+        sample_limit: z.number().int().nonnegative(),
+        sampling_partial: z.boolean(),
+        retained_samples: z.number().int().nonnegative(),
+        sample_limit_reached: z.boolean(),
+        sampling_failures: z.number().int().nonnegative(),
+        first_sampling_failure: z.string().nullable(),
+        coverage: z.literal("sampled"),
+    }),
+});
+const omitted = (retention) => retention.observed_frames > retention.retained_frames;
+const filesystemTruncated = (coverage) => coverage.enumeration_truncated || coverage.hash_omissions.length > 0;
+/** Derive the legacy aggregate flag from independent producer observations. */
+export const hasCaptureTruncation = (details) => omitted(details.raw_terminal) ||
+    omitted(details.rendered_terminal) ||
+    filesystemTruncated(details.filesystem_before) ||
+    filesystemTruncated(details.filesystem_after) ||
+    details.process.sampling_partial;
+/** Older truncated captures lack enough information to localize missing observations. */
+export const processSourceTruncated = (capture, source) => {
+    const details = capture.truncation_details;
+    if (details === undefined)
+        return capture.truncated;
+    switch (source) {
+        case "terminal_raw":
+            return omitted(details.raw_terminal);
+        case "terminal_rendered":
+            return (omitted(details.raw_terminal) || omitted(details.rendered_terminal));
+        case "filesystem":
+            return (filesystemTruncated(details.filesystem_before) ||
+                filesystemTruncated(details.filesystem_after));
+        case "process":
+            return details.process.sampling_partial;
+        case "interaction":
+        case "lifecycle":
+            return false;
+    }
+};

package/dist/domain/process/processCaptureExample.js

@@ -1,4 +1,4 @@
-import { digestProcessCommitment } from "./processCapture.js";
+import { digestProcessCommitment } from "./processScenario.js";
 const normalization = {
     paths: true,
     pids: true,
@@ -51,6 +51,7 @@ export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
             truncated: false,
         },
     ],
+    event_journal: [],
     files_before: [],
     files_after: [],
     filesystem_effects: [],