rea-agents 6.1.0 → 6.3.0

package/dist/domain/native/objcSwiftMetadata.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
 /** Objective-C method type. */
 export const objcMethodTypeSchema = z.enum([
     "instance",
@@ -10,25 +11,22 @@ export const objcMethodTypeSchema = z.enum([
 export const objcPropertyAttributeSchema = z.strictObject({
     name: z.string().min(1),
     value: z.string(),
-    is_weak: z.boolean().default(false),
-    is_atomic: z.boolean().default(false),
-    is_copy: z.boolean().default(false),
-    is_strong: z.boolean().default(false),
 });
 /** Objective-C method metadata. */
 export const objcMethodSchema = z.strictObject({
     selector: z.string().min(1),
     method_type: objcMethodTypeSchema,
     address: z.number().int().nullable(),
-    is_required: z.boolean().default(false),
-    is_optional: z.boolean().default(false),
+    is_required: z.boolean().nullable(),
+    is_optional: z.boolean().nullable(),
 });
 /** Objective-C property metadata. */
 export const objcPropertySchema = z.strictObject({
     name: z.string().min(1),
     type_encoding: z.string().nullable(),
-    attributes: z.array(objcPropertyAttributeSchema).default([]),
-    is_readonly: z.boolean().default(false),
+    attributes: z.array(objcPropertyAttributeSchema),
+    atomicity: z.enum(["atomic", "nonatomic"]).nullable(),
+    is_readonly: z.boolean().nullable(),
     getter: z.string().nullable(),
     setter: z.string().nullable(),
 });
@@ -43,12 +41,12 @@ export const objcProtocolSchema = z.strictObject({
 export const objcClassSchema = z.strictObject({
     name: z.string().min(1),
     super_class: z.string().nullable(),
-    is_meta_class: z.boolean().default(false),
-    is_root_class: z.boolean().default(false),
+    is_meta_class: z.boolean().nullable(),
+    is_root_class: z.boolean().nullable(),
     methods: z.array(objcMethodSchema).default([]),
     properties: z.array(objcPropertySchema).default([]),
     protocols: z.array(z.string()).default([]),
-    ivar_count: z.number().int().nonnegative().default(0),
+    ivar_count: z.number().int().nonnegative().nullable(),
     instance_size: z.number().int().nonnegative().nullable(),
     location: z
         .object({
@@ -333,23 +331,23 @@ export const inspectNativeDispatchMetadata = (names, maxRecords = 5_000) => {
             selector: implementation.selector,
             method_type: implementation.method_type,
             address: parseMetadataAddress(implementation.implementation_address),
-            is_required: false,
-            is_optional: false,
+            is_required: null,
+            is_optional: null,
         });
         methodsByClass.set(implementation.class_name, methods);
     }
     const classes = [...classNames].sort().map((name) => ({
         name,
         super_class: null,
-        is_meta_class: false,
-        is_root_class: false,
+        is_meta_class: null,
+        is_root_class: null,
         methods: methodsByClass.get(name) ?? [],
         properties: [],
         protocols: [],
-        ivar_count: 0,
+        ivar_count: null,
         instance_size: null,
     }));
-    const decodedImplementations = [...implementations.values()].sort((left, right) => `${left.class_name}:${left.selector}`.localeCompare(`${right.class_name}:${right.selector}`));
+    const decodedImplementations = [...implementations.values()].sort((left, right) => compareUnicodeCodePoints(compositeKey([left.class_name, left.selector]), compositeKey([right.class_name, right.selector])));
     const swift = swiftSymbols.length > 0;
     return objcSwiftMetadataSchema.parse({
         objc_classes: classes,

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 { filesystemCoverageSchema, processCaptureTruncationDetailsSchema, } from "./processCaptureCoverage.js";
 /** Capture collection whose members participate in global observation order. */
 export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
     "frames",
@@ -40,6 +40,13 @@ const fileStateSchema = z.discriminatedUnion("type", [
         symlink_target: z.null(),
     }),
 ]);
+/** Canonical checkpoint facts retained even when capture completion fails. */
+export const processFilesystemSnapshotSchema = z.strictObject({
+    files: z.array(fileStateSchema),
+    truncated: z.boolean(),
+    completeRoots: z.array(z.string()),
+    coverage: filesystemCoverageSchema,
+});
 const fileEffectSchema = z.discriminatedUnion("status", [
     z.object({
         path: z.string(),
@@ -59,6 +66,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", [
@@ -95,10 +109,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(),
@@ -110,6 +120,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(),
@@ -162,17 +173,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,
     limitations: z.array(z.string()),
     residual_unknowns: z.array(z.object({
         scope: z.enum([
@@ -218,14 +228,8 @@ const incompleteProcessCaptureObservationsSchema = z.strictObject({
     })),
     process_samples: partialObservationFieldSchema(processCaptureShapeSchema.shape.process_samples),
     filesystem_snapshots: z.strictObject({
-        before: partialObservationFieldSchema(z.strictObject({
-            files: z.array(fileStateSchema),
-            truncated: z.boolean(),
-        })),
-        after: partialObservationFieldSchema(z.strictObject({
-            files: z.array(fileStateSchema),
-            truncated: z.boolean(),
-        })),
+        before: partialObservationFieldSchema(processFilesystemSnapshotSchema),
+        after: partialObservationFieldSchema(processFilesystemSnapshotSchema),
     }),
     event_journal: partialObservationFieldSchema(processCaptureShapeSchema.shape.event_journal),
     manifest: partialObservationFieldSchema(processCaptureShapeSchema.shape.manifest),
@@ -315,6 +319,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,70 @@
+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",
+            "file_unavailable",
+        ]),
+        system_code: z.string().nullable(),
+    })),
+});
+/** 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 aggregate truncation 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;
+/** Whether producer accounting reports a gap in the selected observation source. */
+export const processSourceTruncated = (capture, source) => {
+    const details = capture.truncation_details;
+    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,10 +51,54 @@ export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
             truncated: false,
         },
     ],
+    event_journal: [],
     files_before: [],
     files_after: [],
     filesystem_effects: [],
     truncated: false,
+    truncation_details: {
+        raw_terminal: {
+            budget_bytes: 1_000_000,
+            observed_bytes: 0,
+            retained_bytes: 0,
+            observed_frames: 0,
+            retained_frames: 0,
+        },
+        rendered_terminal: {
+            budget_bytes: 1_000_000,
+            observed_bytes: 0,
+            retained_bytes: 0,
+            observed_frames: 0,
+            retained_frames: 0,
+        },
+        filesystem_before: {
+            files_limit: 10_000,
+            depth_limit: 16,
+            enumeration_truncated: false,
+            enumeration_reasons: [],
+            hash_budget_bytes: 10_000_000,
+            hashed_bytes: 0,
+            hash_omissions: [],
+        },
+        filesystem_after: {
+            files_limit: 10_000,
+            depth_limit: 16,
+            enumeration_truncated: false,
+            enumeration_reasons: [],
+            hash_budget_bytes: 10_000_000,
+            hashed_bytes: 0,
+            hash_omissions: [],
+        },
+        process: {
+            sample_limit: 1_000,
+            sampling_partial: false,
+            retained_samples: 0,
+            sample_limit_reached: false,
+            sampling_failures: 0,
+            first_sampling_failure: null,
+            coverage: "sampled",
+        },
+    },
     limitations: [],
     residual_unknowns: [],
     cleanup: {

package/dist/domain/process/processCaptureParsing.js

@@ -1,5 +1,4 @@
 import { processCaptureSchema, } from "./processCapture.js";
-import { z } from "zod";
 const verifiedCaptures = new WeakSet();
 const isVerifiedCapture = (capture) => verifiedCaptures.has(capture);
 const attachProof = (capture) => {
@@ -8,41 +7,9 @@ const attachProof = (capture) => {
         return capture;
     throw new TypeError("Process Capture proof ownership failed");
 };
-const recordSchema = z.record(z.string(), z.unknown());
-const LEGACY_EXECUTABLE_IDENTITY_REASON = "Legacy v3 capture did not distinguish selected and launch executable digests";
-const migrateLegacyV3Capture = (input) => {
-    const capture = recordSchema.safeParse(input);
-    if (!capture.success)
-        return input;
-    const manifest = recordSchema.safeParse(capture.data.manifest);
-    if (!manifest.success)
-        return input;
-    if (manifest.data.provider_version !== "3" ||
-        "selected_executable_sha256" in manifest.data ||
-        "executable_identity" in manifest.data ||
-        "legacy_executable_sha256" in manifest.data)
-        return input;
-    const { executable_sha256 } = manifest.data;
-    if (typeof executable_sha256 !== "string" ||
-        !/^[a-f0-9]{64}$/u.test(executable_sha256))
-        return input;
-    return {
-        ...capture.data,
-        manifest: {
-            ...manifest.data,
-            selected_executable_sha256: null,
-            executable_sha256: null,
-            executable_identity: {
-                state: "unknown",
-                reason: LEGACY_EXECUTABLE_IDENTITY_REASON,
-            },
-            legacy_executable_sha256: executable_sha256,
-        },
-    };
-};
 /** Parse unknown input and reject invalid commitments or semantics. */
 export const parseProcessCapture = (input) => {
-    const parsed = processCaptureSchema.safeParse(migrateLegacyV3Capture(input));
+    const parsed = processCaptureSchema.safeParse(input);
     if (parsed.success)
         return attachProof(parsed.data);
     const issues = parsed.error.issues.flatMap((issue) => issue.code === "custom"

package/dist/domain/process/processCaptureValidation.js

@@ -1,22 +1,13 @@
 import { digestProcessCommitment } from "./processScenario.js";
+import { hasCaptureTruncation } from "./processCaptureCoverage.js";
 const orderedTimestamps = (values) => values.every((value, index) => {
     const previous = values[index - 1];
     return previous === undefined || value.at_ms >= previous.at_ms;
 });
 const validateCommitments = (capture, require) => {
     const { manifest } = capture;
-    if (manifest.legacy_executable_sha256 !== undefined) {
-        require(manifest.selected_executable_sha256 === null &&
-            manifest.executable_sha256 === null &&
-            manifest.executable_identity.state === "unknown" &&
-            manifest.executable_identity.reason !== null &&
-            manifest.scenario.executable_sha256 ===
-                manifest.legacy_executable_sha256, "manifest.legacy_executable_sha256", "legacy executable digest must remain distinct from unknown selected and launch digests");
-    }
-    else {
-        require(manifest.scenario.executable_sha256 ===
-            manifest.selected_executable_sha256, "manifest.selected_executable_sha256", "selected executable commitment does not match the scenario projection");
-    }
+    require(manifest.scenario.executable_sha256 ===
+        manifest.selected_executable_sha256, "manifest.selected_executable_sha256", "selected executable commitment does not match the scenario projection");
     require(manifest.executable_identity.state === "path_metadata_unchanged"
         ? manifest.executable_sha256 === manifest.selected_executable_sha256 &&
             manifest.executable_identity.reason === null
@@ -48,7 +39,7 @@ const validateOrdering = (capture, require) => {
         require(orderedTimestamps(values), name, "timestamps must be ordered");
 };
 const validateEventJournal = (capture, require) => {
-    const journal = capture.event_journal ?? [];
+    const journal = capture.event_journal;
     if (journal.length === 0)
         return;
     const sizes = {
@@ -83,6 +74,83 @@ const validateLifecycle = (capture, require) => {
         capture.exit.code ===
             null, "exit", "deadline termination cannot declare a normal exit code");
 };
+const validateCoverage = (capture, require) => {
+    const details = capture.truncation_details;
+    require(details.process.retained_samples === capture.process_samples.length &&
+        details.process.retained_samples <= details.process.sample_limit &&
+        details.process.sampling_partial ===
+            (details.process.sample_limit_reached ||
+                details.process.sampling_failures > 0) &&
+        (details.process.sampling_failures === 0) ===
+            (details.process.first_sampling_failure ===
+                null), "truncation_details.process", "sampling coverage must agree with retained samples and observed failures");
+    require(capture.truncated ===
+        hasCaptureTruncation(details), "truncation_details", "aggregate truncation must match producer coverage");
+    for (const [name, retention, count, bytes] of [
+        [
+            "raw_terminal",
+            details.raw_terminal,
+            capture.frames.length,
+            capture.frames.reduce((total, frame) => total + Buffer.byteLength(frame.raw_data ?? frame.data), 0),
+        ],
+        [
+            "rendered_terminal",
+            details.rendered_terminal,
+            capture.rendered_frames.length,
+            capture.rendered_frames.reduce((total, frame) => frame.lines.reduce((sum, line) => sum + Buffer.byteLength(line), total + Buffer.byteLength(frame.serialized_state)), 0),
+        ],
+    ]) {
+        // Whole frames are retained or omitted, so retained bytes are exactly the
+        // retained frames' bytes, and nothing is unretained when no frame was omitted.
+        require(retention.retained_frames === count &&
+            retention.observed_frames >= count &&
+            retention.retained_bytes === bytes &&
+            retention.observed_bytes >= retention.retained_bytes &&
+            (retention.observed_frames > count ||
+                retention.observed_bytes === retention.retained_bytes) &&
+            retention.retained_bytes <=
+                retention.budget_bytes, `truncation_details.${name}`, "retained observations and budget accounting do not agree");
+    }
+    for (const [name, coverage, files, checkpoint] of [
+        [
+            "filesystem_before",
+            details.filesystem_before,
+            capture.files_before,
+            capture.filesystem_checkpoints[0],
+        ],
+        [
+            "filesystem_after",
+            details.filesystem_after,
+            capture.files_after,
+            capture.filesystem_checkpoints[1],
+        ],
+    ]) {
+        const unhashedFiles = new Map(files
+            .filter((file) => file.type === "file" && file.sha256 === null)
+            .map((file) => [file.path, file]));
+        require(coverage.hash_omissions.length === unhashedFiles.size &&
+            new Set(coverage.hash_omissions.map(({ path }) => path)).size ===
+                unhashedFiles.size &&
+            coverage.hash_omissions.every((omission) => unhashedFiles.get(omission.path)?.size === omission.size_bytes &&
+                omission.remaining_budget_bytes <= coverage.hash_budget_bytes &&
+                (omission.reason === "file_unavailable"
+                    ? omission.system_code !== null
+                    : omission.system_code === null)), `truncation_details.${name}.hash_omissions`, "every retained regular file without a digest must have one matching omission reason");
+        require(coverage.hashed_bytes ===
+            files
+                .filter((file) => file.type === "file" && file.sha256 !== null)
+                .reduce((sum, file) => sum + file.size, 0) &&
+            coverage.hashed_bytes <= coverage.hash_budget_bytes &&
+            files.length <=
+                coverage.files_limit, `truncation_details.${name}`, "filesystem budget accounting does not match retained observations");
+        require(coverage.enumeration_truncated ===
+            coverage.enumeration_reasons.length > 0 &&
+            checkpoint?.truncated ===
+                (coverage.enumeration_truncated ||
+                    coverage.hash_omissions.length >
+                        0), `truncation_details.${name}`, "filesystem checkpoint truncation must match enumeration and digest coverage");
+    }
+};
 /** Recompute commitments and cross-field invariants without side effects. */
 export const collectProcessCaptureIssues = (capture) => {
     const issues = [];
@@ -94,5 +162,6 @@ export const collectProcessCaptureIssues = (capture) => {
     validateOrdering(capture, require);
     validateEventJournal(capture, require);
     validateLifecycle(capture, require);
+    validateCoverage(capture, require);
     return issues;
 };

package/dist/domain/process/processComparison.js

@@ -1,9 +1,13 @@
 import canonicalize from "canonicalize";
 import { z } from "zod";
+import { processSourceTruncated } from "./processCaptureCoverage.js";
+import { comparableTerminalFrame } from "./processObservation.js";
 import { AnalysisInputError } from "../analysisErrorCore.js";
 import { jsonValueSchema } from "../jsonValue.js";
-import { compareProcessTraces, processTraceOutcomesDiffer, processTraceComparisonResultSchema, } from "./processTraceComparison.js";
+import {} from "./processTraceSpecification.js";
+import { processTraceComparisonResultSchema } from "./processTraceEvaluation.js";
 import { dimensionsForTraceSources, traceCoversObservedDimension, } from "./processTraceDimensionProjection.js";
+import { compareProcessTraces, processTraceOutcomesDiffer, } from "./processTraceComparison.js";
 const OPERATION = "compare_process_captures";
 /** Comparison classification that never equates incomplete evidence. */
 export const comparisonStatusSchema = z.enum([
@@ -72,7 +76,10 @@ export const processCaptureComparisonSchema = z
         });
 });
 const terminalObservations = (capture) => [
-    ...capture.frames.map((frame) => ({ kind: "raw", ...frame })),
+    ...capture.frames.map((frame) => ({
+        kind: "raw",
+        ...comparableTerminalFrame(frame),
+    })),
     ...capture.rendered_frames.map((frame) => ({
         kind: "rendered",
         ...frame,
@@ -195,19 +202,6 @@ const differingContractFields = (left, right) => [...new Set([...Object.keys(lef
     !Object.hasOwn(right, field) ||
     canonicalize(left[field]) !== canonicalize(right[field]))
     .sort();
-const truncatedComparison = () => ({
-    status: "truncated",
-    terminal: "truncated",
-    interaction: "truncated",
-    exit: "truncated",
-    filesystem: "truncated",
-    process: "truncated",
-    first_divergence: {
-        status: "unknown",
-        reason: "At least one capture is truncated.",
-    },
-    limitations: ["At least one capture is truncated."],
-});
 const applyTraceVerdict = (dimensions, specification, trace, captures) => {
     const traceShowsDifference = processTraceOutcomesDiffer(trace);
     const traceStatus = trace.verdict === "unknown"
@@ -241,19 +235,23 @@ const applyTraceVerdict = (dimensions, specification, trace, captures) => {
     };
 };
 const compareDimensions = (left, right, sameNormalization) => {
-    const classify = (scope, leftValues, rightValues) => !sameNormalization || hasUnknown(left, scope) || hasUnknown(right, scope)
+    const classify = (scope, leftValues, rightValues, source) => !sameNormalization ||
+        hasUnknown(left, scope) ||
+        hasUnknown(right, scope) ||
+        processSourceTruncated(left, source) ||
+        processSourceTruncated(right, source)
         ? "unknown"
         : classifyCollection(leftValues, rightValues);
     return {
-        terminal: classify("terminal", terminalObservations(left), terminalObservations(right)),
-        interaction: classify("interaction", left.interaction_events, right.interaction_events),
+        terminal: classify("terminal", terminalObservations(left), terminalObservations(right), "terminal_rendered"),
+        interaction: classify("interaction", left.interaction_events, right.interaction_events, "interaction"),
         exit: hasUnknown(left, "exit") || hasUnknown(right, "exit")
             ? "unknown"
             : sameJsonValue({ exit: left.exit, settlement: left.settlement }, { exit: right.exit, settlement: right.settlement })
                 ? "unchanged"
                 : "changed",
-        filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right)),
-        process: classify("process", left.process_samples, right.process_samples),
+        filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right), "filesystem"),
+        process: classify("process", left.process_samples, right.process_samples, "process"),
     };
 };
 /**
@@ -264,15 +262,6 @@ const compareDimensions = (left, right, sameNormalization) => {
  */
 export const compareProcessCaptures = (left, right, options = {}) => {
     assertComparable(left, right, options);
-    if (left.truncated || right.truncated) {
-        const truncated = truncatedComparison();
-        return options.traceSpecification === undefined
-            ? truncated
-            : {
-                ...truncated,
-                trace: compareProcessTraces(left, right, options.traceSpecification),
-            };
-    }
     const sameNormalization = sameJsonValue(left.normalization, right.normalization);
     const exactDimensions = compareDimensions(left, right, sameNormalization);
     const trace = options.traceSpecification === undefined
@@ -284,25 +273,32 @@ export const compareProcessCaptures = (left, right, options = {}) => {
             left,
             right,
         ]);
-    const divergenceCandidates = PROCESS_COMPARISON_DIMENSIONS.map((dimension) => firstCollectionDivergence(dimension, processDimensionObservations(left, dimension), processDimensionObservations(right, dimension)));
+    const divergenceCandidates = PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension] === "unknown"
+        ? null
+        : firstCollectionDivergence(dimension, processDimensionObservations(left, dimension), processDimensionObservations(right, dimension)));
     const observedFirstDivergence = chooseFirstDivergence(divergenceCandidates.map((candidate) => candidate !== null &&
         trace?.verdict === "equivalent" &&
         dimensions[candidate.dimension] === "unchanged"
         ? null
         : candidate));
-    const firstDivergence = trace?.verdict === "equivalent" &&
-        deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension])) === "unchanged"
-        ? { status: "none" }
-        : observedFirstDivergence.status === "found"
-            ? observedFirstDivergence
-            : !sameNormalization ||
-                left.residual_unknowns.length > 0 ||
-                right.residual_unknowns.length > 0
-                ? {
-                    status: "unknown",
-                    reason: "Residual unknowns prevent proving that no divergence occurred.",
-                }
-                : observedFirstDivergence;
+    const firstDivergence = left.truncated || right.truncated
+        ? {
+            status: "unknown",
+            reason: "Incomplete observations prevent locating the first divergence; unaffected dimensions retain their comparisons.",
+        }
+        : trace?.verdict === "equivalent" &&
+            deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension])) === "unchanged"
+            ? { status: "none" }
+            : observedFirstDivergence.status === "found"
+                ? observedFirstDivergence
+                : !sameNormalization ||
+                    left.residual_unknowns.length > 0 ||
+                    right.residual_unknowns.length > 0
+                    ? {
+                        status: "unknown",
+                        reason: "Residual unknowns prevent proving that no divergence occurred.",
+                    }
+                    : observedFirstDivergence;
     const observedStatus = deriveProcessComparisonStatus(PROCESS_COMPARISON_DIMENSIONS.map((dimension) => dimensions[dimension]));
     return {
         status: observedStatus,