rea-agents 6.5.0 → 6.7.0

package/dist/mcpDoctor.js

@@ -6,6 +6,7 @@ import { resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { createCatalogIdentity } from "./catalogIdentity.js";
 import { compactPresentationForMcpInputSchemaProfile, parseMcpInputSchemaProfile, } from "./config/mcpInputSchemaProfile.js";
+import { parseMcpOutputSchemaProfile } from "./config/mcpOutputSchemaProfile.js";
 import { PROMPT_CONTRACTS } from "./contracts/promptContracts.js";
 import { TOOL_CONTRACTS } from "./contracts/toolContracts.js";
 import { err, ok } from "./domain/result.js";
@@ -347,8 +348,9 @@ const targetFreeEnvironment = (environment) => {
     return result;
 };
 const catalogIdentityForEnvironment = (environment) => {
-    const parsed = parseMcpInputSchemaProfile(environment.REA_MCP_INPUT_SCHEMA_PROFILE);
-    return createCatalogIdentity(compactPresentationForMcpInputSchemaProfile(parsed.ok ? parsed.value : undefined));
+    const inputProfile = parseMcpInputSchemaProfile(environment.REA_MCP_INPUT_SCHEMA_PROFILE);
+    const outputProfile = parseMcpOutputSchemaProfile(environment.REA_MCP_OUTPUT_SCHEMA_PROFILE);
+    return createCatalogIdentity(compactPresentationForMcpInputSchemaProfile(inputProfile.ok ? inputProfile.value : undefined), outputProfile.ok ? (outputProfile.value ?? "full") : "full");
 };
 const captureStderr = () => {
     const retained = Buffer.allocUnsafe(MCP_STARTUP_POLICY.doctorStderrBytes);

package/dist/mcpStartupPolicy.js

@@ -1,17 +1,32 @@
 /**
- * Supported MCP startup deadlines and regression budgets.
+ * Supported MCP startup deadlines and operation headroom.
  *
- * The Codex timeout is caller-facing configuration. The smaller phase budgets
+ * Client timeouts are caller-facing configuration. The smaller phase budgets
  * preserve operational headroom, while the doctor deadline covers additional
  * inventory requests after initialization.
  */
 export const MCP_STARTUP_POLICY = {
     codexStartupTimeoutSeconds: 30,
     kimiStartupTimeoutMs: 30_000,
-    kimiToolTimeoutMs: 120_000,
+    toolOperationHeadroomMs: 120_000,
     initializeBudgetMs: 15_000,
     toolsListBudgetMs: 5_000,
     firstCatalogBudgetMs: 20_000,
     doctorDeadlineMs: 30_000,
     doctorStderrBytes: 64 * 1024,
 };
+/** Allow for known startup phases and caller-selected upstream request budgets. */
+export const mcpProviderDeadlineAllowanceMs = (inputs) => {
+    const selectedProvider = inputs.analysisProvider;
+    const selectedTimeout = selectedProvider === "ghidra"
+        ? inputs.ghidraStartupTimeoutMs
+        : selectedProvider === "hopper"
+            ? inputs.hopperStartupTimeoutMs
+            : Math.max(inputs.ghidraStartupTimeoutMs, inputs.hopperStartupTimeoutMs);
+    return Math.max(selectedTimeout, inputs.jebMcpTimeoutMs ?? 0, inputs.providerRequestTimeoutMs ?? 0);
+};
+/** Add operation headroom to the parsed provider deadline allowance. */
+export const recommendedMcpToolTimeoutMs = (inputs) => mcpProviderDeadlineAllowanceMs(inputs) +
+    MCP_STARTUP_POLICY.toolOperationHeadroomMs;
+/** Round up so Codex's whole-second deadline still covers the millisecond budget. */
+export const recommendedMcpToolTimeoutSeconds = (inputs) => Math.ceil(recommendedMcpToolTimeoutMs(inputs) / 1000);

package/dist/native/AppleDispatchMetadata.js

@@ -1,8 +1,14 @@
 import { createHash } from "node:crypto";
 import { objcSwiftMetadataSchema, nativeDispatchMetadataResultSchema, } from "../domain/native/objcSwiftMetadata.js";
 import { isMachOFormat, } from "../domain/binaryTargetTypes.js";
-import { AnalysisCancelledError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
-import { openRegularFile } from "../filesystem/RegularFile.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
+import { ArtifactFileCleanupFailure, artifactFileCancellationCause, artifactFilePrimaryFailure, bindArtifactFileCleanup, withArtifactRegularFile, } from "../artifacts/ArtifactFileOperation.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { NATIVE_MACOS_PROVIDER_IDENTITY as IDENTITY } from "./NativeMacOSProviderMetadata.js";
 import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { pushDispatchCoverage } from "./AppleDispatchCoverage.js";
@@ -48,7 +54,8 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
         if (end === bytes.length || end - start >= 4096)
             throw new RangeError("Unterminated or oversized metadata string");
         offset(address, end - start + 1);
-        return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, end));
+        // A metadata C string owns every code point, including an initial U+FEFF.
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(start, end));
     };
     const result = objcSwiftMetadataSchema.parse({ db_save_result: null });
     let records = 0;
@@ -140,40 +147,82 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
     });
     return objcSwiftMetadataSchema.parse(result);
 };
-/** Read digest-verified target bytes under a 64 MiB static metadata budget. */
-export const inspectAppleDispatchMetadata = async (target, maxRecords, signal) => {
+/**
+ * Read digest-verified target bytes under a 64 MiB static metadata budget.
+ * The caller's scope retains the target descriptor when its final close fails.
+ */
+export const inspectAppleDispatchMetadata = async (target, maxRecords, resources, signal) => {
     if (target.kind !== "executable" || !isMachOFormat(target.format))
         throw new TypeError("Apple dispatch metadata requires a Mach-O target");
     const maximumBytes = 64 * 1024 * 1024;
     const capacityError = () => new AnalysisResourceConstraintError("inspect_native_dispatch_metadata", "memory", "Apple static metadata input exceeds its 64 MiB snapshot budget", { input_bytes: maximumBytes });
-    const handle = await openRegularFile(target.path, {
-        symlinks: "reject",
-        signal,
+    const cancelled = () => new AnalysisCancelledError("inspect_native_dispatch_metadata", {
+        cause: signal?.reason,
     });
-    try {
+    const { bytes, digest } = await withArtifactRegularFile(target.path, resources, signal, async (handle) => {
         const before = await handle.stat();
         if (before.size > maximumBytes)
             throw capacityError();
         if (signal?.aborted)
-            throw new AnalysisCancelledError("inspect_native_dispatch_metadata");
-        const bytes = await readBoundedFileBytes(handle, maximumBytes, signal);
-        if (bytes === undefined)
+            throw cancelled();
+        const read = await readBoundedFileBytes(handle, maximumBytes, signal).catch((cause) => {
+            // The bounded reader rejects with the caller's exact abort reason.
+            if (signal?.aborted === true && cause === signal.reason)
+                throw cancelled();
+            throw cause;
+        });
+        if (read === undefined)
             throw capacityError();
-        const digest = createHash("sha256").update(bytes).digest("hex");
-        if (digest !== target.sha256)
+        const sha256 = createHash("sha256").update(read).digest("hex");
+        if (sha256 !== target.sha256)
             throw new EvidenceIntegrityError("Apple metadata target digest changed after session binding");
-        return nativeDispatchMetadataResultSchema.parse({
-            target_sha256: target.sha256,
-            provider: {
-                id: "native-macos",
-                name: "macOS native inspection utilities",
-                version: "apple-metadata-reader-1",
-            },
-            analysis_profile_digest: null,
-            result: decodeAppleDispatchMetadata(bytes, maxRecords, { path: target.path, sha256: digest }, target.architecture),
-        });
-    }
-    finally {
-        await handle.close();
+        return { bytes: read, digest: sha256 };
+    }, "reject");
+    return nativeDispatchMetadataResultSchema.parse({
+        target_sha256: target.sha256,
+        provider: {
+            id: "native-macos",
+            name: "macOS native inspection utilities",
+            version: "apple-metadata-reader-1",
+        },
+        analysis_profile_digest: null,
+        result: decodeAppleDispatchMetadata(bytes, maxRecords, { path: target.path, sha256: digest }, target.architecture),
+    });
+};
+const OPERATION = "inspect_native_dispatch_metadata";
+/** Translate the owned target read, keeping a failed close beside its physical outcome. */
+export const appleDispatchMetadataFailure = (cause, path) => {
+    if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) {
+        const physical = cause instanceof ArtifactFileCleanupFailure
+            ? cause.fileCleanupFailure
+            : undefined;
+        const previous = physical?.outcome.kind === "failed"
+            ? appleDispatchMetadataFailure(artifactFilePrimaryFailure(cause), path)
+            : physical?.completionCancellation === undefined
+                ? undefined
+                : new AnalysisCancelledError(OPERATION, {
+                    cause: physical.completionCancellation.reason,
+                });
+        const failure = new ProviderCleanupError(IDENTITY.id, cause.cleanup.resources, {
+            reason: cause.cleanup.reason,
+            previous_error: previous === undefined ? null : projectAnalysisError(previous),
+        }, { operation: OPERATION, cause, cleanupPrimary: previous });
+        bindArtifactFileCleanup(cause, failure);
+        return failure;
     }
+    if (cause instanceof AnalysisError)
+        return cause;
+    if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled")
+        return new AnalysisCancelledError(OPERATION, {
+            cause: artifactFileCancellationCause(cause),
+        });
+    if (cause instanceof ArtifactReaderFailure && cause.reason === "unavailable")
+        return new AnalysisCapabilityUnavailableError(IDENTITY.id, OPERATION, cause.message, { cause });
+    return new ProviderAdapterError(IDENTITY.id, OPERATION, {
+        cause,
+        diagnostics: {
+            target_path: path,
+            reason: cause instanceof Error ? cause.message : String(cause),
+        },
+    });
 };

package/dist/native/AppleMachoFixups.js

@@ -314,31 +314,41 @@ const chainedFixups = (image, range, unreadRebaseBytes) => {
 };
 const uleb = (bytes, cursor, end) => {
     let value = 0n;
-    let shift = 0n;
+    let shift = 0;
     for (;;) {
         if (cursor.at >= end)
             throw new RangeError("Truncated bind opcode operand");
         const byte = bytes[cursor.at++] ?? 0;
-        value |= BigInt(byte & 0x7f) << shift;
-        shift += 7n;
+        const slice = byte & 0x7f;
+        if ((shift === 63 && slice > 1) || (shift === 64 && slice !== 0))
+            throw new RangeError("Oversized bind opcode operand");
+        if (shift < 64)
+            value |= BigInt(slice) << BigInt(shift);
+        // Padding may extend the encoding, but never the represented integer.
+        shift = Math.min(64, shift + 7);
         if ((byte & 0x80) === 0)
             return value;
-        if (shift > 63n)
-            throw new RangeError("Oversized bind opcode operand");
     }
 };
 const sleb = (bytes, cursor, end) => {
     let value = 0n;
-    let shift = 0n;
+    let shift = 0;
     let byte = 0;
     do {
         if (cursor.at >= end)
             throw new RangeError("Truncated bind opcode operand");
         byte = bytes[cursor.at++] ?? 0;
-        value |= BigInt(byte & 0x7f) << shift;
-        shift += 7n;
-    } while ((byte & 0x80) !== 0 && shift <= 63n);
-    return (byte & 0x40) !== 0 ? value - (1n << shift) : value;
+        const slice = byte & 0x7f;
+        if ((shift === 63 && slice !== 0 && slice !== 0x7f) ||
+            (shift === 64 && slice !== (value < 0n ? 0x7f : 0)))
+            throw new RangeError("Oversized bind opcode operand");
+        if (shift < 64)
+            value = BigInt.asIntN(64, value | (BigInt(slice) << BigInt(shift)));
+        shift = Math.min(64, shift + 7);
+    } while ((byte & 0x80) !== 0);
+    return shift < 64 && (byte & 0x40) !== 0
+        ? value - (1n << BigInt(shift))
+        : value;
 };
 /** Apply a bind opcode that sets a register; false when the opcode is not one. */
 const setBindRegister = (image, stream, state, byte) => {

package/dist/native/AppleObjcCategories.js

@@ -24,9 +24,20 @@ export const decodeObjcCategories = (input) => {
             try {
                 const category = read.pointer(field);
                 const name = read.string(read.pointer(category));
+                if (name.length === 0)
+                    throw new TypeError("Objective-C category has an empty name");
                 const external = boundClassName(read, category + 8n);
                 const local = read.pointer(category + 8n);
-                const className = external ?? (local === 0n ? null : input.localClassName(local));
+                let className = external ?? null;
+                if (external === undefined && local !== 0n)
+                    try {
+                        className = input.localClassName(local);
+                    }
+                    catch (cause) {
+                        // The category's own name and methods do not depend on its owner;
+                        // keep them and report the unreadable class reference.
+                        input.issues.push(issue("objc_properties_categories", "category_class_unresolved", `Category ${name} class reference 0x${local.toString(16)}: ${cause instanceof Error ? cause.message : String(cause)}`, `0x${(category + 8n).toString(16)}`));
+                    }
                 const owner = className ?? `(${name})`;
                 result.objc_categories.push({
                     name,

package/dist/native/AppleObjcDispatchFacets.js

@@ -4,8 +4,14 @@ import { readObjcPropertiesOf } from "./AppleObjcProperties.js";
 import { createObjcProtocolReader } from "./AppleObjcProtocols.js";
 const hex = (value) => `0x${value.toString(16)}`;
 const decoded = { status: "decoded", reason: null };
-/** Name of a class defined in this image, from its class_ro_t. */
-const localClassName = (read, address) => read.string(read.pointer((read.pointer(address + 32n) & ~7n) + 24n));
+/** Admit the local class identity once for classes, superclasses and categories. */
+const readLocalClass = (read, address) => {
+    const ro = read.pointer(address + 32n) & ~7n;
+    const name = read.string(read.pointer(ro + 24n));
+    if (name.length === 0)
+        throw new TypeError(`Objective-C class at ${hex(address)} has an empty name`);
+    return { ro, name };
+};
 /**
  * Resolve a class's superclass: a bind to `_OBJC_CLASS_$_Name` names a class
  * in another image; otherwise the pointer is a class_t in this image.
@@ -18,12 +24,13 @@ const resolveSuperclass = (read, address, className, failures) => {
     if (superclass === 0n)
         return { name: null, address: null };
     try {
-        return { name: localClassName(read, superclass), address: hex(superclass) };
+        return {
+            name: readLocalClass(read, superclass).name,
+            address: hex(superclass),
+        };
     }
     catch (cause) {
-        // Superclass resolution failure is recorded; the cause adds no identity.
-        void cause;
-        failures.push(`Superclass pointer ${hex(superclass)} of ${className} requires unsupported binding/fixup resolution`);
+        failures.push(`Superclass pointer ${hex(superclass)} of ${className} could not be decoded: ${cause instanceof Error ? cause.message : String(cause)}`);
         return { name: null, address: hex(superclass) };
     }
 };
@@ -89,6 +96,8 @@ export const decodeObjcDispatchFacets = (input) => {
                 void cause;
             }
             const selector = read.string(selectorAddress);
+            if (selector.length === 0)
+                throw new TypeError("Objective-C method has an empty selector");
             selectors.push(selector);
             result.objc_dispatch_implementations.push({
                 class_name: className,
@@ -180,10 +189,7 @@ export const decodeObjcDispatchFacets = (input) => {
         if (address === 0n || visited.has(hex(address)) || !budget.admit())
             return;
         visited.add(hex(address));
-        const ro = read.pointer(address + 32n) & ~7n;
-        const name = read.string(read.pointer(ro + 24n));
-        if (name.length === 0)
-            throw new TypeError(`Objective-C class at ${hex(address)} has an empty name`);
+        const { ro, name } = readLocalClass(read, address);
         const root = (read.u32(ro) & 2) !== 0;
         const superclass = resolveSuperclass(read, address, name, failures);
         if (superclass.name === null && superclass.address === null && !root)
@@ -209,10 +215,13 @@ export const decodeObjcDispatchFacets = (input) => {
                     void cause;
                     failures.push(`Unresolved ivar offset pointer ${hex(encodedOffset)}`);
                 }
+                const ivarName = read.string(read.pointer(entry + 8n));
+                if (ivarName.length === 0)
+                    throw new TypeError("Objective-C ivar has an empty name");
                 const alignment = read.u32(entry + 24n);
                 result.objc_ivars.push({
                     class_name: name,
-                    name: read.string(read.pointer(entry + 8n)),
+                    name: ivarName,
                     type_encoding: read.string(read.pointer(entry + 16n)),
                     offset: value,
                     size: read.u32(entry + 28n),
@@ -316,7 +325,7 @@ export const decodeObjcDispatchFacets = (input) => {
         admit: () => budget.admit(),
         methods,
         protocols: (list) => protocolReader.list(list),
-        localClassName: (address) => localClassName(read, address),
+        localClassName: (address) => readLocalClass(read, address).name,
     });
     return {
         failures,

package/dist/native/AppleObjcProperties.js

@@ -3,15 +3,24 @@ import { issue } from "./AppleDispatchDecodeFacts.js";
  * Parse an `@property` attribute string such as `T@"NSString",C,N,V_name`.
  * Each comma-separated token is one attribute; `T` is the type encoding.
  */
-export const parsePropertyAttributes = (name, attributes) => {
-    const tokens = attributes.length === 0 ? [] : splitAttributes(attributes);
+export const parsePropertyAttributes = (name, attributes) => decodePropertyAttributes(name, attributes).property;
+/**
+ * Decode one attribute string. A quoted class name that never closes leaves
+ * the string incomplete: later attributes may be inside the unfinished type,
+ * so a missing `N` or `R` does not establish the Objective-C defaults.
+ */
+const decodePropertyAttributes = (name, attributes) => {
+    const { tokens, complete } = attributes.length === 0
+        ? { tokens: [], complete: true }
+        : splitAttributes(attributes);
     const typeAttributes = tokens.filter((token) => token[0] === "T");
     const typeAttribute = typeAttributes.length === 1 ? typeAttributes[0] : undefined;
     const typeEncoding = typeAttribute !== undefined && typeAttribute.length > 1
         ? typeAttribute.slice(1)
         : null;
     const value = (code) => tokens.find((token) => token[0] === code)?.slice(1) ?? null;
-    return {
+    const defaultsEstablished = typeEncoding !== null && complete;
+    const property = {
         name,
         type_encoding: typeEncoding,
         attributes: tokens.map((token) => ({
@@ -20,19 +29,23 @@ export const parsePropertyAttributes = (name, attributes) => {
         })),
         atomicity: tokens.includes("N")
             ? "nonatomic"
-            : typeEncoding === null
-                ? null
-                : "atomic",
+            : defaultsEstablished
+                ? "atomic"
+                : null,
         is_readonly: tokens.includes("R")
             ? true
-            : typeEncoding === null
-                ? null
-                : false,
+            : defaultsEstablished
+                ? false
+                : null,
         getter: value("G"),
         setter: value("S"),
     };
+    return { property, complete };
 };
-/** Split on commas that are outside a quoted class name in the type encoding. */
+/**
+ * Split on commas that are outside a quoted class name in the type encoding,
+ * and report whether every quote closed.
+ */
 const splitAttributes = (attributes) => {
     const tokens = [];
     let current = "";
@@ -48,29 +61,60 @@ const splitAttributes = (attributes) => {
             current += character;
     }
     tokens.push(current);
-    return tokens.filter((token) => token.length > 0);
+    return {
+        tokens: tokens.filter((token) => token.length > 0),
+        complete: !quoted,
+    };
 };
-/** Decode `property_list_t { entsize_and_flags, count, property_t[] }`. */
+/**
+ * Decode `property_list_t { entsize_and_flags, count, property_t[] }`. Each
+ * entry is decoded on its own, so one malformed entry is reported without
+ * discarding the properties decoded before or after it.
+ */
 export const readObjcPropertyList = (read, list, admit) => {
+    const properties = [];
+    const issues = [];
     if (list === 0n)
-        return [];
+        return { properties, issues };
     const entrySize = read.u32(list) & ~3;
     const count = read.u32(list + 4n);
     if (entrySize !== 16)
         throw new TypeError(`Unsupported Objective-C property entry size ${entrySize}`);
-    const properties = [];
     for (let index = 0; index < count; index++) {
         if (!admit())
             break;
         const entry = list + 8n + BigInt(index * entrySize);
-        properties.push(parsePropertyAttributes(read.string(read.pointer(entry)), read.string(read.pointer(entry + 8n))));
+        const location = `0x${entry.toString(16)}`;
+        try {
+            const name = read.string(read.pointer(entry));
+            if (name.length === 0)
+                throw new TypeError("the property name is empty");
+            const decoded = decodePropertyAttributes(name, read.string(read.pointer(entry + 8n)));
+            properties.push(decoded.property);
+            if (!decoded.complete)
+                issues.push({
+                    code: "property_attributes_incomplete",
+                    message: `property ${name} has an unterminated quoted class name in its type attribute, so atomicity and unestablished read-only state are unknown`,
+                    location,
+                });
+        }
+        catch (cause) {
+            issues.push({
+                code: "property_decode_failed",
+                message: `property ${String(index)} could not be decoded: ${cause instanceof Error ? cause.message : String(cause)}`,
+                location,
+            });
+        }
     }
-    return properties;
+    return { properties, issues };
 };
 /** Decode a property list, recording a failure for `owner` instead of throwing. */
 export const readObjcPropertiesOf = (read, list, context) => {
     try {
-        return readObjcPropertyList(read, list, context.admit);
+        const { properties, issues } = readObjcPropertyList(read, list, context.admit);
+        for (const item of issues)
+            context.issues.push(issue("objc_properties_categories", item.code, `${context.owner}: ${item.message}`, item.location));
+        return properties;
     }
     catch (cause) {
         context.issues.push(issue("objc_properties_categories", "property_decode_failed", `${context.owner}: ${cause instanceof Error ? cause.message : String(cause)}`, context.location));

package/dist/native/AppleObjcProtocols.js

@@ -20,7 +20,9 @@ export const createObjcProtocolReader = (input) => {
         }
         return names;
     };
-    const methods = (address, required, instance) => {
+    const methods = (address, required, instance, 
+    /** Entries skipped for an empty selector, reported by the declaring protocol. */
+    emptySelectors) => {
         const output = [];
         if (address === 0n)
             return output;
@@ -38,8 +40,15 @@ export const createObjcProtocolReader = (input) => {
                 : read.pointer(entry);
             if (relative && (flags & 0x40000000) === 0)
                 selector = read.pointer(selector);
+            // One empty selector is reported on its own, so the protocol and its
+            // other method declarations keep their decoded records.
+            const selectorName = read.string(selector);
+            if (selectorName.length === 0) {
+                emptySelectors.push(`${required ? "required" : "optional"} ${instance ? "instance" : "class"} method ${String(index)} at 0x${entry.toString(16)} has an empty selector`);
+                continue;
+            }
             output.push({
-                selector: read.string(selector),
+                selector: selectorName,
                 method_type: instance ? "instance" : "class",
                 address: null,
                 is_required: required,
@@ -56,15 +65,22 @@ export const createObjcProtocolReader = (input) => {
             if (read.u32(address + 64n) < 72)
                 throw new RangeError("Truncated Objective-C protocol declaration");
             const protocolName = name(address);
+            // Adopted protocols are independent declarations; decode them before
+            // rejecting a parent whose own name is empty.
             const adopted = list(read.pointer(address + 16n));
+            if (protocolName.length === 0)
+                throw new TypeError("Objective-C protocol has an empty name");
+            const skipped = [];
             const required = [
-                ...methods(read.pointer(address + 24n), true, true),
-                ...methods(read.pointer(address + 32n), true, false),
+                ...methods(read.pointer(address + 24n), true, true, skipped),
+                ...methods(read.pointer(address + 32n), true, false, skipped),
             ];
             const optional = [
-                ...methods(read.pointer(address + 40n), false, true),
-                ...methods(read.pointer(address + 48n), false, false),
+                ...methods(read.pointer(address + 40n), false, true, skipped),
+                ...methods(read.pointer(address + 48n), false, false, skipped),
             ];
+            for (const message of skipped)
+                failures.push(`Protocol 0x${address.toString(16)}: Objective-C protocol ${protocolName} ${message}`);
             result.objc_protocols.push({
                 name: protocolName,
                 methods: required,
@@ -77,7 +93,9 @@ export const createObjcProtocolReader = (input) => {
                 methods: required,
                 optional_methods: optional,
                 location: read.location(address),
-                decode: { status: "decoded", reason: null },
+                decode: skipped.length === 0
+                    ? { status: "decoded", reason: null }
+                    : { status: "partial", reason: "protocol_method_selector_empty" },
                 evidence: read.evidence(address, "Objective-C protocol declaration and encoded method lists; IMP fields are not handler targets"),
             });
         }

package/dist/native/AppleSwiftVtables.js

@@ -35,6 +35,8 @@ export const decodeSwiftClassVtables = (input) => {
             if (count > 20000 || tableOffset + count > positiveWords)
                 throw new RangeError("Swift vtable count or offset exceeds declared metadata bounds");
             const owner = read.string(read.relative(descriptor + 8n));
+            if (owner.length === 0)
+                throw new RangeError("Swift class vtable descriptor class name is empty");
             for (let index = 0; index < count; index++) {
                 const entry = header + 8n + BigInt(index * 8);
                 if (!read.admit()) {

package/dist/native/CommandRunner.js

@@ -27,6 +27,7 @@ export class NativeCommandFailure extends Error {
     cleanupOwner;
     cleanupFailures;
     detail;
+    preparationFailure;
     constructor(tool, reason, exitCode = null, options, capture = null, cleanupFailure = null, cleanupResources = []) {
         super(`Native command ${tool} failed: ${reason}`, options);
         this.tool = tool;
@@ -37,7 +38,14 @@ export class NativeCommandFailure extends Error {
         this.cleanupResources = cleanupResources;
         this.cleanupOwner = options?.cleanupOwner;
         this.cleanupFailures = options?.cleanupFailures ?? [];
-        this.detail = options?.detail ?? null;
+        this.preparationFailure =
+            options?.cause instanceof DarwinProcessOwnershipInspectionError
+                ? options.cause
+                : options?.cause instanceof NativeCommandFailure ||
+                    options?.cause instanceof OwnedCommandFailure
+                    ? options.cause.preparationFailure
+                    : undefined;
+        this.detail = options?.detail ?? this.preparationFailure?.message ?? null;
     }
 }
 /** Run allowlisted Xcode tools directly without a shell. */
@@ -234,14 +242,10 @@ const captureProcess = async (executable, arguments_, tool, options, environment
                     : { cleanupOwner: cause.cleanupOwner }),
             }, capture, cause.cleanupFailure, cause.resources));
         }
-        return err(new NativeCommandFailure(tool, "io", null, {
-            cause,
-            // Process supervision needs the Darwin ownership helper; its typed
-            // message names the compiler or SDK prerequisite to fix.
-            ...(cause instanceof DarwinProcessOwnershipInspectionError
-                ? { detail: cause.message }
-                : {}),
-        }));
+        return err(new NativeCommandFailure(tool, cause instanceof DarwinProcessOwnershipInspectionError &&
+            cause.cancellation !== undefined
+            ? "cancelled"
+            : "io", null, { cause }));
     }
 };
 const processFailureReason = (capture) => capture !== null &&