rea-agents 3.0.0 → 3.2.0

package/dist/domain/managedNativeVerificationMatch.js

@@ -94,44 +94,57 @@ const candidateNames = (managed) => {
     }
     return [...names];
 };
-const selectCandidates = (managed, symbols, maxCandidates) => {
+const matchPinvoke = (managed, symbols, supportedNativeEvidence) => {
     const names = candidateNames(managed);
     const allCandidates = symbols.filter((symbol) => names.some((name) => sameSymbolName(name, symbol.name)));
-    const candidates = allCandidates.slice(0, maxCandidates);
+    const [first, ...remaining] = allCandidates;
+    if (first === undefined)
+        return {
+            match: {
+                status: "unresolved",
+                basis: supportedNativeEvidence > 0
+                    ? "no-native-candidate"
+                    : "unsupported-native-evidence",
+                confidence: "unknown",
+                matched_native: null,
+                candidates: [],
+            },
+        };
+    const candidates = [first, ...remaining];
     const exact = candidates.find((symbol) => sameSymbolName(managed.import_name, symbol.name) &&
         moduleCompatible(managed.import_scope_name, symbol));
     const decorated = candidates.find((symbol) => moduleCompatible(managed.import_scope_name, symbol));
-    const selected = exact ?? decorated ?? candidates[0] ?? null;
-    return { allCandidates, candidates, selected, exact, decorated };
-};
-const basisAndStatus = (managed, selection, hasSupportedNativeEvidence) => {
-    const { selected, exact } = selection;
-    if (selected === null)
-        return {
-            basis: hasSupportedNativeEvidence
-                ? "no-native-candidate"
-                : "unsupported-native-evidence",
-            status: "unresolved",
-            confidence: "unknown",
-        };
+    const selected = exact ?? decorated ?? first;
     if (!moduleCompatible(managed.import_scope_name, selected))
         return {
-            basis: "module-mismatch",
-            status: "contradicted",
-            confidence: "unknown",
+            match: {
+                status: "contradicted",
+                basis: "module-mismatch",
+                confidence: "unknown",
+                matched_native: selected,
+                candidates,
+            },
         };
     if (exact !== undefined)
         return {
-            basis: selected.source === "macho-export"
-                ? "exact-export-name"
-                : "exact-function-name",
-            status: "verified",
-            confidence: "observed",
+            match: {
+                status: "verified",
+                basis: selected.source === "macho-export"
+                    ? "exact-export-name"
+                    : "exact-function-name",
+                confidence: "observed",
+                matched_native: selected,
+                candidates,
+            },
         };
     return {
-        basis: "decorated-name-candidate",
-        status: "inferred",
-        confidence: "inferred",
+        match: {
+            basis: "decorated-name-candidate",
+            status: "inferred",
+            confidence: "inferred",
+            matched_native: selected,
+            candidates,
+        },
     };
 };
 const pinvokeLimitations = (status, managed) => [
@@ -154,7 +167,7 @@ const pinvokeLimitations = (status, managed) => [
         ]
         : []),
 ];
-export const verifyPinvoke = ({ item, managedEvidenceId, symbols, hasSupportedNativeEvidence, input, }) => {
+export const verifyPinvoke = ({ item, managedEvidenceId, native, }) => {
     const managed = {
         token: item.token,
         member_token: item.member_token,
@@ -166,9 +179,8 @@ export const verifyPinvoke = ({ item, managedEvidenceId, symbols, hasSupportedNa
         call_convention: item.call_convention,
         declaration_verification: item.verification,
     };
-    const selection = selectCandidates(item, symbols, input.limits.max_candidates_per_import);
-    const { status, basis, confidence } = basisAndStatus(item, selection, hasSupportedNativeEvidence);
-    const limitations = pinvokeLimitations(status, item);
+    const selection = matchPinvoke(item, native.symbols, native.accepted);
+    const limitations = pinvokeLimitations(selection.match.status, item);
     return {
         verification: pinvokeVerificationSchema.parse({
             item_id: `mnv_pinvoke_${digest({
@@ -176,21 +188,16 @@ export const verifyPinvoke = ({ item, managedEvidenceId, symbols, hasSupportedNa
                 token: item.token,
                 importName: item.import_name,
                 importScope: item.import_scope_name,
-                candidates: [...selection.candidates],
+                candidates: selection.match.candidates,
             })}`,
             managed,
-            status,
-            basis,
-            confidence,
-            matched_native: selection.selected,
-            candidates: selection.candidates,
+            ...selection.match,
             evidence_links: [
                 managedEvidenceId,
-                ...new Set(selection.candidates.map(({ evidence_id: id }) => id)),
+                ...new Set(selection.match.candidates.map(({ evidence_id: id }) => id)),
             ],
             limitations,
         }),
-        omittedCandidates: Math.max(0, selection.allCandidates.length - selection.candidates.length),
     };
 };
 const countStatuses = (items) => ({
@@ -199,21 +206,17 @@ const countStatuses = (items) => ({
     unresolved: items.filter(({ status }) => status === "unresolved").length,
     contradicted: items.filter(({ status }) => status === "contradicted").length,
 });
-export const buildVerificationResult = ({ managedEvidence, managed, native, pinvokeImports, verifiedPinvokes, input, }) => {
+export const buildVerificationResult = ({ managedEvidence, managed, native, pinvokeImports, input, }) => {
     const counts = countStatuses(pinvokeImports);
-    const omittedNativeObservations = Math.max(0, input.native_observations.length - input.limits.max_native_observations);
-    const omittedCandidates = verifiedPinvokes.reduce((sum, item) => sum + item.omittedCandidates, 0);
-    const nativeBodyUnresolved = managed.native_implementations.items.filter(({ boundary_kind: kind }) => kind !== "pinvoke").length;
-    const coverageStatus = omittedNativeObservations > 0 || omittedCandidates > 0
-        ? "truncated"
-        : managed.coverage.state === "complete" && native.unsupported === 0
+    const nativeBodyUnresolved = managed.native_implementations.filter(({ boundary_kind: kind }) => kind !== "pinvoke").length;
+    const coverage = {
+        status: managed.coverage.state === "complete" && native.unsupported === 0
             ? "complete-within-inputs"
-            : "partial";
+            : "partial",
+    };
     return {
-        schema_version: 1,
         algorithm: {
             name: "rea-managed-native-verification",
-            version: 1,
             token_identity: "build-local",
             token_to_address_mapping: "not-inferred",
         },
@@ -223,8 +226,8 @@ export const buildVerificationResult = ({ managedEvidence, managed, native, pinv
             artifact_path: managed.artifact.path,
             mvid: managed.module?.mvid ?? null,
             metadata_status: managed.metadata.status,
-            pinvoke_imports_total: managed.pinvoke_imports.total,
-            native_implementations_total: managed.native_implementations.total,
+            pinvoke_imports_total: managed.pinvoke_imports.length,
+            native_implementations_total: managed.native_implementations.length,
             coverage_state: managed.coverage.state,
         },
         native_observations: {
@@ -232,7 +235,6 @@ export const buildVerificationResult = ({ managedEvidence, managed, native, pinv
             accepted: native.accepted,
             unsupported: native.unsupported,
             symbols: native.symbols.length,
-            truncated: omittedNativeObservations > 0,
         },
         summary: {
             ...counts,
@@ -243,16 +245,10 @@ export const buildVerificationResult = ({ managedEvidence, managed, native, pinv
             unresolved: nativeBodyUnresolved,
             reason: "Managed metadata tokens and RVAs are not translated to native provider addresses by this workflow; C++/CLI, ReadyToRun, and native-body mappings require explicit provider-supported bridge evidence.",
         },
-        coverage: {
-            status: coverageStatus,
-            omitted_native_observations: omittedNativeObservations,
-            omitted_candidates: omittedCandidates,
-        },
+        coverage,
         evidence_links: [
             managedEvidence.evidence_id,
-            ...input.native_observations
-                .slice(0, input.limits.max_native_observations)
-                .map(({ evidence_id: id }) => id),
+            ...input.native_observations.map(({ evidence_id: id }) => id),
         ],
         limitations: [
             "P/Invoke verification checks declared import names against supplied native export or function-name Evidence only.",

package/dist/domain/managedNativeVerificationSchemas.js

@@ -4,25 +4,7 @@ import { cliMetadataGuidSchema } from "./managedArtifact.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-const matchStatusSchema = z.enum([
-    "verified",
-    "inferred",
-    "unresolved",
-    "contradicted",
-]);
-const matchBasisSchema = z.enum([
-    "exact-export-name",
-    "exact-function-name",
-    "decorated-name-candidate",
-    "module-mismatch",
-    "no-native-candidate",
-    "unsupported-native-evidence",
-]);
-const nativeVerificationLimitsSchema = z.strictObject({
-    max_native_observations: z.number().int().min(1).max(50).default(20),
-    max_candidates_per_import: z.number().int().min(1).max(100).default(25),
-});
+const textSchema = z.string().min(1);
 const nativeSymbolSchema = z.strictObject({
     evidence_id: evidenceIdSchema,
     operation: z.string().min(1),
@@ -32,7 +14,7 @@ const nativeSymbolSchema = z.strictObject({
     module_path: z.string().nullable(),
     source: z.enum(["macho-export", "function-dossier"]),
 });
-export const pinvokeVerificationSchema = z.strictObject({
+const pinvokeVerificationContextShape = {
     item_id: z.string().regex(/^mnv_pinvoke_[a-f0-9]{64}$/u),
     managed: z.strictObject({
         token: tokenSchema,
@@ -53,24 +35,51 @@ export const pinvokeVerificationSchema = z.strictObject({
         ]),
         declaration_verification: z.literal("managed-declaration-only"),
     }),
-    status: matchStatusSchema,
-    basis: matchBasisSchema,
-    confidence: z.enum(["observed", "inferred", "unknown"]),
-    matched_native: nativeSymbolSchema.nullable(),
-    candidates: z.array(nativeSymbolSchema).max(100),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(51),
-    limitations: z.array(boundedTextSchema).max(100),
-});
+    evidence_links: z.array(evidenceIdSchema).min(1),
+    limitations: z.array(textSchema),
+};
+const observedCandidatesSchema = z
+    .tuple([nativeSymbolSchema])
+    .rest(nativeSymbolSchema);
+export const pinvokeVerificationSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        ...pinvokeVerificationContextShape,
+        status: z.literal("verified"),
+        basis: z.enum(["exact-export-name", "exact-function-name"]),
+        confidence: z.literal("observed"),
+        matched_native: nativeSymbolSchema,
+        candidates: observedCandidatesSchema,
+    }),
+    z.strictObject({
+        ...pinvokeVerificationContextShape,
+        status: z.literal("inferred"),
+        basis: z.literal("decorated-name-candidate"),
+        confidence: z.literal("inferred"),
+        matched_native: nativeSymbolSchema,
+        candidates: observedCandidatesSchema,
+    }),
+    z.strictObject({
+        ...pinvokeVerificationContextShape,
+        status: z.literal("unresolved"),
+        basis: z.enum(["no-native-candidate", "unsupported-native-evidence"]),
+        confidence: z.literal("unknown"),
+        matched_native: z.null(),
+        candidates: z.tuple([]),
+    }),
+    z.strictObject({
+        ...pinvokeVerificationContextShape,
+        status: z.literal("contradicted"),
+        basis: z.literal("module-mismatch"),
+        confidence: z.literal("unknown"),
+        matched_native: nativeSymbolSchema,
+        candidates: observedCandidatesSchema,
+    }),
+]);
 /** Authenticated managed boundary Evidence plus native observations. */
 export const managedNativeVerificationInputSchema = z
     .strictObject({
     managed_boundaries: evidenceSchema,
-    native_observations: z.array(evidenceSchema).min(1).max(50),
-    limits: nativeVerificationLimitsSchema.default({
-        max_native_observations: 20,
-        max_candidates_per_import: 25,
-    }),
-    unknown_registry_approved: z.literal(true).optional(),
+    native_observations: z.array(evidenceSchema).min(1),
 })
     .superRefine((input, context) => {
     const ids = new Set();
@@ -92,13 +101,15 @@ export const managedNativeVerificationInputSchema = z
         ids.add(evidence.evidence_id);
     }
 });
+const verificationCoverageSchema = z.strictObject({
+    status: z.enum(["complete-within-inputs", "partial"]),
+});
 /** Provider-neutral managed/native verification result. */
-export const managedNativeVerificationResultSchema = z.strictObject({
-    schema_version: z.literal(1),
+export const managedNativeVerificationResultSchema = z
+    .strictObject({
     verification_id: z.string().regex(/^mnv_[a-f0-9]{64}$/u),
     algorithm: z.strictObject({
         name: z.literal("rea-managed-native-verification"),
-        version: z.literal(1),
         token_identity: z.literal("build-local"),
         token_to_address_mapping: z.literal("not-inferred"),
     }),
@@ -117,7 +128,6 @@ export const managedNativeVerificationResultSchema = z.strictObject({
         accepted: z.number().int().min(0),
         unsupported: z.number().int().min(0),
         symbols: z.number().int().min(0),
-        truncated: z.boolean(),
     }),
     summary: z.strictObject({
         verified: z.number().int().min(0),
@@ -126,16 +136,42 @@ export const managedNativeVerificationResultSchema = z.strictObject({
         contradicted: z.number().int().min(0),
         native_body_unresolved: z.number().int().min(0),
     }),
-    pinvoke_imports: z.array(pinvokeVerificationSchema).max(50_000),
+    pinvoke_imports: z.array(pinvokeVerificationSchema),
     native_implementations: z.strictObject({
         unresolved: z.number().int().min(0),
-        reason: boundedTextSchema,
-    }),
-    coverage: z.strictObject({
-        status: z.enum(["complete-within-inputs", "partial", "truncated"]),
-        omitted_native_observations: z.number().int().min(0),
-        omitted_candidates: z.number().int().min(0),
+        reason: textSchema,
     }),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(51),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    coverage: verificationCoverageSchema,
+    evidence_links: z.array(evidenceIdSchema).min(2),
+    limitations: z.array(textSchema),
+})
+    .superRefine((result, context) => {
+    const observedNativeCount = result.native_observations.accepted +
+        result.native_observations.unsupported;
+    if (observedNativeCount !== result.native_observations.total)
+        context.addIssue({
+            code: "custom",
+            path: ["native_observations"],
+            message: "Native observation counts must account for the total input",
+        });
+    for (const status of [
+        "verified",
+        "inferred",
+        "unresolved",
+        "contradicted",
+    ])
+        if (result.summary[status] !==
+            result.pinvoke_imports.filter((item) => item.status === status).length)
+            context.addIssue({
+                code: "custom",
+                path: ["summary", status],
+                message: `P/Invoke ${status} count must match the item results`,
+            });
+    if (result.summary.native_body_unresolved !==
+        result.native_implementations.unresolved)
+        context.addIssue({
+            code: "custom",
+            path: ["summary", "native_body_unresolved"],
+            message: "Native body summary must match unresolved implementations",
+        });
 });

package/dist/domain/managedReconstruction.js

@@ -6,14 +6,13 @@ import { cliMetadataGuidSchema, managedMemberInspectionSchema, } from "./managed
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
-const boundedTextSchema = z.string().min(1).max(65_536);
-const boundedLabelSchema = z.string().min(1).max(512);
+const textSchema = z.string().min(1);
 const decompilerSchema = z.strictObject({
-    name: boundedLabelSchema,
-    version: z.string().min(1).max(128).nullable(),
+    name: textSchema,
+    version: textSchema.nullable(),
     family: z.enum(["ilspy", "dnspy", "dnlib", "mono-cecil", "other"]),
     executable_sha256: digestSchema.nullable(),
-    options: z.array(z.string().max(512)).max(50).default([]),
+    options: z.array(z.string()).default([]),
 });
 const managedReconstructionMethodInputSchema = z.strictObject({
     token: tokenSchema,
@@ -22,9 +21,9 @@ const managedReconstructionMethodInputSchema = z.strictObject({
     reconstruction: z.strictObject({
         kind: z.enum(["decompiled-csharp", "decompiled-il", "semantic-pseudocode"]),
         language: z.enum(["csharp", "il", "pseudocode"]),
-        text: boundedTextSchema,
+        text: textSchema,
         text_sha256: digestSchema.optional(),
-        source_path: z.string().min(1).max(4_096).nullable().optional(),
+        source_path: textSchema.nullable().optional(),
         start_line: z.number().int().min(1).nullable().optional(),
         end_line: z.number().int().min(1).nullable().optional(),
     }),
@@ -32,9 +31,8 @@ const managedReconstructionMethodInputSchema = z.strictObject({
 export const managedReconstructionImportInputSchema = z.strictObject({
     static_members: evidenceSchema,
     decompiler: decompilerSchema,
-    methods: z.array(managedReconstructionMethodInputSchema).min(1).max(50),
-    notes: z.array(z.string().min(1).max(4_096)).max(100).default([]),
-    unknown_registry_approved: z.literal(true).optional(),
+    methods: z.array(managedReconstructionMethodInputSchema).min(1),
+    notes: z.array(textSchema).default([]),
 });
 const importedMethodSchema = z.strictObject({
     token: tokenSchema,
@@ -47,11 +45,11 @@ const importedMethodSchema = z.strictObject({
     reconstruction: z.strictObject({
         kind: z.enum(["decompiled-csharp", "decompiled-il", "semantic-pseudocode"]),
         language: z.enum(["csharp", "il", "pseudocode"]),
-        text: boundedTextSchema,
+        text: textSchema,
         text_sha256: digestSchema,
-        text_length: z.number().int().min(1).max(65_536),
+        text_length: z.number().int().min(1),
         line_count: z.number().int().min(1),
-        source_path: z.string().min(1).max(4_096).nullable(),
+        source_path: textSchema.nullable(),
         start_line: z.number().int().min(1).nullable(),
         end_line: z.number().int().min(1).nullable(),
     }),
@@ -63,7 +61,6 @@ const importedMethodSchema = z.strictObject({
     }),
 });
 export const managedReconstructionImportResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     reconstruction_id: z.string().regex(/^mre_[a-f0-9]{64}$/u),
     phase: z.literal("reconstruction-import"),
     executed: z.literal(false),
@@ -80,16 +77,16 @@ export const managedReconstructionImportResultSchema = z.strictObject({
         options_sha256: digestSchema,
     }),
     summary: z.strictObject({
-        imported_methods: z.number().int().min(1).max(50),
-        decompiled_csharp_methods: z.number().int().min(0).max(50),
-        decompiled_il_methods: z.number().int().min(0).max(50),
-        pseudocode_methods: z.number().int().min(0).max(50),
+        imported_methods: z.number().int().min(1),
+        decompiled_csharp_methods: z.number().int().min(0),
+        decompiled_il_methods: z.number().int().min(0),
+        pseudocode_methods: z.number().int().min(0),
         total_text_bytes: z.number().int().min(1),
     }),
-    methods: z.array(importedMethodSchema).min(1).max(50),
-    notes: z.array(z.string().min(1).max(4_096)).max(100),
+    methods: z.array(importedMethodSchema).min(1),
+    notes: z.array(textSchema),
     evidence_links: z.array(evidenceIdSchema).length(1),
-    limitations: z.array(z.string().min(1).max(4_096)).max(1_000),
+    limitations: z.array(textSchema),
 });
 const sha256Text = (value) => createHash("sha256").update(value).digest("hex");
 const sha256Json = (value) => {
@@ -99,7 +96,7 @@ const sha256Json = (value) => {
     return createHash("sha256").update(serialized).digest("hex");
 };
 const countLines = (text) => text.length === 0 ? 0 : text.split(/\r\n|\r|\n/u).length;
-const findObservedMethod = (members, candidate) => members.methods.items.find((item) => item.token === candidate.token &&
+const findObservedMethod = (members, candidate) => members.methods.find((item) => item.token === candidate.token &&
     item.signature.raw_sha256 === candidate.signature_sha256 &&
     item.body.status === "present" &&
     item.body.normalized_il_sha256 !== null &&
@@ -163,7 +160,6 @@ const RECONSTRUCTION_LIMITATIONS = [
     "Obfuscated names, decompiler variables, and control-flow restructuring are not treated as proof without separate validation.",
 ];
 const buildReconstructionWithoutId = (input, staticEvidence, members, methods) => ({
-    schema_version: 1,
     phase: "reconstruction-import",
     executed: false,
     static_observation: buildStaticObservation(staticEvidence, members),

package/dist/domain/managedRuntimeCorrelation.js

@@ -6,7 +6,7 @@ import { cliMetadataGuidSchema, managedMemberInspectionSchema, } from "./managed
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
+const boundedTextSchema = z.string().min(1);
 const managedRuntimeEffectSchema = z.enum([
     "attach",
     "load",
@@ -20,9 +20,9 @@ const managedRuntimeHostSchema = z.strictObject({
     architecture: z.enum(["x86", "x86_64", "arm", "arm64"]),
 });
 const managedRuntimeBoundsSchema = z.strictObject({
-    timeout_ms: z.number().int().min(1).max(60_000).default(5_000),
-    max_threads: z.number().int().min(1).max(256).default(32),
-    max_output_bytes: z.number().int().min(0).max(1_048_576).default(65_536),
+    timeout_ms: z.number().int().min(1).default(5_000),
+    max_threads: z.number().int().min(1).default(32),
+    max_output_bytes: z.number().int().min(0).default(65_536),
     allow_network: z.literal(false).default(false),
     allow_ui: z.literal(false).default(false),
 });
@@ -42,10 +42,8 @@ export const managedRuntimeCorrelationInputSchema = z.strictObject({
         allow_network: false,
         allow_ui: false,
     }),
-    unknown_registry_approved: z.literal(true).optional(),
 });
 export const managedRuntimeCorrelationResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     correlation_id: z.string().regex(/^mrc_[a-f0-9]{64}$/u),
     phase: z.literal("admission-plan"),
     executed: z.literal(false),
@@ -99,7 +97,7 @@ export const managedRuntimeCorrelationResultSchema = z.strictObject({
     bounds: managedRuntimeBoundsSchema,
     unsupported_until_executor_exists: z.literal(true),
     evidence_links: z.array(evidenceIdSchema).length(1),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    limitations: z.array(boundedTextSchema),
 });
 const sha256 = (value) => {
     const serialized = canonicalize(value);
@@ -113,7 +111,7 @@ export const planManagedRuntimeCorrelation = (input, executablePath, permissionG
     if (staticEvidence.operation !== "inspect_managed_members")
         throw new TypeError("Evidence operation is not inspect_managed_members");
     const members = managedMemberInspectionSchema.parse(staticEvidence.normalized_result);
-    const method = members.methods.items.find((item) => item.token === input.method.token &&
+    const method = members.methods.find((item) => item.token === input.method.token &&
         item.signature.raw_sha256 === input.method.signature_sha256 &&
         item.body.status === "present" &&
         item.body.normalized_il_sha256 !== null &&
@@ -122,7 +120,6 @@ export const planManagedRuntimeCorrelation = (input, executablePath, permissionG
     if (method === undefined)
         throw new TypeError("Requested method lock does not match a static managed member observation");
     const withoutId = {
-        schema_version: 1,
         phase: "admission-plan",
         executed: false,
         authority_model: {

package/dist/domain/nativeApiBoundary.js

@@ -13,9 +13,7 @@ const inferenceEvidenceSchema = z
     detail: z.string().min(1),
 })
     .strict();
-const inferredBoundaryTypeSchema = z
-    .object({
-    role: z.enum(["return", "parameter"]),
+const inferredBoundaryTypeFacts = {
     ordinal: z.number().int().min(0).nullable(),
     name: z.string().min(1).nullable(),
     data_type: z.string().min(1),
@@ -28,14 +26,25 @@ const inferredBoundaryTypeSchema = z
         "register-or-stack-storage",
         "compiler-generated-variable",
     ])),
-})
-    .strict();
+};
+const inferredReturnTypeSchema = z.strictObject({
+    ...inferredBoundaryTypeFacts,
+    role: z.literal("return"),
+    ordinal: z.null(),
+    name: z.null(),
+});
+const inferredParameterTypeSchema = z.strictObject({
+    ...inferredBoundaryTypeFacts,
+    role: z.literal("parameter"),
+    ordinal: z.number().int().min(0),
+});
 const jumpTableDataSourceSchema = z
     .object({
     address: z.string().min(1),
     provenance: z.enum([
         "ghidra-decompiler-load-table",
         "ghidra-dispatch-block-data-reference",
+        "ghidra-aarch64-byte-table",
     ]),
     entry_size_bytes: z.number().int().min(1).nullable(),
     entry_count: z.number().int().min(0).nullable(),
@@ -47,7 +56,6 @@ const jumpTableMappingSchema = z
     .object({
     case_value: z.number().int().nullable(),
     target_address: z.string().min(1),
-    data_addresses: z.array(z.string().min(1)),
     confidence: inferenceConfidenceSchema,
     evidence: z.array(inferenceEvidenceSchema).min(1),
 })
@@ -56,9 +64,7 @@ const inferredJumpTableSchema = z
     .object({
     dispatch_address: z.string().min(1),
     data_sources: z.array(jumpTableDataSourceSchema),
-    data_sources_truncated: z.boolean(),
     mappings: z.array(jumpTableMappingSchema),
-    mappings_truncated: z.boolean(),
     limitations: z.array(z.string()),
 })
     .strict();
@@ -68,11 +74,9 @@ const availableNativeApiBoundarySchema = z
     provenance: z.string().min(1),
     signature_source: z.string().min(1),
     calling_convention: z.string().min(1),
-    return_type: inferredBoundaryTypeSchema,
-    parameters: z.array(inferredBoundaryTypeSchema),
-    parameters_truncated: z.boolean(),
+    return_type: inferredReturnTypeSchema,
+    parameters: z.array(inferredParameterTypeSchema),
     jump_tables: z.array(inferredJumpTableSchema),
-    jump_tables_truncated: z.boolean(),
     pseudocode: z
         .object({
         classification: z.literal("decompiler-generated-non-source"),
@@ -115,7 +119,6 @@ const nativeApiInspectionSubstepSchema = z
 /** Agent-facing projection of structured native API reconstruction substeps. */
 export const nativeApiInspectionResultSchema = z
     .object({
-    schema_version: z.literal(1),
     procedure: z
         .object({
         address: z.string().min(1),
@@ -123,7 +126,7 @@ export const nativeApiInspectionResultSchema = z
     })
         .strict(),
     boundary: nativeApiBoundarySchema,
-    substeps: z.array(nativeApiInspectionSubstepSchema).min(3).max(3),
+    substeps: z.array(nativeApiInspectionSubstepSchema).length(3),
     unsupported_branches: z.array(z.string().min(1)),
     residual_unknowns: z.array(z.string().min(1)),
 })

package/dist/domain/nativeInspection.js

@@ -19,8 +19,6 @@ const nativeCommandInvocationSchema = z.object({
     }),
     stdout_bytes: z.number().int().min(0),
     stderr_bytes: z.number().int().min(0),
-    stdout_truncated: z.boolean(),
-    stderr_truncated: z.boolean(),
 });
 const architectureSchema = z.object({
     name: z.string(),