rea-agents 6.2.0 → 6.3.0

package/dist/domain/managed/managedApplicationGraphNodes.js

@@ -2,7 +2,6 @@ import { basename } from "node:path";
 import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "../javascript/javascriptApplicationGraph.js";
 import { managedSourceCoverage } from "./managedApplicationGraphCoverage.js";
 import {} from "./managedArtifact.js";
-import { moduleCoverageState } from "./managedApplicationGraphNodeCoverage.js";
 /** Add the root managed artifact node to the graph state. */
 export const addArtifactNode = (state) => {
     const node = createJavaScriptApplicationNode({
@@ -19,7 +18,7 @@ export const addArtifactNode = (state) => {
                     format: "pe",
                     source: "managed-application-graph",
                 },
-                evidence: managedEvidence(state, "project-managed-artifact"),
+                evidence: projectedManagedEvidence(state, "project-managed-artifact"),
             },
         ],
     });
@@ -28,36 +27,36 @@ export const addArtifactNode = (state) => {
 };
 /** Add managed assembly and module identity nodes for the artifact. */
 export const addArtifactIdentityNodes = (state, artifactNode, parsed) => {
-    const artifact = parsed.artifact?.result;
-    const artifactCoverage = managedSourceCoverage(parsed.artifact?.result.coverage.state ?? "complete");
-    if (artifact?.assembly !== undefined && artifact.assembly !== null) {
+    const artifactInput = parsed.artifact;
+    if (artifactInput !== null && artifactInput.result.assembly !== null) {
+        const assemblyFacts = artifactInput.result.assembly;
+        const artifactEvidence = sourceManagedEvidence(state, artifactInput.evidence, artifactInput.result.coverage.state);
         const assembly = createJavaScriptApplicationNode({
             kind: "managed-assembly",
-            identity: artifactLocalIdentity(state.artifactSha256, "managed-assembly", artifact.assembly.token),
+            identity: artifactLocalIdentity(state.artifactSha256, "managed-assembly", assemblyFacts.token),
             observations: [
                 {
-                    label: artifact.assembly.name,
+                    label: assemblyFacts.name,
                     properties: {
-                        name: artifact.assembly.name,
-                        version: artifact.assembly.version,
-                        culture: artifact.assembly.culture,
-                        public_key_kind: artifact.assembly.public_key.kind,
+                        name: assemblyFacts.name,
+                        version: assemblyFacts.version,
+                        culture: assemblyFacts.culture,
+                        public_key_kind: assemblyFacts.public_key.kind,
                     },
-                    evidence: managedEvidence(state, "inspect_managed_artifact", artifactCoverage),
+                    evidence: artifactEvidence,
                 },
             ],
         });
         state.nodes.push(assembly);
         addContainsEdge(state, artifactNode, assembly, {
             kind: "declares-managed-assembly",
-            coverage: artifactCoverage,
+            coverage: artifactEvidence.coverage,
         });
     }
-    const module = artifact?.module ??
-        parsed.members?.result.module ??
-        parsed.boundaries?.result.module;
-    if (module !== undefined && module !== null) {
-        const moduleCoverage = managedSourceCoverage(moduleCoverageState(parsed));
+    const moduleSource = selectModuleSource(parsed);
+    if (moduleSource !== null) {
+        const { module } = moduleSource;
+        const moduleEvidence = sourceManagedEvidence(state, moduleSource.evidence, moduleSource.coverageState);
         const moduleNode = createJavaScriptApplicationNode({
             kind: "managed-module",
             identity: artifactLocalIdentity(state.artifactSha256, "managed-module", module.mvid ?? module.token),
@@ -70,28 +69,51 @@ export const addArtifactIdentityNodes = (state, artifactNode, parsed) => {
                         generation: module.generation,
                         token: module.token,
                     },
-                    evidence: managedEvidence(state, "inspect_managed_artifact", moduleCoverage),
+                    evidence: moduleEvidence,
                 },
             ],
         });
         state.nodes.push(moduleNode);
         addContainsEdge(state, artifactNode, moduleNode, {
             kind: "declares-managed-module",
-            coverage: moduleCoverage,
+            coverage: moduleEvidence.coverage,
         });
     }
 };
+const selectModuleSource = (parsed) => {
+    if (parsed.artifact?.result.module != null)
+        return {
+            module: parsed.artifact.result.module,
+            evidence: parsed.artifact.evidence,
+            coverageState: parsed.artifact.result.coverage.state,
+        };
+    if (parsed.members?.result.module != null)
+        return {
+            module: parsed.members.result.module,
+            evidence: parsed.members.evidence,
+            coverageState: parsed.members.result.coverage.state,
+        };
+    if (parsed.boundaries?.result.module != null)
+        return {
+            module: parsed.boundaries.result.module,
+            evidence: parsed.boundaries.evidence,
+            coverageState: parsed.boundaries.result.coverage.state,
+        };
+    return null;
+};
 /** Add managed type, method, and field nodes from member evidence. */
 export const addMemberNodes = (state, artifactNode, parsed) => {
-    const members = parsed.members?.result;
-    if (members === undefined)
-        return { types: 0, methods: 0, fields: 0 };
+    const memberInput = parsed.members;
+    if (memberInput === null)
+        return;
+    const members = memberInput.result;
     const { types, methods, fields } = members;
     const typeCoverage = managedSourceCoverage(members.coverage.state);
     const methodCoverage = managedSourceCoverage(members.coverage.state);
     const fieldCoverage = managedSourceCoverage(members.coverage.state);
+    const sourceEvidence = sourceManagedEvidence(state, memberInput.evidence, members.coverage.state);
     for (const type of types) {
-        const node = typeNode(state, type, typeCoverage);
+        const node = typeNode(state, type, sourceEvidence);
         state.nodes.push(node);
         state.typeNodes.set(type.token, node);
         addContainsEdge(state, artifactNode, node, {
@@ -100,7 +122,7 @@ export const addMemberNodes = (state, artifactNode, parsed) => {
         });
     }
     for (const method of methods) {
-        const node = methodNode(state, method, methodCoverage);
+        const node = methodNode(state, method, sourceEvidence);
         state.nodes.push(node);
         state.methodNodes.set(method.token, node);
         const owner = method.declaring_type_token === null
@@ -112,7 +134,7 @@ export const addMemberNodes = (state, artifactNode, parsed) => {
         });
     }
     for (const field of fields) {
-        const node = fieldNode(state, field, fieldCoverage);
+        const node = fieldNode(state, field, sourceEvidence);
         state.nodes.push(node);
         state.fieldNodes.set(field.token, node);
         const owner = field.declaring_type_token === null
@@ -123,14 +145,9 @@ export const addMemberNodes = (state, artifactNode, parsed) => {
             coverage: fieldCoverage,
         });
     }
-    return {
-        types: types.length,
-        methods: methods.length,
-        fields: fields.length,
-    };
 };
 /** Build a managed type application node. */
-const typeNode = (state, type, coverage) => createJavaScriptApplicationNode({
+const typeNode = (state, type, evidence) => createJavaScriptApplicationNode({
     kind: "managed-type",
     identity: artifactLocalIdentity(state.artifactSha256, "managed-type-token", type.token),
     observations: [
@@ -144,12 +161,12 @@ const typeNode = (state, type, coverage) => createJavaScriptApplicationNode({
                 flags: type.flags,
                 extends_token: type.extends_token,
             },
-            evidence: managedEvidence(state, "inspect_managed_members", coverage),
+            evidence,
         },
     ],
 });
 /** Build a managed method application node. */
-const methodNode = (state, method, coverage) => createJavaScriptApplicationNode({
+const methodNode = (state, method, evidence) => createJavaScriptApplicationNode({
     kind: "managed-method",
     identity: artifactLocalIdentity(state.artifactSha256, "managed-method-token", method.token),
     observations: [
@@ -169,12 +186,12 @@ const methodNode = (state, method, coverage) => createJavaScriptApplicationNode(
                 normalized_il_sha256: method.body.normalized_il_sha256,
                 il_size: method.body.il_size,
             },
-            evidence: managedEvidence(state, "inspect_managed_members", coverage),
+            evidence,
         },
     ],
 });
 /** Build a managed field application node. */
-const fieldNode = (state, field, coverage) => createJavaScriptApplicationNode({
+const fieldNode = (state, field, evidence) => createJavaScriptApplicationNode({
     kind: "managed-field",
     identity: artifactLocalIdentity(state.artifactSha256, "managed-field-token", field.token),
     observations: [
@@ -191,24 +208,30 @@ const fieldNode = (state, field, coverage) => createJavaScriptApplicationNode({
                 signature_sha256: field.signature.raw_sha256,
                 signature_status: field.signature.parse_status,
             },
-            evidence: managedEvidence(state, "inspect_managed_members", coverage),
+            evidence,
         },
     ],
 });
 /** Add P/Invoke import and native implementation boundary nodes. */
 export const addBoundaryNodes = (state, artifactNode, parsed) => {
-    const boundaries = parsed.boundaries?.result;
-    if (boundaries === undefined)
-        return { pinvoke_imports: 0, native_implementations: 0 };
+    const boundaryInput = parsed.boundaries;
+    if (boundaryInput === null)
+        return;
+    const boundaries = boundaryInput.result;
     const { pinvoke_imports: pinvokes, native_implementations: implementations } = boundaries;
     const pinvokeCoverage = managedSourceCoverage(boundaries.coverage.state);
     const implementationCoverage = managedSourceCoverage(boundaries.coverage.state);
+    const sourceEvidence = sourceManagedEvidence(state, boundaryInput.evidence, boundaries.coverage.state);
     for (const pinvoke of pinvokes) {
-        const node = pinvokeNode(state, pinvoke, pinvokeCoverage);
+        const node = pinvokeNode(state, pinvoke, sourceEvidence);
         state.nodes.push(node);
-        const owner = pinvoke.member_token === null
-            ? artifactNode
-            : (state.methodNodes.get(pinvoke.member_token) ?? artifactNode);
+        const method = pinvoke.member_token === null
+            ? undefined
+            : state.methodNodes.get(pinvoke.member_token);
+        const memberEvidence = method === undefined || parsed.members === null
+            ? undefined
+            : parsed.members.evidence;
+        const owner = method ?? artifactNode;
         state.edges.push(createJavaScriptApplicationEdge({
             source_node_id: owner.node_id,
             target_node_id: node.node_id,
@@ -218,11 +241,11 @@ export const addBoundaryNodes = (state, artifactNode, parsed) => {
                 import_name: pinvoke.import_name,
                 import_scope_name: pinvoke.import_scope_name,
             },
-            evidence: managedEvidence(state, "inspect_managed_native_boundaries", pinvokeCoverage),
+            evidence: pinvokeAssociationEvidence(state, boundaryInput.evidence, pinvokeCoverage, memberEvidence),
         }));
     }
     for (const implementation of implementations) {
-        const node = nativeImplementationNode(state, implementation, implementationCoverage);
+        const node = nativeImplementationNode(state, implementation, sourceEvidence);
         state.nodes.push(node);
         const owner = state.methodNodes.get(implementation.token) ?? artifactNode;
         addContainsEdge(state, owner, node, {
@@ -230,13 +253,9 @@ export const addBoundaryNodes = (state, artifactNode, parsed) => {
             coverage: implementationCoverage,
         });
     }
-    return {
-        pinvoke_imports: pinvokes.length,
-        native_implementations: implementations.length,
-    };
 };
 /** Build a managed P/Invoke import application node. */
-const pinvokeNode = (state, pinvoke, coverage) => createJavaScriptApplicationNode({
+const pinvokeNode = (state, pinvoke, evidence) => createJavaScriptApplicationNode({
     kind: "managed-pinvoke-import",
     identity: artifactLocalIdentity(state.artifactSha256, "managed-pinvoke-token", pinvoke.token),
     observations: [
@@ -252,12 +271,12 @@ const pinvokeNode = (state, pinvoke, coverage) => createJavaScriptApplicationNod
                 call_convention: pinvoke.call_convention,
                 verification: pinvoke.verification,
             },
-            evidence: managedEvidence(state, "inspect_managed_native_boundaries", coverage),
+            evidence,
         },
     ],
 });
 /** Build a managed native implementation application node. */
-const nativeImplementationNode = (state, implementation, coverage) => createJavaScriptApplicationNode({
+const nativeImplementationNode = (state, implementation, evidence) => createJavaScriptApplicationNode({
     kind: "managed-native-implementation",
     identity: artifactLocalIdentity(state.artifactSha256, "managed-native-implementation-token", implementation.token),
     observations: [
@@ -273,7 +292,7 @@ const nativeImplementationNode = (state, implementation, coverage) => createJava
                 boundary_kind: implementation.boundary_kind,
                 body_interpretation: implementation.body_interpretation,
             },
-            evidence: managedEvidence(state, "inspect_managed_native_boundaries", coverage),
+            evidence,
         },
     ],
 });
@@ -284,7 +303,7 @@ const addContainsEdge = (state, source, target, options) => {
         target_node_id: target.node_id,
         relation: "contains",
         properties: { kind: options.kind },
-        evidence: managedEvidence(state, "project-managed-contains", options.coverage),
+        evidence: projectedManagedEvidence(state, "project-managed-contains", options.coverage),
     }));
 };
 /** Build an artifact-local key identity for a managed graph entity. */
@@ -296,7 +315,13 @@ const artifactLocalIdentity = (artifactSha256, namespace, key) => ({
     key,
 });
 /** Build managed static-analysis evidence for a graph observation. */
-const managedEvidence = (state, operation, coverage = managedSourceCoverage("complete")) => ({
+const sourceManagedEvidence = (state, source, coverageState) => createManagedEvidence(state, source.operation, managedSourceCoverage(coverageState), [source.evidence_id]);
+const projectedManagedEvidence = (state, operation, coverage = managedSourceCoverage("complete")) => createManagedEvidence(state, operation, coverage, state.evidenceLinks);
+const pinvokeAssociationEvidence = (state, boundaryEvidence, coverage, memberEvidence) => createManagedEvidence(state, boundaryEvidence.operation, coverage, [
+    boundaryEvidence.evidence_id,
+    ...(memberEvidence === undefined ? [] : [memberEvidence.evidence_id]),
+]);
+const createManagedEvidence = (state, operation, coverage, evidenceIds) => ({
     authority: "managed-static-analysis",
     state: "observed",
     confidence: "exact",
@@ -324,7 +349,7 @@ const managedEvidence = (state, operation, coverage = managedSourceCoverage("com
         : [
             "The source managed Evidence slice is incomplete; unreturned or unavailable items remain unobserved.",
         ],
-    evidence_ids: state.evidenceLinks,
+    evidence_ids: [...evidenceIds],
 });
 /** Sanitize an artifact path into a managed graph location. */
 const graphArtifactPath = (path) => {

package/dist/domain/managed/managedMemberComparisonMatch.js

@@ -11,21 +11,21 @@ export const sha256 = (value) => {
 const keyMethod = (item) => ({
     item,
     exactKey: item.body.status === "present" && item.body.normalized_il_sha256 !== null
-        ? stableKey([
+        ? sha256([
             "method-exact",
             item.signature.raw_sha256,
             item.body.normalized_il_sha256,
         ])
         : null,
     // The raw blob is the exact signature; decoding only feeds shape keys.
-    signatureKey: stableKey([
+    signatureKey: sha256([
         "method-signature",
         item.declaring_type,
         item.name,
         item.signature.raw_sha256,
     ]),
     structuralKey: item.signature.parse_status === "decoded" && item.body.status === "present"
-        ? stableKey([
+        ? sha256([
             "method-structural",
             item.signature.kind,
             item.signature.calling_convention,
@@ -56,24 +56,23 @@ const keyMethod = (item) => ({
 const keyField = (item) => ({
     item,
     exactKey: item.signature.parse_status === "decoded"
-        ? stableKey(["field-exact", item.signature.raw_sha256])
+        ? sha256(["field-exact", item.signature.raw_sha256])
         : null,
     // Only an undecoded field reaches this round: a decoded field with the
     // same raw signature already met its counterpart in the exact round.
-    signatureKey: stableKey([
+    signatureKey: sha256([
         "field-signature",
         item.declaring_type,
         item.name,
         item.signature.raw_sha256,
     ]),
-    structuralKey: stableKey([
+    structuralKey: sha256([
         "field-structural",
         item.signature.kind,
         item.signature.field_type,
         item.flags,
     ]),
 });
-const stableKey = (value) => sha256(value);
 const matchMethods = (left, right) => matchByKeys({
     left,
     right,

package/dist/domain/native/nativeCallObservation.js

@@ -3,7 +3,7 @@ import { localPathStringSchema } from "../localPath.js";
 const hexSchema = z.string().regex(/^0x[0-9a-f]+$/u);
 const nativeString = z
     .string()
-    .regex(/^[^\u0000]*$/u, "Native launch and breakpoint strings cannot contain NUL");
+    .regex(/^[^\x00]*$/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)
@@ -46,9 +46,7 @@ export const nativeCallObservationInputSchema = z.strictObject({
         .record(z
         .string()
         .min(1)
-        .regex(/^[^=\u0000]+$/u, "Environment names cannot contain '=' or NUL"), z
-        .string()
-        .regex(/^[^\u0000]*$/u, "Environment values cannot contain NUL"))
+        .regex(/^[^=\x00]+$/u, "Environment names cannot contain '=' or NUL"), z.string().regex(/^[^\x00]*$/u, "Environment values cannot contain NUL"))
         .default({})
         .describe("Overrides on top of the environment REA runs with."),
     working_directory: localPathStringSchema.optional(),

package/dist/domain/native/nativeValueFlow.js

@@ -16,9 +16,7 @@ export const nativePcodeOperationSchema = z.strictObject({
     sequence: z.number().int().nonnegative(),
     opcode: z.string().min(1),
     is_dead: z.boolean(),
-    block_membership: z
-        .enum(["member", "detached", "unavailable"])
-        .default("unavailable"),
+    block_membership: z.enum(["member", "detached", "unavailable"]),
     inputs: z.array(nativeVarnodeSchema),
     output: nativeVarnodeSchema.nullable(),
 });
@@ -50,20 +48,16 @@ export const nativeValueFlowSchema = z.discriminatedUnion("available", [
         operations: z.array(nativePcodeOperationSchema),
         def_use: z.array(nativePcodeDefUseSchema),
         effects: z.array(nativePcodeEffectSchema),
-        parameters: z
-            .array(z.strictObject({
+        parameters: z.array(z.strictObject({
             ordinal: z.number().int().nonnegative(),
             name: z.string(),
             data_type: z.string(),
-        }))
-            .default([]),
-        parameter_uses: z
-            .array(z.strictObject({
+        })),
+        parameter_uses: z.array(z.strictObject({
             ordinal: z.number().int().nonnegative(),
             use: z.string(),
             input_index: z.number().int().nonnegative(),
-        }))
-            .default([]),
+        })),
         truncated: z.boolean(),
         omitted_operations_lower_bound: z.number().int().nonnegative(),
         known_omitted_inputs: z.number().int().nonnegative(),

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/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";
-import { processCaptureTruncationDetailsSchema, } from "./processCaptureCoverage.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(),
@@ -175,7 +182,7 @@ const processCaptureShapeSchema = z.strictObject({
     files_after: z.array(fileStateSchema),
     filesystem_effects: z.array(fileEffectSchema),
     truncated: z.boolean(),
-    truncation_details: processCaptureTruncationDetailsSchema.optional(),
+    truncation_details: processCaptureTruncationDetailsSchema,
     limitations: z.array(z.string()),
     residual_unknowns: z.array(z.object({
         scope: z.enum([
@@ -221,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),

package/dist/domain/process/processCaptureCoverage.js

@@ -18,7 +18,12 @@ export const filesystemCoverageSchema = 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"]),
+        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. */
@@ -39,17 +44,15 @@ export const processCaptureTruncationDetailsSchema = z.strictObject({
 });
 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. */
+/** 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;
-/** Older truncated captures lack enough information to localize missing observations. */
+/** Whether producer accounting reports a gap in the selected observation source. */
 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);

package/dist/domain/process/processCaptureExample.js

@@ -56,6 +56,49 @@ export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
     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/processCaptureValidation.js

@@ -76,8 +76,6 @@ const validateLifecycle = (capture, require) => {
 };
 const validateCoverage = (capture, require) => {
     const details = capture.truncation_details;
-    if (details === undefined)
-        return;
     require(details.process.retained_samples === capture.process_samples.length &&
         details.process.retained_samples <= details.process.sample_limit &&
         details.process.sampling_partial ===
@@ -134,7 +132,10 @@ const validateCoverage = (capture, require) => {
             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), `truncation_details.${name}.hash_omissions`, "every retained regular file without a digest must have one matching omission reason");
+                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)