rea-agents 4.1.0 → 5.0.0

package/dist/native/parsers/dyldInfo.js

@@ -1,5 +1,5 @@
 /** Decode Apple dyld inventory rows, projecting export offsets to VM addresses. */
-export const parseDyldSymbols = (output, mode, imageBase = null) => {
+export const parseDyldSymbols = (output, mode, imageBase = null, knownExportNames = new Set()) => {
     const offsets = /^\s*offset\s+symbol\s*$/mu.test(output);
     return output.split(/\r?\n/u).flatMap((rawLine) => {
         const line = rawLine.trim();
@@ -31,7 +31,16 @@ export const parseDyldSymbols = (output, mode, imageBase = null) => {
         const exported = /^(0x[\da-f]+)\s+(.+?)(?:\s+\[([^\]]+)\])?$/iu.exec(line);
         if (exported?.[1] === undefined || exported[2] === undefined)
             return [];
-        const absolute = /\babsolute\b/u.test(exported[3] ?? "");
+        const rawName = /^0x[\da-f]+\s+(.+)$/iu.exec(line)?.[1];
+        const literalName = rawName !== undefined && knownExportNames.has(rawName);
+        // If nm establishes both interpretations, the textual row cannot bind an address or flags.
+        // Let the caller retain the exact nm names without guessing which one owns this row.
+        if (literalName &&
+            exported[3] !== undefined &&
+            knownExportNames.has(exported[2]))
+            return [];
+        const annotation = literalName ? undefined : exported[3];
+        const absolute = /\babsolute\b/u.test(annotation ?? "");
         const address = offsets && !absolute
             ? imageBase === null
                 ? null
@@ -39,9 +48,9 @@ export const parseDyldSymbols = (output, mode, imageBase = null) => {
             : canonicalHex(exported[1]);
         return [
             {
-                name: exported[2],
+                name: literalName ? rawName : exported[2],
                 address,
-                weak: /\bweak-def\b/u.test(exported[3] ?? "") ? true : null,
+                weak: /\bweak-def\b/u.test(annotation ?? "") ? true : null,
                 reexport: false,
                 source: null,
             },

package/dist/native/parsers/echoedPath.js

@@ -0,0 +1,14 @@
+/**
+ * Remove the header line otool and dyld_info print before a slice's output:
+ * `<path>:`, `<path> (architecture <arch>):`, or `<path> [<arch>]:`. File
+ * names may contain line breaks and tool keywords, so only the exact operand
+ * path is stripped; output without that header is returned unchanged.
+ */
+export const withoutEchoedPathHeader = (output, path) => {
+    if (path === undefined || !output.startsWith(path))
+        return output;
+    const header = /^(?: \(architecture [^)\n]*\)| \[[^\]\n]*\])?:\r?\n/u.exec(output.slice(path.length));
+    return header === null
+        ? output
+        : output.slice(path.length + header[0].length);
+};

package/dist/native/parsers/lipo.js

@@ -9,6 +9,20 @@ const architectureSchema = z.object({
 });
 /** Parse `lipo -detailed_info` into deterministic slice metadata. */
 export const parseLipoArchitectures = (output) => {
+    // lipo echoes a thin file's pathname verbatim, including embedded newlines.
+    // Match its final architecture field before splitting records into lines.
+    const thinArchitecture = /(?:^|\r?\n)Non-fat file:[\s\S]* is architecture: ([^\s]+)\s*$/u.exec(output)?.[1];
+    if (thinArchitecture !== undefined)
+        return [
+            architectureSchema.parse({
+                name: thinArchitecture,
+                cpu_type: null,
+                cpu_subtype: null,
+                file_offset: null,
+                size: null,
+                alignment: null,
+            }),
+        ];
     const architectures = [];
     let current;
     const flush = () => {

package/dist/native/parsers/otool.js

@@ -11,7 +11,7 @@ export const parseOtoolLoadCommands = (raw) => {
     const output = normalizeLineEndings(raw);
     const header = parseHeader(output);
     const state = createLoadCommandState(header?.flags);
-    for (const block of output.split(/(?=Load command \d+)/u))
+    for (const block of output.split(/(?=^Load command \d+$)/mu))
         parseLoadCommand(block, state);
     return {
         fileType: header?.fileType ?? null,

package/dist/native/parsers/plist.js

@@ -1,17 +1,175 @@
 import { z } from "zod";
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { projectPlistValue, } from "../../domain/apple/plistValue.js";
+import { omitPrototypeKeys, omittedPrototypeKeysLimitation, parseXmlPropertyList, } from "../../domain/propertyListKeys.js";
 import { err, ok } from "../../domain/result.js";
-import { safeParseJson } from "../../domain/safeJson.js";
 const plistObject = z.record(z.string(), z.unknown());
-/** Parse plutil JSON output and project stable bundle metadata. */
-export const parsePlistJson = (output) => {
+/** Digits of a JSON number literal that has no fraction or exponent. */
+const INTEGRAL_LITERAL = /^-?\d+$/u;
+/**
+ * Decode plutil JSON, passing each integral number literal beyond the exact
+ * range of a JavaScript number, with its source digits, to `unsafe`.
+ */
+const decodePlistJson = (output, unsafe) => {
     // plutil output can carry a UTF-8 BOM, which JSON.parse rejects outright.
-    const parsed = safeParseJson(output.replace(/^\uFEFF/u, ""));
-    if (!parsed.ok)
-        return err(new AnalysisOutputError("inspect_plist", parsed.error, {
-            cause: parsed.cause,
-        }));
-    const value = parsed.value;
+    const text = output.replace(/^\uFEFF/u, "");
+    return JSON.parse(text, (_key, item, context) => {
+        const source = context?.source;
+        return typeof item !== "number" ||
+            Number.isSafeInteger(item) ||
+            source === undefined ||
+            !INTEGRAL_LITERAL.test(source)
+            ? item
+            : unsafe(item, source);
+    });
+};
+/**
+ * Whether plutil JSON holds an integral number beyond the exact range of a
+ * JSON number. JSON prints an integral `<real>` and an `<integer>` alike, so
+ * such a number's element type must be read from plutil's XML conversion.
+ */
+export const plistJsonNeedsNumberTypes = (output) => {
+    let found = false;
+    try {
+        decodePlistJson(output, (item) => {
+            found = true;
+            return item;
+        });
+    }
+    catch {
+        // Malformed JSON is reported by `parsePlistJson`.
+    }
+    return found;
+};
+/**
+ * Parse plutil JSON output and project stable bundle metadata. An integer
+ * beyond the exact range of a JSON number keeps its decimal text when
+ * `xmlConversion`, plutil's XML form of the same plist, shows that it came
+ * from an `<integer>` rather than a `<real>`.
+ */
+export const parsePlistJson = (output, xmlConversion) => {
+    const literals = xmlConversion === undefined ? undefined : xmlNumberLiterals(xmlConversion);
+    let exactIntegerCount = 0;
+    let ambiguousNumberCount = 0;
+    const classify = (item, digits) => {
+        const exact = BigInt(digits).toString();
+        const integer = literals?.integers.get(item)?.has(exact) === true;
+        const real = literals?.reals.has(item) === true;
+        if (integer && !real) {
+            exactIntegerCount += 1;
+            return { $plist_type: "integer", decimal: digits };
+        }
+        // An integral <real> decodes exactly; only its JSON spelling is integral.
+        if (real && !integer)
+            return item;
+        ambiguousNumberCount += 1;
+        return item;
+    };
+    let decoded;
+    try {
+        decoded = omitPrototypeKeys(decodePlistJson(output, classify));
+    }
+    catch (cause) {
+        return err(new AnalysisOutputError("inspect_plist", cause instanceof Error ? cause.message : String(cause), { cause }));
+    }
+    const { value } = decoded;
+    return ok({
+        value,
+        bundle: projectPlistBundle(value),
+        limitations: [
+            ...numberLimitations(exactIntegerCount, ambiguousNumberCount),
+            ...prototypeKeyLimitations(decoded.omittedPrototypeKeys),
+        ],
+    });
+};
+/**
+ * Parse plutil XML output for a plist that JSON cannot express, such as one
+ * containing data, dates, or non-finite reals.
+ */
+export const parsePlistXml = (output) => {
+    let projected;
+    let omittedPrototypeKeys;
+    try {
+        const decoded = parseXmlPropertyList(output);
+        omittedPrototypeKeys = decoded.omittedPrototypeKeys;
+        projected = projectPlistValue(decoded.value);
+    }
+    catch (cause) {
+        return err(new AnalysisOutputError("inspect_plist", "plutil XML conversion was not a readable plist", { cause }));
+    }
+    // The XML decoder turns <integer> and <real> into numbers before REA sees
+    // them, rounding integers beyond the exact range.
+    const literals = xmlNumberLiterals(output);
+    let exactIntegerCount = 0;
+    let ambiguousNumberCount = 0;
+    const value = mapJsonNumbers(projected.value, (item) => {
+        const decimals = literals.integers.get(item);
+        if (decimals === undefined)
+            return item;
+        const [decimal] = decimals;
+        if (decimals.size !== 1 ||
+            decimal === undefined ||
+            literals.reals.has(item)) {
+            ambiguousNumberCount += 1;
+            return item;
+        }
+        exactIntegerCount += 1;
+        return { $plist_type: "integer", decimal };
+    });
+    return ok({
+        value,
+        bundle: projectPlistBundle(value),
+        limitations: [
+            'plutil cannot express this plist as JSON, so it was decoded from plutil\'s XML conversion; data and date values are typed objects such as { "$plist_type": "data", "base64": ... }.',
+            ...(projected.unknownRealCount === 0
+                ? []
+                : [
+                    `${String(projected.unknownRealCount)} non-finite real value(s) are reported as { "$plist_type": "real", "value": null } because the XML decoder does not distinguish NaN from infinity.`,
+                ]),
+            ...numberLimitations(exactIntegerCount, ambiguousNumberCount),
+            ...prototypeKeyLimitations(omittedPrototypeKeys),
+        ],
+    });
+};
+// plutil escapes "<" in keys and strings, so these element literals can be
+// read from the XML text.
+const xmlNumberLiterals = (xml) => {
+    const integers = new Map();
+    for (const [, decimal = ""] of xml.matchAll(/<integer>\s*([+-]?\d+)\s*<\/integer>/gu)) {
+        const rounded = Number(decimal);
+        if (Number.isSafeInteger(rounded))
+            continue;
+        integers.set(rounded, (integers.get(rounded) ?? new Set()).add(BigInt(decimal).toString()));
+    }
+    const reals = new Set([...xml.matchAll(/<real>([^<]*)<\/real>/gu)].map(([, text = ""]) => Number.parseFloat(text)));
+    return { integers, reals };
+};
+const prototypeKeyLimitations = (count) => count === 0 ? [] : [omittedPrototypeKeysLimitation(count)];
+const numberLimitations = (exactIntegerCount, ambiguousNumberCount) => [
+    ...(exactIntegerCount === 0
+        ? []
+        : [
+            `${String(exactIntegerCount)} integer value(s) exceed the exact range of a JSON number and are reported as { "$plist_type": "integer", "decimal": "<exact digits>" }.`,
+        ]),
+    ...(ambiguousNumberCount === 0
+        ? []
+        : [
+            `${String(ambiguousNumberCount)} number(s) beyond the exact range of a JSON number are reported as decoded because the XML literal they came from, a rounded <integer> or a <real>, cannot be identified.`,
+        ]),
+];
+const mapJsonNumbers = (value, map) => {
+    if (typeof value === "number")
+        return map(value);
+    if (Array.isArray(value))
+        return value.map((item) => mapJsonNumbers(item, map));
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            mapJsonNumbers(item, map),
+        ]));
+    return value;
+};
+const projectPlistBundle = (value) => {
     const object = plistObject.safeParse(value);
     const field = (name) => {
         if (!object.success)
@@ -19,14 +177,11 @@ export const parsePlistJson = (output) => {
         const candidate = object.data[name];
         return typeof candidate === "string" ? candidate : null;
     };
-    return ok({
-        value,
-        bundle: {
-            identifier: field("CFBundleIdentifier"),
-            executable: field("CFBundleExecutable"),
-            name: field("CFBundleName"),
-            version: field("CFBundleVersion"),
-            short_version: field("CFBundleShortVersionString"),
-        },
-    });
+    return {
+        identifier: field("CFBundleIdentifier"),
+        executable: field("CFBundleExecutable"),
+        name: field("CFBundleName"),
+        version: field("CFBundleVersion"),
+        short_version: field("CFBundleShortVersionString"),
+    };
 };

package/dist/process/ExecFileOutput.js

@@ -7,6 +7,8 @@ export const execFileOutput = (command, arguments_, options = {}) => new Promise
         maxBuffer: options.maxBuffer ?? Number.POSITIVE_INFINITY,
     }, (error, stdout, stderr) => {
         if (error !== null) {
+            Reflect.set(error, "stdout", stdout);
+            Reflect.set(error, "stderr", stderr);
             reject(error);
             return;
         }

package/dist/process/ProviderProcess.js

@@ -58,7 +58,7 @@ export const spawnOwnedProviderProcess = async (options) => {
 /**
  * Supervises only generic process resources; wire protocol remains adapter-owned.
  *
- * Output retention is bounded per stream while byte totals remain exact. Stop
+ * Output retention is complete per stream; adapters own resource budgets. Stop
  * first honors token-verified group cleanup when supplied, otherwise it uses a
  * bounded TERM-to-KILL escalation for a directly owned child.
  */
@@ -68,6 +68,8 @@ export class ProviderProcessSupervisor {
     #stdout = new ProcessOutputCapture();
     #stderr = new ProcessOutputCapture();
     #exit = deferred();
+    #outputClose = deferred();
+    #outputClosed = false;
     #onStdout = (chunk) => {
         this.#capture("stdout", this.#stdout, chunk);
     };
@@ -79,6 +81,8 @@ export class ProviderProcessSupervisor {
     };
     #onClose = (code, signal) => {
         this.#recordExit(code, signal);
+        this.#outputClosed = true;
+        this.#outputClose.resolve(undefined);
     };
     #onError = (cause) => {
         this.#options.onDiagnostic?.({ type: "error", message: cause.message });
@@ -89,7 +93,8 @@ export class ProviderProcessSupervisor {
     constructor(launch, options = {}) {
         this.launch = launch;
         this.#options = options;
-        this.#attach(launch.process.stdout, "stdout");
+        if (options.captureStdout !== false)
+            this.#attach(launch.process.stdout, "stdout");
         this.#attach(launch.process.stderr, "stderr");
         launch.process.once("exit", this.#onExit);
         launch.process.once("close", this.#onClose);
@@ -106,23 +111,18 @@ export class ProviderProcessSupervisor {
             signal: this.#exitObservation?.signal,
         };
     }
+    /** Begin a new observation on a retained process without retaining earlier output. */
+    resetOutput() {
+        this.#stdout.reset();
+        this.#stderr.reset();
+    }
     /** Wait for process exit up to a caller-owned bounded interval. */
     async waitForExit(timeoutMs) {
-        if (this.#exitObservation !== undefined)
-            return true;
-        let timer;
-        try {
-            return await Promise.race([
-                this.#exit.promise.then(() => true),
-                new Promise((resolve) => {
-                    timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
-                }),
-            ]);
-        }
-        finally {
-            if (timer !== undefined)
-                clearTimeout(timer);
-        }
+        return waitForProcessEvent(this.#exitObservation !== undefined, this.#exit.promise, timeoutMs);
+    }
+    /** Wait until the producer has closed its output streams; exit alone does not prove complete output. */
+    async waitForOutputClose(timeoutMs) {
+        return waitForProcessEvent(this.#outputClosed, this.#outputClose.promise, timeoutMs);
     }
     /** Stop an owned process once; concurrent callers share the same escalation. */
     stop(options = {}) {
@@ -237,6 +237,10 @@ class ProcessOutputCapture {
     get bytes() {
         return this.#bytes;
     }
+    reset() {
+        this.#chunks.length = 0;
+        this.#bytes = 0;
+    }
     append(chunk) {
         this.#bytes += chunk.byteLength;
         this.#chunks.push(Buffer.from(chunk));
@@ -273,3 +277,20 @@ const waitForSpawn = (child) => new Promise((resolve, reject) => {
     child.once("spawn", onSpawn);
     child.once("error", onError);
 });
+const waitForProcessEvent = async (observed, event, timeoutMs) => {
+    if (observed)
+        return true;
+    let timer;
+    try {
+        return await Promise.race([
+            event.then(() => true),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+};

package/dist/reference/ReferenceSourceReaderEntries.js

@@ -31,6 +31,12 @@ export const traverseDirectory = async (state, current) => {
         state.entries.push(entryFailure(pathFromRoot(state.root, current.path), "directory", "changed", "Directory changed while it was read"));
         return { ok: true, value: undefined };
     }
+    if (current.path !== state.root)
+        state.entries.push({
+            status: "read",
+            kind: "directory",
+            path: pathFromRoot(state.root, current.path),
+        });
     const directories = [];
     for (const name of names.value) {
         const result = await processEntry(state, current, name, directories);
@@ -102,7 +108,6 @@ const processEntry = async (state, current, name, directories) => {
     if (metadata.value.isSymbolicLink())
         state.entries.push(await describeSymlink(state.root, absolute, path, state.signal));
     else if (metadata.value.isDirectory()) {
-        state.entries.push({ status: "read", kind: "directory", path });
         directories.push({ path: absolute });
     }
     else if (!metadata.value.isFile())

package/dist/server/createServer.js

@@ -6,16 +6,26 @@ import { registerApplicationTools } from "./registerApplicationTools.js";
 import { registerArtifactTools } from "./registerArtifactTools.js";
 import { registerBrowserScenarioTool } from "./registerBrowserScenarioTool.js";
 import { registerBrowserTools } from "./registerBrowserTools.js";
+import { registerWebScriptTool } from "./registerWebScriptTool.js";
+import { registerWebModuleTool } from "./registerWebModuleTool.js";
+import { createWebModuleTraceService } from "../composition/webModules.js";
+import { createWebSourceLocationService } from "../composition/webSourceLocations.js";
+import { registerWebSourceLocationTool } from "./registerWebSourceLocationTool.js";
+import { createWebRuntimeService } from "../composition/webRuntime.js";
+import { registerWebRuntimeTools } from "./registerWebRuntimeTools.js";
+import { registerJavaScriptRecoveryTool } from "./registerJavaScriptRecoveryTool.js";
+import { JavaScriptRecoveryService } from "../application/javascript/JavaScriptRecoveryService.js";
+import { createJavaScriptRecoveryProvider } from "../composition/javascriptRecovery.js";
 import { registerElectronTools } from "./registerElectronTools.js";
 import { registerEnhancedTools } from "./registerEnhancedTools.js";
 import { registerJavaScriptRuntimeObservationTools } from "./registerJavaScriptRuntimeObservationTools.js";
 import { registerManagedTools } from "./registerManagedTools.js";
 import { registerFirmwareTools } from "./registerFirmwareTools.js";
-import { FirmwareAnalysisService } from "../application/FirmwareAnalysisService.js";
-import { FirmwareProvider } from "../firmware/FirmwareProvider.js";
+import { FirmwareAnalysisService } from "../application/firmware/FirmwareAnalysisService.js";
+import { createFirmwareAnalysisProvider } from "../composition/firmware.js";
 import { registerAndroidTools } from "./registerAndroidTools.js";
-import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
-import { JadxProvider } from "../android/JadxProvider.js";
+import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
+import { createAndroidAnalysisProvider } from "../composition/android.js";
 import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
 import { registerNativeTools } from "./registerNativeTools.js";
 import { registerOfficialTools } from "./registerOfficialTools.js";
@@ -28,7 +38,10 @@ const installSessionToolAvailability = (server, session, options) => {
     if (session === undefined)
         return undefined;
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
+        optionalProviderLoadFailures: options.optionalProviderLoadFailures,
         optionalFeatures: {
+            webModuleResolutionEnabled: options.webModuleTrace !== undefined ||
+                isAbsolute(process.env.REA_BROWSER_EXECUTABLE ?? ""),
             firmwareInspectionEnabled: options.firmwareAnalysis !== undefined ||
                 (process.platform === "linux" &&
                     isAbsolute(process.env.REA_BINWALK_COMMAND ?? "")),
@@ -39,6 +52,10 @@ const installSessionToolAvailability = (server, session, options) => {
                 ((process.platform === "linux" || process.platform === "darwin") &&
                     isAbsolute(process.env.REA_JADX_MCP_JAR ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
+            javascriptRecoveryEnabled: options.javascriptRecovery !== undefined ||
+                (process.platform === "linux" &&
+                    process.arch === "x64" &&
+                    isAbsolute(process.env.REA_WAKARU_COMMAND ?? "")),
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
             electronAutomationEnabled: options.electronActiveObservation !== undefined,
@@ -82,9 +99,28 @@ export const createServer = (analysis, session, options = {}) => {
         recordEvidenceWithUnknown,
     };
     registerBinaryAnalysisTools(toolContext);
-    registerAndroidTools(server, new AndroidAnalysisService(options.androidAnalysis ?? new JadxProvider()), toolLogger, recordEvidence);
-    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? new FirmwareProvider()), toolLogger, recordEvidence);
+    const android = options.androidAnalysis ?? createAndroidAnalysisProvider();
+    const previousOnclose = server.server.onclose;
+    server.server.onclose = () => {
+        previousOnclose?.();
+        void android.close().catch((cause) => {
+            logger.error({ error: cause instanceof Error ? cause.message : String(cause) }, "Android provider cleanup failed");
+        });
+    };
+    const closeServer = server.close.bind(server);
+    server.close = async () => {
+        const results = await Promise.allSettled([closeServer(), android.close()]);
+        for (const result of results)
+            if (result.status === "rejected")
+                throw result.reason;
+    };
+    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence);
+    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider()), toolLogger, recordEvidence);
     registerObservationTools(toolContext);
+    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(), toolLogger, recordEvidence);
+    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(), toolLogger, recordEvidence);
+    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence);
+    registerJavaScriptRecoveryTool(server, new JavaScriptRecoveryService(options.javascriptRecovery ?? createJavaScriptRecoveryProvider()), toolLogger, recordEvidence);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
         registerSessionTools(server, session, toolLogger, {
@@ -149,22 +185,28 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
 };
 const registerObservationTools = ({ evidenceById, server, options, logger, recordEvidence, recordEvidenceWithUnknown, }) => {
     const common = { logger, recordEvidence };
+    registerWebScriptTool(server, common);
     registerBrowserTools(server, {
         ...common,
         browser: options.browserObservation,
+        loadFailure: options.optionalProviderLoadFailures?.browserObservation,
     });
     registerBrowserScenarioTool(server, {
         ...common,
         provider: options.browserScenarioCapture,
+        loadFailure: options.optionalProviderLoadFailures?.browserScenarioCapture,
     });
     registerElectronTools(server, {
         ...common,
         electron: options.electronObservation,
         electronActive: options.electronActiveObservation,
+        observationLoadFailure: options.optionalProviderLoadFailures?.electronObservation,
+        activeLoadFailure: options.optionalProviderLoadFailures?.electronActiveObservation,
     });
     registerJavaScriptRuntimeObservationTools(server, {
         ...common,
         runtime: options.javascriptRuntimeObservation,
+        loadFailure: options.optionalProviderLoadFailures?.javascriptRuntimeObservation,
     });
     registerApplicationTools(server, {
         evidenceById,

package/dist/server/mcpClientMetadata.js

@@ -21,10 +21,13 @@ const capabilityFeatures = (value) => {
     const capabilities = isRecord(value) ? value : {};
     const elicitation = isRecord(capabilities.elicitation)
         ? capabilities.elicitation
-        : {};
+        : undefined;
     return {
-        elicitation_form: elicitation.form !== undefined,
-        elicitation_url: elicitation.url !== undefined,
+        // A declared capability without modes retains the protocol's form-only
+        // compatibility rule; a missing capability still grants no support.
+        elicitation_form: elicitation !== undefined &&
+            (elicitation.form !== undefined || elicitation.url === undefined),
+        elicitation_url: elicitation?.url !== undefined,
         roots: capabilities.roots !== undefined,
         sampling: capabilities.sampling !== undefined,
     };

package/dist/server/registerAndroidTools.js

@@ -1,4 +1,4 @@
-import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
+import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,8 +1,8 @@
 import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascriptExportShapeComparisonSchemas.js";
+import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,8 +1,8 @@
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { compareSourceToBundleEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { sourceToBundleComparisonResultSchema } from "../../domain/sourceToBundleComparisonSchemas.js";
+import { sourceToBundleComparisonResultSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,8 +1,8 @@
 import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { compareApplicationVersionsEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
+import { applicationVersionComparisonResultSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerApplicationTools/projectMobileApplicationGraph.js

@@ -0,0 +1,43 @@
+import { projectAndroidApplicationEvidence } from "../../application/android/AndroidApplicationService.js";
+import { projectAppleApplicationEvidence } from "../../application/apple/AppleApplicationService.js";
+import { APPLICATION_TOOL_CONTRACTS, applicationToolContract, } from "../../contracts/applicationToolContracts.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
+import { logToolExecution } from "../toolLogging.js";
+import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { toCallToolResult } from "../toolResult.js";
+import { recordResult } from "./helpers.js";
+/** Register execution-free Android and Apple inventory projection tools. */
+export const registerProjectMobileApplicationGraphTools = (server, options) => {
+    registerProjection({
+        server,
+        options,
+        contract: applicationToolContract("project_android_application_graph"),
+        project: projectAndroidApplicationEvidence,
+    });
+    registerProjection({
+        server,
+        options,
+        contract: applicationToolContract("project_apple_application_graph"),
+        project: projectAppleApplicationEvidence,
+    });
+};
+const registerProjection = (context) => {
+    const { server, options, contract, project } = context;
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(project(input)));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recordedSources = recordSessionEvidenceSources(options.recordEvidence, inventoryEvidenceSources(input));
+        if (!recordedSources.ok)
+            return toCallToolResult(recordedSources, contract);
+        return recordResult(options, contract, result.value);
+    });
+};
+const inventoryEvidenceSources = (input) => {
+    if (typeof input !== "object" ||
+        input === null ||
+        !("inventory_evidence" in input) ||
+        !Array.isArray(input.inventory_evidence))
+        return [];
+    return input.inventory_evidence;
+};

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,6 +1,6 @@
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { traceApplicationFeatureEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";