rea-agents 3.0.0 → 3.2.0

package/dist/domain/replayMachineRuntime.js

@@ -1,15 +1,11 @@
-import canonicalize from "canonicalize";
 import { z } from "zod";
+import { isJsonCompatible, replayValuesEqual } from "./replayMachineValues.js";
 /** One bounded inbound protocol event offered to a replay machine. */
 const replayEventHeadersSchema = z
     .record(z
     .string()
     .min(1)
-    .max(256)
-    .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z
-    .string()
-    .max(8_192)
-    .regex(/^[\t\x20-\x7e\x80-\xff]*$/u))
+    .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z.string().regex(/^[\t\x20-\x7e\x80-\xff]*$/u))
     .superRefine((headers, context) => {
     const normalized = Object.keys(headers).map((name) => name.toLowerCase());
     if (new Set(normalized).size !== normalized.length)
@@ -20,10 +16,10 @@ const replayEventHeadersSchema = z
         });
 });
 const replayEventFields = {
-    at_ms: z.number().int().nonnegative().safe(),
-    path: z.string().startsWith("/").max(8_192),
+    at_ms: z.number().int().safe().nonnegative(),
+    path: z.string().startsWith("/"),
     headers: replayEventHeadersSchema,
-    body: z.string().max(1_000_000),
+    body: z.string(),
 };
 export const replayMachineEventSchema = z.discriminatedUnion("protocol", [
     z.strictObject({
@@ -32,7 +28,6 @@ export const replayMachineEventSchema = z.discriminatedUnion("protocol", [
         method: z
             .string()
             .min(1)
-            .max(16)
             .transform((method) => method.toUpperCase()),
         ...replayEventFields,
     }),
@@ -51,7 +46,8 @@ export const replayMachineEventSchema = z.discriminatedUnion("protocol", [
 ]);
 const parseJson = (value) => {
     try {
-        return JSON.parse(value);
+        const parsed = JSON.parse(value);
+        return parsed;
     }
     catch {
         return undefined;
@@ -70,7 +66,8 @@ const atPath = (value, path) => {
             current === null ||
             !Object.hasOwn(current, segment))
             return undefined;
-        current = current[segment];
+        const next = Reflect.get(current, segment);
+        current = next;
     }
     return current;
 };
@@ -82,6 +79,7 @@ const actionJsonBody = (transition) => {
             return action.data;
     return undefined;
 };
+const triggerKey = (transition) => `${transition.trigger.protocol}\0${transition.trigger.path}`;
 const readValue = (source, event, transition) => {
     switch (source.source) {
         case "request_header":
@@ -112,20 +110,6 @@ const triggerMatches = (transition, event) => {
         return trigger.body === null || trigger.body === event.body;
     return true;
 };
-const isJsonCompatible = (value) => {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return true;
-    if (typeof value === "number")
-        return Number.isFinite(value);
-    if (Array.isArray(value))
-        return value.every(isJsonCompatible);
-    if (typeof value !== "object")
-        return false;
-    return Object.values(value).every(isJsonCompatible);
-};
-const replayValuesEqual = (left, right) => isJsonCompatible(left) &&
-    isJsonCompatible(right) &&
-    (Object.is(left, right) || canonicalize(left) === canonicalize(right));
 const createTransitionRecord = ({ sequence, atMs, stateBefore, transition, captures, }) => ({
     sequence,
     at_ms: atMs,
@@ -140,6 +124,7 @@ const createTransitionRecord = ({ sequence, atMs, stateBefore, transition, captu
 /** Stateful evaluator for one validated replay-machine instance. */
 export class ReplayMachineRuntime {
     machine;
+    #transitionsByTrigger = new Map();
     #variables = new Map();
     #sensitiveValues = new Map();
     #uses = new Map();
@@ -155,6 +140,16 @@ export class ReplayMachineRuntime {
         this.machine = machine;
         this.#state = machine.initial_state;
         this.#stateVisits.set(machine.initial_state, 1);
+        const byTrigger = new Map();
+        for (const [declarationOrder, transition,] of machine.transitions.entries()) {
+            const key = triggerKey(transition);
+            const indexed = byTrigger.get(key) ?? [];
+            indexed.push({ transition, declarationOrder });
+            byTrigger.set(key, indexed);
+        }
+        for (const [key, indexed] of byTrigger)
+            this.#transitionsByTrigger.set(key, indexed.sort((left, right) => left.transition.priority - right.transition.priority ||
+                left.declarationOrder - right.declarationOrder));
     }
     /** Current machine state after all accepted transitions. */
     get state() {
@@ -205,25 +200,11 @@ export class ReplayMachineRuntime {
         };
         if (!this.#admitEvent(normalizedEvent))
             return this.#refusal("limit_exhausted");
-        const matching = this.machine.transitions
-            .map((transition, declarationOrder) => ({
-            transition,
-            declarationOrder,
-        }))
-            .filter(({ transition }) => triggerMatches(transition, normalizedEvent));
-        const eligible = matching
-            .filter(({ transition }) => transition.from === this.#state)
-            .sort((left, right) => left.transition.priority - right.transition.priority ||
-            left.declarationOrder - right.declarationOrder);
+        const matching = this.#matchingTransitions(normalizedEvent);
+        const eligible = matching.filter(({ transition }) => this.#transitionStartsHere(transition));
         if (eligible.length === 0)
-            return this.#refusal(matching.length === 0
-                ? "unmatched"
-                : normalizedEvent.protocol === "websocket_connect" &&
-                    normalizedEvent.connection === "reconnect"
-                    ? "unexpected_reconnect"
-                    : "invalid_state");
-        const guarded = eligible.filter(({ transition }) => transition.guards.every((guard) => this.#variables.has(guard.variable) &&
-            replayValuesEqual(this.#variables.get(guard.variable), readValue(guard.value, normalizedEvent, transition))));
+            return this.#refusal(this.#noEligibleReason(matching, normalizedEvent));
+        const guarded = eligible.filter(({ transition }) => this.#transitionGuardsMatch(transition, normalizedEvent));
         if (guarded.length === 0)
             return this.#refusal("guard_failed");
         if (this.#timeline.length >= this.machine.max_transitions)
@@ -270,6 +251,27 @@ export class ReplayMachineRuntime {
             transition: record,
         };
     }
+    #matchingTransitions(event) {
+        return (this.#transitionsByTrigger.get(`${event.protocol}\0${event.path}`) ?? []).filter(({ transition }) => triggerMatches(transition, event));
+    }
+    #transitionStartsHere(transition) {
+        return transition.from === this.#state;
+    }
+    #noEligibleReason(matching, event) {
+        if (matching.length === 0)
+            return "unmatched";
+        return event.protocol === "websocket_connect" &&
+            event.connection === "reconnect"
+            ? "unexpected_reconnect"
+            : "invalid_state";
+    }
+    #transitionGuardsMatch(transition, event) {
+        return transition.guards.every((guard) => {
+            if (!this.#variables.has(guard.variable))
+                return false;
+            return replayValuesEqual(this.#variables.get(guard.variable), readValue(guard.value, event, transition));
+        });
+    }
     #admitEvent(event) {
         const connections = this.#connections + (event.protocol === "websocket_connect" ? 1 : 0);
         const messages = this.#messages + (event.protocol === "websocket_message" ? 1 : 0);

package/dist/domain/replayMachineValues.js

@@ -0,0 +1,84 @@
+/** Compare JSON-compatible replay values without recursive stack growth. */
+export const replayValuesEqual = (left, right) => {
+    const pending = [[left, right]];
+    while (pending.length > 0) {
+        const pair = pending.pop();
+        if (pair === undefined)
+            continue;
+        const [currentLeft, currentRight] = pair;
+        const primitive = equalPrimitiveReplayValues(currentLeft, currentRight);
+        if (primitive !== undefined) {
+            if (!primitive)
+                return false;
+            continue;
+        }
+        const array = compareReplayArrays(currentLeft, currentRight, pending);
+        if (array !== undefined) {
+            if (!array)
+                return false;
+            continue;
+        }
+        if (!compareReplayRecords(currentLeft, currentRight, pending))
+            return false;
+    }
+    return true;
+};
+/** Check that captured values can be serialized as JSON without recursion. */
+export const isJsonCompatible = (value) => {
+    const pending = [value];
+    while (pending.length > 0) {
+        const candidate = pending.pop();
+        if (candidate === null ||
+            typeof candidate === "string" ||
+            typeof candidate === "boolean")
+            continue;
+        if (typeof candidate === "number") {
+            if (!Number.isFinite(candidate))
+                return false;
+            continue;
+        }
+        if (Array.isArray(candidate)) {
+            for (const item of candidate)
+                pending.push(item);
+            continue;
+        }
+        if (typeof candidate !== "object")
+            return false;
+        for (const item of Object.values(candidate))
+            pending.push(item);
+    }
+    return true;
+};
+const equalPrimitiveReplayValues = (left, right) => {
+    if (left === null || typeof left === "string" || typeof left === "boolean")
+        return left === right;
+    if (typeof left !== "number")
+        return undefined;
+    return (Number.isFinite(left) &&
+        left === right &&
+        typeof right === "number" &&
+        Number.isFinite(right));
+};
+const compareReplayArrays = (left, right, pending) => {
+    if (!Array.isArray(left))
+        return undefined;
+    if (!Array.isArray(right) || left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index += 1)
+        pending.push([left[index], right[index]]);
+    return true;
+};
+const compareReplayRecords = (left, right, pending) => {
+    if (typeof left !== "object" || left === null)
+        return undefined;
+    if (typeof right !== "object" || right === null || Array.isArray(right))
+        return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (leftKeys.length !== rightKeys.length ||
+        leftKeys.some((key, index) => key !== rightKeys[index]))
+        return false;
+    for (const key of leftKeys)
+        pending.push([Reflect.get(left, key), Reflect.get(right, key)]);
+    return true;
+};

package/dist/domain/residualUnknown.js

@@ -3,18 +3,18 @@ import canonicalize from "canonicalize";
 import { z } from "zod";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const unknownIdSchema = z.string().regex(/^unk_[a-f0-9]{64}$/u);
-const boundedText = z.string().trim().min(1).max(1_000);
+const text = z.string().trim().min(1);
 const environmentRequirementSchema = z.object({
-    id: z.string().min(1).max(200).nullable(),
-    platform: z.string().min(1).max(100).nullable(),
-    architecture: z.string().min(1).max(100).nullable(),
+    id: z.string().min(1).nullable(),
+    platform: z.string().min(1).nullable(),
+    architecture: z.string().min(1).nullable(),
     isolation: z
         .enum(["none", "process", "container", "virtual-machine"])
         .nullable(),
 });
 const probeSchema = z.object({
-    operation: z.string().min(1).max(200),
-    rationale: boundedText,
+    operation: z.string().min(1),
+    rationale: text,
 });
 const relationshipSchema = z.object({
     type: z.enum(["depends-on", "related-to", "contradicts"]),
@@ -23,18 +23,17 @@ const relationshipSchema = z.object({
 const resolutionSchema = z.discriminatedUnion("disposition", [
     z.object({
         disposition: z.literal("verified"),
-        rationale: boundedText,
-        evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+        rationale: text,
+        evidence_ids: z.array(evidenceIdSchema).min(1),
     }),
     z.object({
         disposition: z.enum(["withdrawn", "out-of-scope"]),
-        rationale: boundedText,
-        evidence_ids: z.array(evidenceIdSchema).max(100),
+        rationale: text,
+        evidence_ids: z.array(evidenceIdSchema),
     }),
 ]);
 /** Strict durable record for one unresolved or evidence-qualified question. */
 const residualUnknownObjectSchema = z.object({
-    registry_version: z.literal(1),
     unknown_id: unknownIdSchema,
     revision: z.number().int().min(1),
     previous_revision_digest: z
@@ -46,7 +45,7 @@ const residualUnknownObjectSchema = z.object({
         .string()
         .regex(/^[a-f0-9]{64}$/u)
         .nullable(),
-    question: boundedText,
+    question: text,
     status: z.enum([
         "open",
         "investigating",
@@ -55,9 +54,9 @@ const residualUnknownObjectSchema = z.object({
         "resolved",
     ]),
     severity: z.enum(["low", "medium", "high", "critical"]),
-    domain: z.string().trim().min(1).max(100),
-    supporting_evidence_ids: z.array(evidenceIdSchema).max(100),
-    contradicting_evidence_ids: z.array(evidenceIdSchema).max(100),
+    domain: text,
+    supporting_evidence_ids: z.array(evidenceIdSchema),
+    contradicting_evidence_ids: z.array(evidenceIdSchema),
     required_authority: z
         .enum([
         "shipped-artifact",
@@ -69,10 +68,10 @@ const residualUnknownObjectSchema = z.object({
         .nullable(),
     required_confidence: z.enum(["observed", "derived", "inferred"]),
     required_environment: environmentRequirementSchema.nullable(),
-    recommended_probes: z.array(probeSchema).max(20),
-    relationships: z.array(relationshipSchema).max(100),
+    recommended_probes: z.array(probeSchema),
+    relationships: z.array(relationshipSchema),
     resolution: resolutionSchema.nullable(),
-    mutation_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    mutation_evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 export const residualUnknownSchema = residualUnknownObjectSchema.superRefine((value, context) => {
     if (computeRevisionDigest(value) !== value.revision_digest)
@@ -116,7 +115,8 @@ export const residualUnknownSchema = residualUnknownObjectSchema.superRefine((va
                 code: "custom",
                 message: "Evidence IDs must be unique",
             });
-    if (value.supporting_evidence_ids.some((id) => value.contradicting_evidence_ids.includes(id)))
+    const contradictingEvidence = new Set(value.contradicting_evidence_ids);
+    if (value.supporting_evidence_ids.some((id) => contradictingEvidence.has(id)))
         context.addIssue({
             code: "custom",
             message: "Evidence cannot simultaneously support and contradict",
@@ -132,7 +132,6 @@ export const residualUnknownSchema = residualUnknownObjectSchema.superRefine((va
 /** Input for deterministic creation of one residual unknown. */
 export const recordUnknownInputSchema = residualUnknownObjectSchema
     .omit({
-    registry_version: true,
     unknown_id: true,
     revision: true,
     previous_revision_digest: true,
@@ -145,24 +144,22 @@ export const recordUnknownInputSchema = residualUnknownObjectSchema
     mutation_evidence_ids: true,
 })
     .extend({
-    supporting_evidence_ids: z.array(evidenceIdSchema).max(100).default([]),
-    contradicting_evidence_ids: z.array(evidenceIdSchema).max(100).default([]),
-    approved: z.literal(true),
+    supporting_evidence_ids: z.array(evidenceIdSchema).default([]),
+    contradicting_evidence_ids: z.array(evidenceIdSchema).default([]),
 });
 /** Explicit optimistic-concurrency update command for one unknown. */
 export const updateUnknownInputSchema = z.object({
     unknown_id: unknownIdSchema,
     expected_revision: z.number().int().min(1),
-    approved: z.literal(true),
     status: residualUnknownObjectSchema.shape.status,
     severity: residualUnknownObjectSchema.shape.severity,
-    supporting_evidence_ids: z.array(evidenceIdSchema).max(100),
-    contradicting_evidence_ids: z.array(evidenceIdSchema).max(100),
+    supporting_evidence_ids: z.array(evidenceIdSchema),
+    contradicting_evidence_ids: z.array(evidenceIdSchema),
     required_authority: residualUnknownObjectSchema.shape.required_authority,
     required_confidence: residualUnknownObjectSchema.shape.required_confidence,
     required_environment: environmentRequirementSchema.nullable(),
-    recommended_probes: z.array(probeSchema).max(20),
-    relationships: z.array(relationshipSchema).max(100),
+    recommended_probes: z.array(probeSchema),
+    relationships: z.array(relationshipSchema),
     resolution: resolutionSchema.nullable(),
 });
 /** Create stable identity from immutable question and domain fields. */
@@ -174,7 +171,6 @@ export const createResidualUnknown = (input, mutationEvidenceId, scopeDigest) =>
         scope_digest: scopeDigest,
     });
     const revision = {
-        registry_version: 1,
         unknown_id: `unk_${createHash("sha256").update(identity).digest("hex")}`,
         revision: 1,
         previous_revision_digest: null,
@@ -194,7 +190,6 @@ export const createResidualUnknown = (input, mutationEvidenceId, scopeDigest) =>
 /** Apply a complete, revision-guarded replacement while preserving identity. */
 export const updateResidualUnknown = (current, input, mutationEvidenceId) => {
     const revision = {
-        registry_version: 1,
         unknown_id: current.unknown_id,
         revision: current.revision + 1,
         previous_revision_digest: current.revision_digest,

package/dist/domain/runtimeCharacterization.js

@@ -2,24 +2,24 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
+const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
 const runtimeIdentitySchema = z.strictObject({
-    family: z.string().trim().min(1).max(100),
+    family: z.string().trim().min(1),
     provider_id: stableIdSchema,
-    executable_path: z.string().min(1).max(4_096),
+    executable_path: z.string().min(1),
     executable_sha256: digestSchema,
-    version: z.string().trim().min(1).max(500),
+    version: z.string().trim().min(1),
     profile_sha256: digestSchema,
 });
 const artifactIdentitySchema = z.strictObject({
-    path: z.string().min(1).max(4_096),
+    path: z.string().min(1),
     sha256: digestSchema,
     byte_length: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
 });
 const callableIdentitySchema = z.strictObject({
     callable_id: stableIdSchema,
     module_id: stableIdSchema,
-    export_name: z.string().min(1).max(1_000),
+    export_name: z.string().min(1),
     semantic_evidence_id: z
         .string()
         .regex(/^ev_[a-f0-9]{64}$/u)
@@ -27,24 +27,23 @@ const callableIdentitySchema = z.strictObject({
     selector_sha256: digestSchema,
 });
 export const runtimeCharacterizationPlanSchema = z.strictObject({
-    schema_version: z.literal(1),
     plan_sha256: digestSchema,
     preparation_sha256: digestSchema,
     artifact: artifactIdentitySchema,
     runtime: runtimeIdentitySchema,
     callable: callableIdentitySchema,
-    working_directory: z.string().min(1).max(4_096),
-    isolated_home: z.string().min(1).max(4_096),
+    working_directory: z.string().min(1),
+    isolated_home: z.string().min(1),
     expected_effect: z.enum(["pure", "bounded-effects", "observation-only"]),
-    allowed_boundaries: z.array(stableIdSchema).max(1_000),
+    allowed_boundaries: z.array(stableIdSchema),
     limits: z.strictObject({
-        max_calls: z.number().int().min(1).max(10_000),
-        max_processes: z.number().int().min(0).max(1_000),
-        max_files: z.number().int().min(0).max(100_000),
+        max_calls: z.number().int().min(1),
+        max_processes: z.number().int().min(0),
+        max_files: z.number().int().min(0),
         max_bytes: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-        max_handles: z.number().int().min(0).max(100_000),
-        timeout_ms: z.number().int().min(1).max(300_000),
-        idle_timeout_ms: z.number().int().min(1).max(300_000),
+        max_handles: z.number().int().min(0),
+        timeout_ms: z.number().int().min(1),
+        idle_timeout_ms: z.number().int().min(1),
     }),
     determinism: z.strictObject({
         clock: z.enum(["fixed", "real"]),

package/dist/domain/runtimeIdentification.js

@@ -14,45 +14,51 @@ const runtimeFamilySchema = z.enum([
     "webassembly",
 ]);
 const observationSchema = z.strictObject({
-    path: z.string().min(1).max(4_096),
+    path: z.string().min(1),
     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),
 });
+const runtimeObservationShape = {
+    family: runtimeFamilySchema,
+    observations: z.array(observationSchema),
+};
+const identifiedRuntimeSchema = z.discriminatedUnion("inspection", [
+    z.strictObject({
+        ...runtimeObservationShape,
+        inspection: z.literal("available"),
+        provider_id: z.string().min(1),
+        reason: z.null(),
+    }),
+    z.strictObject({
+        ...runtimeObservationShape,
+        inspection: z.literal("provider-missing"),
+        provider_id: z.null(),
+        reason: z.string().min(1),
+    }),
+    z.strictObject({
+        ...runtimeObservationShape,
+        inspection: z.literal("provider-selection-required"),
+        provider_id: z.null(),
+        reason: z.string().min(1),
+    }),
+]);
 /** Authenticated artifact inventory pages to classify by runtime family. */
 const runtimeIdentificationInputSchema = z.strictObject({
-    inventory_evidence: z.array(evidenceSchema).min(1).max(100),
-    limits: z
-        .strictObject({
-        max_observations: z.number().int().min(1).max(10_000).default(1_000),
-    })
-        .default({ max_observations: 1_000 }),
+    inventory_evidence: z.array(evidenceSchema).min(1),
 });
 /** Provider-neutral runtime identification with explicit tooling availability. */
 export const runtimeIdentificationResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     identification_id: z.string().regex(/^rid_[a-f0-9]{64}$/u),
     root_sha256: digestSchema,
-    root_format: z.string().min(1).max(100),
-    source_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    runtimes: z.array(z.strictObject({
-        family: runtimeFamilySchema,
-        inspection: z.enum([
-            "available",
-            "provider-missing",
-            "provider-selection-required",
-        ]),
-        provider_id: z.string().min(1).max(200).nullable(),
-        reason: z.string().min(1).max(1_000).nullable(),
-        observations: z.array(observationSchema),
-        omitted_observations: z.number().int().min(0),
-    })),
+    root_format: z.string().min(1),
+    source_evidence_ids: z.array(evidenceIdSchema).min(1),
+    runtimes: z.array(identifiedRuntimeSchema),
     coverage: z.strictObject({
-        status: z.enum(["complete-within-inventory", "partial", "truncated"]),
+        status: z.enum(["complete-within-inventory", "partial"]),
         inventory_complete: z.boolean(),
-        omitted_observations: z.number().int().min(0),
     }),
-    limitations: z.array(z.string().min(1).max(4_096)).max(100),
+    limitations: z.array(z.string().min(1)),
 });
 const PROVIDERS = {
     android: {
@@ -117,24 +123,15 @@ export const identifyRuntimes = (input) => {
                 sha256: rootObservation.sha256,
                 format: rootObservation.format,
             });
-    let remaining = parsed.limits.max_observations;
-    let omitted = 0;
     const runtimes = [...grouped.entries()]
         .sort(([left], [right]) => compare(left, right))
         .map(([family, values]) => {
         const unique = deduplicate(values);
-        const observations = unique.slice(0, remaining);
-        remaining -= observations.length;
-        const omittedObservations = unique.length - observations.length;
-        omitted += omittedObservations;
         const provider = providerFor(family, inventory.manifest.root_format);
         return {
             family,
-            inspection: provider.inspection,
-            provider_id: provider.id,
-            reason: provider.reason,
-            observations,
-            omitted_observations: omittedObservations,
+            ...runtimeInspection(provider),
+            observations: unique,
         };
     });
     const limitations = [
@@ -143,13 +140,9 @@ export const identifyRuntimes = (input) => {
                 "Source inventory pages are incomplete; absent runtimes remain unknown.",
             ]
             : []),
-        ...(omitted > 0
-            ? [`${String(omitted)} runtime observations were omitted by the limit.`]
-            : []),
         "Runtime families are identified from exact artifact formats and paths; semantic claims require the named provider.",
     ];
     const withoutId = {
-        schema_version: 1,
         root_sha256: inventory.manifest.root_sha256,
         root_format: inventory.manifest.root_format,
         source_evidence_ids: evidence
@@ -157,13 +150,10 @@ export const identifyRuntimes = (input) => {
             .sort(compare),
         runtimes,
         coverage: {
-            status: omitted > 0
-                ? "truncated"
-                : inventory.complete
-                    ? "complete-within-inventory"
-                    : "partial",
+            status: inventory.complete
+                ? "complete-within-inventory"
+                : "partial",
             inventory_complete: inventory.complete,
-            omitted_observations: omitted,
         },
         limitations,
     };
@@ -179,6 +169,17 @@ const providerFor = (family, rootFormat) => family === "android" && rootFormat !
         reason: "Extract or select an APK root before using the Android application provider.",
     }
     : PROVIDERS[family];
+const runtimeInspection = (provider) => provider.inspection === "available"
+    ? {
+        inspection: provider.inspection,
+        provider_id: provider.id,
+        reason: null,
+    }
+    : {
+        inspection: provider.inspection,
+        provider_id: null,
+        reason: provider.reason,
+    };
 const familiesFor = (format, path) => {
     const families = new Set();
     if (format === "apk" ||