rea-agents 3.0.0 → 3.2.0

package/dist/domain/appleApplication.js

@@ -2,34 +2,27 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 import { parseArtifactInventoryEvidence } from "./artifactInventoryEvidence.js";
-import { projectBoundedCartesian } from "./boundedCartesianProjection.js";
 import { evidenceSchema } from "./evidence.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const boundedPathSchema = z.string().min(1).max(4_096);
+const pathSchema = z.string().min(1);
 const componentSchema = z.strictObject({
-    path: boundedPathSchema,
+    path: pathSchema,
     artifact_id: z.string().regex(/^art_[a-f0-9]{64}$/u),
     sha256: digestSchema,
-    format: z.string().min(1).max(100),
+    format: z.string().min(1),
 });
 /** Authenticated artifact inventory pages projected as one Apple application. */
 export const appleApplicationProjectionInputSchema = z.strictObject({
-    inventory_evidence: z.array(evidenceSchema).min(1).max(100),
-    limits: z
-        .strictObject({
-        max_components: z.number().int().min(1).max(10_000).default(1_000),
-    })
-        .default({ max_components: 1_000 }),
+    inventory_evidence: z.array(evidenceSchema).min(1),
 });
 /** Deterministic, execution-free Apple application inventory projection. */
 export const appleApplicationProjectionResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     projection_id: z.string().regex(/^aap_[a-f0-9]{64}$/u),
     root_sha256: digestSchema,
     root_format: z.literal("ipa"),
-    source_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    application_roots: z.array(boundedPathSchema),
+    source_evidence_ids: z.array(evidenceIdSchema).min(1),
+    application_roots: z.array(pathSchema),
     components: z.strictObject({
         bundle_metadata: z.array(componentSchema),
         executables: z.array(componentSchema),
@@ -47,8 +40,8 @@ export const appleApplicationProjectionResultSchema = z.strictObject({
         "unity",
     ])),
     bridge_candidates: z.array(z.strictObject({
-        source_path: boundedPathSchema,
-        native_path: boundedPathSchema,
+        source_path: pathSchema,
+        native_path: pathSchema,
         basis: z.enum([
             "javascript-and-native-content",
             "react-native-convention",
@@ -57,12 +50,10 @@ export const appleApplicationProjectionResultSchema = z.strictObject({
         ]),
     })),
     coverage: z.strictObject({
-        status: z.enum(["complete-within-inventory", "partial", "truncated"]),
+        status: z.enum(["complete-within-inventory", "partial"]),
         inventory_complete: z.boolean(),
-        omitted_components: z.number().int().min(0),
-        omitted_bridge_candidates: z.number().int().min(0),
     }),
-    limitations: z.array(z.string().min(1).max(4_096)).max(100),
+    limitations: z.array(z.string().min(1)),
 });
 /** Project exact IPA paths and hashes without parsing or executing target code. */
 export const projectAppleApplication = (input) => {
@@ -91,34 +82,27 @@ export const projectAppleApplication = (input) => {
         })),
     ].sort(compare);
     const classified = classifyComponents(all, roots);
-    const retained = retainComponents(classified, parsed.limits.max_components);
-    const omitted = componentCount(classified) - componentCount(retained);
     const runtimeFamilies = identifyRuntimeFamilies(all);
-    const bridgeProjection = identifyBridgeCandidates(retained.javascript, deduplicateComponents([
-        ...retained.executables,
-        ...retained.native_libraries,
-    ]), parsed.limits.max_components);
-    const limitations = projectionLimitations(inventory.complete, omitted, bridgeProjection.omitted, roots);
+    const bridgeProjection = identifyBridgeCandidates(classified.javascript, deduplicateComponents([
+        ...classified.executables,
+        ...classified.native_libraries,
+    ]));
+    const limitations = projectionLimitations(inventory.complete, roots);
     const withoutId = {
-        schema_version: 1,
         root_sha256: inventory.manifest.root_sha256,
         root_format: "ipa",
         source_evidence_ids: evidence
             .map(({ evidence_id: id }) => id)
             .sort(compare),
         application_roots: roots,
-        components: retained,
+        components: classified,
         runtime_families: runtimeFamilies,
         bridge_candidates: bridgeProjection.candidates,
         coverage: {
-            status: omitted > 0 || bridgeProjection.omitted > 0
-                ? "truncated"
-                : inventory.complete
-                    ? "complete-within-inventory"
-                    : "partial",
+            status: inventory.complete
+                ? "complete-within-inventory"
+                : "partial",
             inventory_complete: inventory.complete,
-            omitted_components: omitted,
-            omitted_bridge_candidates: bridgeProjection.omitted,
         },
         limitations,
     };
@@ -138,17 +122,6 @@ const classifyComponents = (all, roots) => {
         signing: all.filter(({ path }) => /(?:^|\/)(?:embedded\.mobileprovision|_CodeSignature\/CodeResources)$/u.test(path)),
     };
 };
-const retainComponents = (groups, maximum) => {
-    let remaining = maximum;
-    return Object.fromEntries(Object.entries(groups).map(([key, values]) => {
-        const retained = [...values]
-            .sort((left, right) => compare(left.path, right.path))
-            .slice(0, remaining);
-        remaining -= retained.length;
-        return [key, retained];
-    }));
-};
-const componentCount = (groups) => Object.values(groups).reduce((total, values) => total + values.length, 0);
 const deduplicateComponents = (values) => [...new Map(values.map((value) => [value.path, value])).values()].sort((left, right) => compare(left.path, right.path));
 const identifyRuntimeFamilies = (all) => {
     const paths = all.map(({ path }) => path.toLowerCase());
@@ -169,17 +142,13 @@ const identifyRuntimeFamilies = (all) => {
         families.add("unity");
     return [...families].sort(compare);
 };
-const identifyBridgeCandidates = (scripts, native, maximum) => {
-    const projection = projectBoundedCartesian(scripts, native, maximum, (script, item) => ({
+const identifyBridgeCandidates = (scripts, native) => ({
+    candidates: scripts.flatMap((script) => native.map((item) => ({
         source_path: script.path,
         native_path: item.path,
         basis: bridgeBasis(item.path),
-    }));
-    return {
-        candidates: projection.values,
-        omitted: projection.omitted,
-    };
-};
+    }))),
+});
 const bridgeBasis = (path) => {
     const lower = path.toLowerCase();
     if (lower.includes("react"))
@@ -190,20 +159,10 @@ const bridgeBasis = (path) => {
         return "unity-convention";
     return "javascript-and-native-content";
 };
-const projectionLimitations = (complete, omitted, omittedBridges, roots) => [
+const projectionLimitations = (complete, roots) => [
     ...(!complete
         ? ["Source inventory pages are incomplete; absence is unknown."]
         : []),
-    ...(omitted > 0
-        ? [
-            `${String(omitted)} component observations were omitted by the projection limit.`,
-        ]
-        : []),
-    ...(omittedBridges > 0
-        ? [
-            `${String(omittedBridges)} bridge hypotheses were omitted by the projection limit.`,
-        ]
-        : []),
     ...(roots.length === 0
         ? [
             "No Payload/*.app directory was present in the supplied inventory pages.",

package/dist/domain/artifactComparison.js

@@ -1,6 +1,7 @@
 import canonicalize from "canonicalize";
 import { z } from "zod";
 import {} from "./artifactGraph.js";
+import { evidenceSchema } from "./evidence.js";
 import { parseArtifactInventoryEvidence, } from "./artifactInventoryEvidence.js";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const comparisonStatusSchema = z.enum([
@@ -32,20 +33,14 @@ const comparisonDimensionSchema = z.enum([
 ]);
 /** Strict Evidence-backed input for deterministic artifact comparison. */
 export const artifactComparisonInputSchema = z.strictObject({
-    left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(500).default(100),
-    unknown_registry_approved: z
-        .literal(true)
-        .optional()
-        .describe("Explicit approval to record incomplete or differing evidence"),
+    left: evidenceSchema,
+    right: evidenceSchema,
 });
 /** One path-classified artifact change with citations to both observations. */
 const artifactChangeSchema = z.object({
     classification: changeKindSchema,
-    logical_path: z.string().min(1).max(4_096),
-    dimensions: z.array(comparisonDimensionSchema).min(1).max(8),
+    logical_path: z.string().min(1),
+    dimensions: z.array(comparisonDimensionSchema).min(1),
     left_occurrence_id: z
         .string()
         .regex(/^occ_[a-f0-9]{64}$/u)
@@ -62,9 +57,9 @@ const artifactChangeSchema = z.object({
         .string()
         .regex(/^art_[a-f0-9]{64}$/u)
         .nullable(),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(200),
+    evidence_links: z.array(evidenceIdSchema).min(2),
 });
-/** Bounded deterministic artifact comparison with an independently paged delta. */
+/** Deterministic artifact comparison with every change returned inline. */
 export const artifactComparisonResultSchema = z.object({
     status: comparisonStatusSchema,
     left_manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
@@ -77,17 +72,11 @@ export const artifactComparisonResultSchema = z.object({
         unknown: z.number().int().min(0),
         contradiction: z.number().int().min(0).default(0),
     }),
-    changes: z.object({
-        items: z.array(artifactChangeSchema).max(500),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(500),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-    }),
+    changes: z.array(artifactChangeSchema),
     limitations: z.array(z.string()),
 });
-/** Compare complete inventory pages without treating missing evidence as equality. */
-export const compareArtifacts = (leftEvidence, rightEvidence, offset, limit) => {
+/** Compare complete inventory evidence without treating missing evidence as equality. */
+export const compareArtifacts = (leftEvidence, rightEvidence) => {
     const left = parseArtifactInventoryEvidence(leftEvidence);
     const right = parseArtifactInventoryEvidence(rightEvidence);
     const leftComplete = left.inventory.complete;
@@ -105,7 +94,6 @@ export const compareArtifacts = (leftEvidence, rightEvidence, offset, limit) =>
         ...right.evidence.map(({ evidence_id: id }) => id),
     ], leftCovered && rightCovered);
     const summary = summarize(left.inventory, right.inventory, changes, leftCovered && rightCovered);
-    const page = changes.slice(offset, offset + limit);
     return artifactComparisonResultSchema.parse({
         status: !leftComplete || !rightComplete
             ? "truncated"
@@ -121,13 +109,7 @@ export const compareArtifacts = (leftEvidence, rightEvidence, offset, limit) =>
         left_manifest_id: left.inventory.manifest.manifest_id,
         right_manifest_id: right.inventory.manifest.manifest_id,
         summary,
-        changes: {
-            items: page,
-            offset,
-            limit,
-            total: changes.length,
-            next_offset: offset + page.length < changes.length ? offset + page.length : null,
-        },
+        changes,
         limitations: [...new Set(limitations)].sort((a, b) => a.localeCompare(b)),
     });
 };

package/dist/domain/artifactGraph.js

@@ -9,7 +9,6 @@ const contradictionIdSchema = z.string().regex(/^ic_[a-f0-9]{64}$/u);
 const boundedRelativePathSchema = z
     .string()
     .min(1)
-    .max(4_096)
     .refine((path) => !path.startsWith("/") &&
     !path.includes("\\") &&
     path.split("/").every((part) => part !== "" && part !== ".."), "Expected a normalized relative POSIX path without traversal");
@@ -53,28 +52,19 @@ const artifactFormatSchema = z.enum([
     "file",
     "unknown",
 ]);
-/** Exact bounded policy applied while discovering or extracting artifacts. */
-const artifactTraversalLimitsSchema = z.object({
-    max_entries: z.number().int().min(1).max(1_000_000),
-    max_total_bytes: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-    max_entry_bytes: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-    max_compression_ratio: z.number().min(1).max(100_000),
-    max_depth: z.number().int().min(0).max(100),
-    max_path_bytes: z.number().int().min(1).max(65_535),
-});
 /** File byte interval for an artifact derived without writing it to disk. */
 const artifactByteRangeSchema = z.object({
     offset: z.number().int().min(0),
     length: z.number().int().min(0),
 });
-/** Bounded external command provenance, including observable side effects. */
+/** External command provenance, including observable side effects. */
 const artifactCommandSchema = z.object({
     tool: z.string().min(1),
-    arguments: z.array(z.string().max(4_096)).max(1_024),
+    arguments: z.array(z.string()),
     tool_version: z.string().nullable(),
     executable_sha256: sha256Schema.nullable(),
     exit_code: z.number().int().nullable(),
-    effects: z.array(z.enum(["read", "write", "mount"])).max(3),
+    effects: z.array(z.enum(["read", "write", "mount"])),
 });
 /** One content-addressed application artifact in deterministic manifest order. */
 const artifactNodeSchema = z.object({
@@ -110,12 +100,7 @@ const artifactOccurrenceSchema = z.object({
         .nullable(),
     executable: z.boolean(),
     encrypted: z.boolean(),
-    hash_status: z.enum([
-        "verified",
-        "mismatched",
-        "not-hashed-limit",
-        "unavailable",
-    ]),
+    hash_status: z.enum(["verified", "mismatched", "not-hashed", "unavailable"]),
     source_location: artifactByteRangeSchema.nullable(),
     limitations: z.array(z.string()),
 });
@@ -154,7 +139,6 @@ const artifactEdgeSchema = z.object({
 });
 /** Stable cryptographic commitment and counts for a complete artifact graph. */
 const artifactGraphManifestSchema = z.object({
-    schema_version: z.literal(1),
     manifest_id: manifestIdSchema,
     root_artifact_id: artifactIdSchema,
     root_sha256: sha256Schema,
@@ -164,26 +148,14 @@ const artifactGraphManifestSchema = z.object({
     occurrence_count: z.number().int().min(1),
     edge_count: z.number().int().min(0),
 });
-/** Independently bounded offset page used for deterministic graph traversal. */
-const artifactPageSchema = (item) => z.object({
-    items: z.array(item).max(500),
-    offset: z.number().int().min(0),
-    limit: z.number().int().min(1).max(500),
-    total: z.number().int().min(0),
-    next_offset: z.number().int().min(0).nullable(),
-});
-/** Inventory observation containing stable manifest identity and bounded pages. */
+/** Complete inventory observation containing the stable artifact graph. */
 export const artifactInventoryResultSchema = z.object({
     manifest: artifactGraphManifestSchema,
-    nodes: artifactPageSchema(artifactNodeSchema),
-    occurrences: artifactPageSchema(artifactOccurrenceSchema),
-    edges: artifactPageSchema(artifactEdgeSchema),
-    limits: artifactTraversalLimitsSchema,
-    provenance: z.array(artifactCommandSchema).max(256),
-    integrity_contradictions: z
-        .array(integrityContradictionSchema)
-        .max(100)
-        .default([]),
+    nodes: z.array(artifactNodeSchema),
+    occurrences: z.array(artifactOccurrenceSchema),
+    edges: z.array(artifactEdgeSchema),
+    provenance: z.array(artifactCommandSchema),
+    integrity_contradictions: z.array(integrityContradictionSchema).default([]),
     limitations: z.array(z.string()),
 });
 /** One safely materialized artifact beneath caller-approved output root. */
@@ -196,10 +168,9 @@ const extractedArtifactSchema = z.object({
 });
 /** Path-independent commitment to one selected extraction operation. */
 const artifactExtractionManifestSchema = z.object({
-    schema_version: z.literal(1),
     extraction_id: extractionIdSchema,
     source_manifest_id: manifestIdSchema,
-    selected_occurrence_ids: z.array(occurrenceIdSchema).min(1).max(500),
+    selected_occurrence_ids: z.array(occurrenceIdSchema).min(1),
     files_sha256: sha256Schema,
     output_root_alias: z.literal("$OUTPUT_ROOT"),
 });
@@ -208,14 +179,13 @@ export const artifactExtractionResultSchema = z.object({
     manifest: artifactGraphManifestSchema,
     extraction_manifest: artifactExtractionManifestSchema,
     output_root: z.string().min(1),
-    artifacts: artifactPageSchema(extractedArtifactSchema),
+    artifacts: z.array(extractedArtifactSchema),
     containment_verified: z.boolean(),
     cleanup: z.object({
         attempted: z.boolean(),
         verified: z.boolean(),
-        residual_paths: z.array(boundedRelativePathSchema).max(500),
+        residual_paths: z.array(boundedRelativePathSchema),
     }),
-    limits: artifactTraversalLimitsSchema,
-    provenance: z.array(artifactCommandSchema).max(256),
+    provenance: z.array(artifactCommandSchema),
     limitations: z.array(z.string()),
 });

package/dist/domain/artifactInspection.js

@@ -4,22 +4,13 @@ import { z } from "zod";
 import { artifactInventoryResultSchema, } from "./artifactGraph.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { jsonValueSchema } from "./jsonValue.js";
-const boundedTextSchema = z.string().min(1).max(4_096);
+const textSchema = z.string().min(1);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const artifactIdSchema = z.string().regex(/^art_[a-f0-9]{64}$/u);
-const inspectionLimitsSchema = z.strictObject({
-    max_observations: z.number().int().min(1).max(500).default(100),
-    max_relationships: z.number().int().min(1).max(500).default(100),
-    max_hypotheses: z.number().int().min(1).max(100).default(20),
-    max_unexplored_branches: z.number().int().min(1).max(100).default(20),
-    max_next_probes: z.number().int().min(1).max(50).default(20),
-    max_substeps: z.literal(1).default(1),
-});
-export const artifactInspectionLimitsSchema = inspectionLimitsSchema;
 const inspectionObservationSchema = z.strictObject({
     observation_id: z.string().regex(/^aio_[a-f0-9]{64}$/u),
     kind: z.enum(["root-manifest", "artifact", "occurrence", "integrity"]),
-    subject: boundedTextSchema,
+    subject: textSchema,
     value: jsonValueSchema,
     evidence_id: evidenceIdSchema,
 });
@@ -37,27 +28,27 @@ const inspectionRelationshipSchema = z.strictObject({
     source_artifact_id: artifactIdSchema,
     target_artifact_id: artifactIdSchema,
     occurrence_id: z.string().regex(/^occ_[a-f0-9]{64}$/u),
-    logical_path: boundedTextSchema.nullable(),
+    logical_path: textSchema.nullable(),
     evidence_id: evidenceIdSchema,
 });
 const inspectionHypothesisSchema = z.strictObject({
     hypothesis_id: z.string().regex(/^aih_[a-f0-9]{64}$/u),
-    statement: boundedTextSchema,
+    statement: textSchema,
     confidence: z.enum(["medium", "low"]),
-    basis_evidence_ids: z.array(evidenceIdSchema).min(1).max(8),
-    limitation: boundedTextSchema,
+    basis_evidence_ids: z.array(evidenceIdSchema).min(1),
+    limitation: textSchema,
 });
 const inspectionContradictionSchema = z.strictObject({
     contradiction_id: z.string().regex(/^aic_[a-f0-9]{64}$/u),
-    statement: boundedTextSchema,
+    statement: textSchema,
     occurrence_id: z.string().regex(/^occ_[a-f0-9]{64}$/u),
     declared_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     observed_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     evidence_id: evidenceIdSchema,
 });
 const nextProbeSchema = z.strictObject({
-    operation: z.string().min(1).max(128),
-    rationale: boundedTextSchema,
+    operation: textSchema,
+    rationale: textSchema,
     authority: z.enum([
         "artifact-bytes",
         "managed-static-analysis",
@@ -67,24 +58,19 @@ const nextProbeSchema = z.strictObject({
 });
 const unexploredBranchSchema = z.strictObject({
     branch_id: z.string().regex(/^aib_[a-f0-9]{64}$/u),
-    reason: z.enum([
-        "page-limit",
-        "format-specific-analysis-required",
-        "unknown-format",
-    ]),
-    detail: boundedTextSchema,
+    reason: z.enum(["format-specific-analysis-required", "unknown-format"]),
+    detail: textSchema,
     next_probe: nextProbeSchema.nullable(),
     evidence_id: evidenceIdSchema,
 });
 /** Provider-neutral inspection result with its atomic source Evidence. */
 export const artifactInspectionResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     inspection_id: z.string().regex(/^ai_[a-f0-9]{64}$/u),
     subject: z.strictObject({
         manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
         root_artifact_id: artifactIdSchema,
         root_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-        root_format: z.string().min(1).max(128),
+        root_format: textSchema,
     }),
     substeps: z
         .array(z.strictObject({
@@ -94,14 +80,13 @@ export const artifactInspectionResultSchema = z.strictObject({
         evidence_id: evidenceIdSchema,
         evidence: evidenceSchema,
     }))
-        .min(1)
-        .max(1),
-    observations: z.array(inspectionObservationSchema).max(500),
-    derived_relationships: z.array(inspectionRelationshipSchema).max(500),
-    hypotheses: z.array(inspectionHypothesisSchema).max(100),
-    contradictions: z.array(inspectionContradictionSchema).max(100),
-    unexplored_branches: z.array(unexploredBranchSchema).max(100),
-    next_probes: z.array(nextProbeSchema).max(50),
+        .min(1),
+    observations: z.array(inspectionObservationSchema),
+    derived_relationships: z.array(inspectionRelationshipSchema),
+    hypotheses: z.array(inspectionHypothesisSchema),
+    contradictions: z.array(inspectionContradictionSchema),
+    unexplored_branches: z.array(unexploredBranchSchema),
+    next_probes: z.array(nextProbeSchema),
     coverage: z.strictObject({
         status: z.enum(["complete-within-substeps", "partial", "truncated"]),
         substeps_completed: z.literal(1),
@@ -116,11 +101,11 @@ export const artifactInspectionResultSchema = z.strictObject({
         next_probes_retained: z.number().int().min(0),
         next_probes_omitted: z.number().int().min(0),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(1),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+    limitations: z.array(textSchema),
 });
 /** Project one successful inventory Evidence record into an inspection report. */
-export const createArtifactInspection = (inventoryInput, limits) => {
+export const createArtifactInspection = (inventoryInput) => {
     const inventoryEvidence = parseInventoryEvidence(inventoryInput);
     const inventory = artifactInventoryResultSchema.parse(inventoryEvidence.normalized_result);
     const observations = allObservations(inventory, inventoryEvidence.evidence_id);
@@ -129,21 +114,20 @@ export const createArtifactInspection = (inventoryInput, limits) => {
     const nextProbes = probesFor(inventory);
     const branches = allUnexploredBranches(inventory, inventoryEvidence.evidence_id, nextProbes);
     const retained = {
-        observations: observations.slice(0, limits.max_observations),
-        relationships: relationships.slice(0, limits.max_relationships),
-        hypotheses: hypotheses.slice(0, limits.max_hypotheses),
-        branches: branches.slice(0, limits.max_unexplored_branches),
-        probes: nextProbes.slice(0, limits.max_next_probes),
+        observations,
+        relationships,
+        hypotheses,
+        branches,
+        probes: nextProbes,
     };
     const omissions = {
-        observations: observations.length - retained.observations.length,
-        relationships: relationships.length - retained.relationships.length,
-        hypotheses: hypotheses.length - retained.hypotheses.length,
-        branches: branches.length - retained.branches.length,
-        probes: nextProbes.length - retained.probes.length,
+        observations: 0,
+        relationships: 0,
+        hypotheses: 0,
+        branches: 0,
+        probes: 0,
     };
     const semantic = {
-        schema_version: 1,
         subject: {
             manifest_id: inventory.manifest.manifest_id,
             root_artifact_id: inventory.manifest.root_artifact_id,
@@ -201,8 +185,8 @@ const parseInventoryEvidence = (input) => {
 };
 const allObservations = (inventory, evidenceId) => [
     observation("root-manifest", inventory.manifest.root_artifact_id, inventory.manifest, evidenceId),
-    ...inventory.nodes.items.map((node) => observation("artifact", node.artifact_id, node, evidenceId)),
-    ...inventory.occurrences.items.map((occurrence) => observation("occurrence", occurrence.occurrence_id, occurrence, evidenceId)),
+    ...inventory.nodes.map((node) => observation("artifact", node.artifact_id, node, evidenceId)),
+    ...inventory.occurrences.map((occurrence) => observation("occurrence", occurrence.occurrence_id, occurrence, evidenceId)),
     ...inventory.integrity_contradictions.map((value) => observation("integrity", value.contradiction_id, value, evidenceId)),
 ];
 const observation = (kind, subject, value, evidenceId) => {
@@ -214,7 +198,7 @@ const observation = (kind, subject, value, evidenceId) => {
     };
     return { observation_id: `aio_${digestCanonical(semantic)}`, ...semantic };
 };
-const allRelationships = (inventory, evidenceId) => inventory.edges.items.map((edge) => {
+const allRelationships = (inventory, evidenceId) => inventory.edges.map((edge) => {
     const semantic = {
         relation: edge.relation,
         source_artifact_id: edge.parent_artifact_id,
@@ -303,16 +287,7 @@ const probesFor = (inventory) => {
     return [];
 };
 const allUnexploredBranches = (inventory, evidenceId, nextProbes) => {
-    const pages = [
-        ["nodes", inventory.nodes.next_offset],
-        ["occurrences", inventory.occurrences.next_offset],
-        ["relationships", inventory.edges.next_offset],
-    ];
-    const branches = pages.flatMap(([collection, nextOffset]) => nextOffset === null
-        ? []
-        : [
-            branch("page-limit", `${collection} continue at offset ${String(nextOffset)}.`, null, evidenceId),
-        ]);
+    const branches = [];
     branches.push(...nextProbes.map((probe) => branch("format-specific-analysis-required", `${probe.operation} was not run by provider-neutral artifact inspection.`, probe, evidenceId)));
     if (inventory.manifest.root_format === "unknown")
         branches.push(branch("unknown-format", "Artifact bytes did not match an admitted format classifier.", null, evidenceId));
@@ -327,16 +302,10 @@ const branch = (reason, detail, nextProbe, evidenceId) => {
     };
     return { branch_id: `aib_${digestCanonical(semantic)}`, ...semantic };
 };
-const inspectionCoverage = (inventory, omissions) => {
+const inspectionCoverage = (_inventory, omissions) => {
     if (Object.values(omissions).some((count) => count > 0))
         return "truncated";
-    return [
-        inventory.nodes.next_offset,
-        inventory.occurrences.next_offset,
-        inventory.edges.next_offset,
-    ].some((offset) => offset !== null)
-        ? "partial"
-        : "complete-within-substeps";
+    return "complete-within-substeps";
 };
 const digestCanonical = (value) => {
     const encoded = canonicalize(value);