rea-agents 6.5.0 → 6.7.0

package/dist/cutter/CutterBridgeClient.js

@@ -1,15 +1,22 @@
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { withArtifactRegularFile, ArtifactFileCleanupFailure, bindArtifactFileCleanup, artifactFileCancellationCause, assertArtifactReadActive, } from "../artifacts/ArtifactFileOperation.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { randomUUID } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { createConnection } from "node:net";
-import { lstat, open, opendir } from "node:fs/promises";
-import { homedir } from "node:os";
+import { lstat, opendir } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
 import { requireWindowsNativeAuthority } from "../windows/WindowsNativeLoader.js";
 import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 const descriptorSchema = z.object({
     session_id: z.string().uuid(),
     pid: z.number().int().positive(),
@@ -129,15 +136,36 @@ class CutterBridgeResponseFrames {
         this.#contentBytes = 0;
     }
 }
-const mapDiscovery = async (inputs, operation) => {
+const assertCommandActive = (signal) => {
+    if (signal?.aborted)
+        throw new AnalysisCancelledError("cutter_command", {
+            cause: signal.reason,
+        });
+};
+const mapDiscovery = async (inputs, operation, signal) => {
+    signal?.throwIfAborted();
     const results = new Array(inputs.length);
     let next = 0;
-    await Promise.all(Array.from({ length: Math.min(inputs.length, DISCOVERY_CONCURRENCY) }, async () => {
-        while (next < inputs.length) {
-            const index = next++;
-            results[index] = await operation(inputs[index]);
+    let stopped = false;
+    const workers = await Promise.allSettled(Array.from({ length: Math.min(inputs.length, DISCOVERY_CONCURRENCY) }, async () => {
+        try {
+            while (!stopped && next < inputs.length) {
+                signal?.throwIfAborted();
+                const index = next++;
+                results[index] = await operation(inputs[index]);
+            }
+        }
+        catch (cause) {
+            stopped = true;
+            throw cause;
         }
     }));
+    const failures = workers.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length > 1)
+        throw new CutterDiscoveryFailure(failures);
+    if (failures.length === 1)
+        throw failures[0];
+    signal?.throwIfAborted();
     return results;
 };
 class CutterBridgeRequestFailure extends Error {
@@ -150,6 +178,7 @@ class CutterBridgeRequestFailure extends Error {
 /** Discovers and communicates with REA Python bridge plugins in live Cutter processes. */
 export class CutterBridgeClient {
     #directory;
+    #descriptorResources = new ArtifactResourceScope();
     #platform;
     #windowsPrivateReader;
     #pendingAcknowledgements = new Map();
@@ -169,14 +198,27 @@ export class CutterBridgeClient {
                             .parse(requireWindowsNativeAuthority().call("cutter_bridge_read_descriptor", [directory, name, maxBytes])),
                     }
                     : undefined);
-        this.#directory =
-            configured ??
-                (this.#platform === "win32" && localAppData
-                    ? join(localAppData, "REA", "CutterBridge")
-                    : join(homedir(), ".cache", "rea", "cutter-bridge"));
+        this.#directory = resolveBridgeDirectory(configured, this.#platform, localAppData, homeDirectoryFromEnvironment(environment, this.#platform));
+    }
+    async retryDescriptorCleanup() {
+        try {
+            await this.#descriptorResources.retryCleanup();
+        }
+        catch (cause) {
+            throw descriptorFailure(cause, "close_cutter_descriptors");
+        }
+    }
+    async close() {
+        try {
+            await this.#descriptorResources.close();
+        }
+        catch (cause) {
+            throw descriptorFailure(cause, "close_cutter_descriptors");
+        }
     }
-    async listSessions() {
-        const loaded = await this.#readDescriptors();
+    async listSessions(options = {}) {
+        const { signal } = options;
+        const loaded = await this.#readDescriptors("list_cutter_sessions", signal);
         if (loaded.error !== undefined)
             return {
                 sessions: [],
@@ -185,11 +227,15 @@ export class CutterBridgeClient {
                 bridge_directory_security: loaded.security,
             };
         const descriptors = await mapDiscovery(loaded.descriptors, async (descriptor) => {
+            if (options.signal?.aborted)
+                throw new AnalysisCancelledError("list_cutter_sessions", {
+                    cause: options.signal.reason,
+                });
             try {
                 const status = responseSchema.safeParse(await this.#request(descriptor, serializeRequest(descriptor, {
                     kind: "status",
                     session_id: descriptor.session_id,
-                })));
+                }), signal));
                 if (!status.success ||
                     !status.data.ok ||
                     status.data.session_id !== descriptor.session_id)
@@ -206,9 +252,14 @@ export class CutterBridgeClient {
                 };
             }
             catch {
+                signal?.throwIfAborted();
                 return undefined;
             }
-        });
+        }, signal);
+        if (options.signal?.aborted)
+            throw new AnalysisCancelledError("list_cutter_sessions", {
+                cause: options.signal.reason,
+            });
         const sessions = descriptors.filter((value) => value !== undefined);
         return {
             sessions,
@@ -218,9 +269,9 @@ export class CutterBridgeClient {
         };
     }
     async execute(input) {
-        input.signal?.throwIfAborted();
-        const descriptor = await this.#find(input.sessionId);
-        input.signal?.throwIfAborted();
+        assertCommandActive(input.signal);
+        const descriptor = await this.#find(input.sessionId, input.signal);
+        assertCommandActive(input.signal);
         const requestId = randomUUID();
         const commandRequest = serializeRequest(descriptor, {
             kind: "command",
@@ -231,7 +282,7 @@ export class CutterBridgeClient {
         });
         await this.#recoverCompletedCommands(descriptor, input.signal);
         await this.#retryPendingAcknowledgements(descriptor);
-        input.signal?.throwIfAborted();
+        assertCommandActive(input.signal);
         let completionToken;
         let rawResponse;
         try {
@@ -311,31 +362,27 @@ export class CutterBridgeClient {
             descriptor = await this.#find(sessionId);
         }
         catch (cause) {
+            if (cause instanceof AnalysisError)
+                return err(cause);
             return err(new AnalysisCapabilityUnavailableError("cutter", "cutter_command", cause instanceof Error ? cause.message : "Cutter session unavailable", { cause }));
         }
         try {
-            const raw = await this.#request(descriptor, serializeRequest(descriptor, {
-                kind: "status",
-                session_id: sessionId,
-            }));
-            const parsed = responseSchema.safeParse(raw);
-            if (!parsed.success ||
-                !parsed.data.ok ||
-                parsed.data.session_id !== sessionId)
-                return err(new AnalysisOutputError("cutter_command_status", "The bridge status response did not contain a valid session identity.", { cause: parsed.success ? undefined : parsed.error }));
-            const completed = (parsed.data.completed_commands ?? []).some((receipt) => receipt.request_id === requestId);
+            const status = await this.#readCommandStatus(descriptor);
+            const completed = (status.completed_commands ?? []).some((receipt) => receipt.request_id === requestId);
             if (completed)
                 await this.#acknowledgeCompletion(descriptor, requestId);
             return ok(completed ||
                 (completionToken !== undefined &&
-                    parsed.data.completed_connection !== undefined &&
-                    parsed.data.completed_connection >= completionToken));
+                    status.completed_connection !== undefined &&
+                    status.completed_connection >= completionToken));
         }
         catch (cause) {
-            return err(new AnalysisCapabilityUnavailableError("cutter", "cutter_command_status", cause instanceof Error ? cause.message : "Cutter status failed", { cause }));
+            if (cause instanceof AnalysisError)
+                return err(cause);
+            return err(new AnalysisCapabilityUnavailableError("cutter", "cutter_command", cause instanceof Error ? cause.message : "Cutter status failed", { cause, diagnostics: { auxiliary_operation: "status" } }));
         }
     }
-    async #recoverCompletedCommands(descriptor, signal) {
+    async #readCommandStatus(descriptor, signal) {
         const raw = await this.#request(descriptor, serializeRequest(descriptor, {
             kind: "status",
             session_id: descriptor.session_id,
@@ -344,11 +391,18 @@ export class CutterBridgeClient {
         if (!status.success ||
             !status.data.ok ||
             status.data.session_id !== descriptor.session_id)
-            throw new AnalysisOutputError("cutter_command_status", "The bridge status response did not contain a valid session identity.", { cause: status.success ? undefined : status.error });
-        if (status.data.completed_connection === undefined)
-            throw new AnalysisOutputError("cutter_command_status", "The bridge did not provide authenticated proof that earlier connections reached a terminal state.");
+            throw new AnalysisOutputError("cutter_command", "The bridge status response did not contain a valid session identity.", {
+                cause: status.success ? undefined : status.error,
+                diagnostics: { auxiliary_operation: "status" },
+            });
+        return status.data;
+    }
+    async #recoverCompletedCommands(descriptor, signal) {
+        const status = await this.#readCommandStatus(descriptor, signal);
+        if (status.completed_connection === undefined)
+            throw new AnalysisOutputError("cutter_command", "The bridge did not provide authenticated proof that earlier connections reached a terminal state.", { diagnostics: { auxiliary_operation: "status" } });
         const pending = this.#pendingAcknowledgements.get(descriptor.session_id) ?? new Set();
-        for (const receipt of status.data.completed_commands ?? [])
+        for (const receipt of status.completed_commands ?? [])
             pending.add(receipt.request_id);
         if (pending.size > 0)
             this.#pendingAcknowledgements.set(descriptor.session_id, pending);
@@ -385,8 +439,8 @@ export class CutterBridgeClient {
                 throw new AnalysisCapabilityUnavailableError("cutter", "cutter_command", "A retained Cutter completion receipt could not be acknowledged; no new command was sent.");
         }
     }
-    async #find(sessionId) {
-        const loaded = await this.#readDescriptors();
+    async #find(sessionId, signal) {
+        const loaded = await this.#readDescriptors("cutter_command", signal);
         if (loaded.error === "bridge_directory_capacity_exceeded")
             throw new AnalysisResourceConstraintError("cutter_command", "transport", "Cutter descriptor discovery exceeded its candidate budget; no command was sent.", {
                 max_descriptor_candidates: MAX_DESCRIPTOR_CANDIDATES,
@@ -400,10 +454,19 @@ export class CutterBridgeClient {
         return descriptor;
     }
     async listDescriptors() {
-        const loaded = await this.#readDescriptors();
+        const loaded = await this.#readDescriptors("list_cutter_sessions");
         return loaded.descriptors;
     }
-    async #readDescriptors() {
+    async #readDescriptors(operation, signal) {
+        try {
+            return await this.#descriptorResources.run(() => this.#loadDescriptors(signal));
+        }
+        catch (cause) {
+            throw descriptorFailure(cause, operation);
+        }
+    }
+    async #loadDescriptors(signal) {
+        assertArtifactReadActive(signal);
         let directoryInfo;
         try {
             directoryInfo = await lstat(this.#directory);
@@ -465,6 +528,7 @@ export class CutterBridgeClient {
         try {
             const directory = await opendir(this.#directory);
             for await (const entry of directory) {
+                assertArtifactReadActive(signal);
                 if (!/^cutter-\d+-[0-9a-f-]{36}\.json$/iu.test(entry.name))
                     continue;
                 if (entries.length === MAX_DESCRIPTOR_CANDIDATES)
@@ -476,7 +540,10 @@ export class CutterBridgeClient {
                 entries.push(entry.name);
             }
         }
-        catch {
+        catch (cause) {
+            if (cause instanceof ArtifactReaderFailure &&
+                cause.reason === "cancelled")
+                throw cause;
             return {
                 descriptors: [],
                 security: "not_checked",
@@ -484,26 +551,29 @@ export class CutterBridgeClient {
             };
         }
         const loaded = await mapDiscovery(entries, async (entry) => {
-            let file;
+            assertArtifactReadActive(signal);
             try {
                 let bytes;
                 if (this.#platform === "win32") {
                     bytes = windowsPrivateReader.readDescriptor(this.#directory, entry, MAX_DESCRIPTOR_BYTES);
                 }
                 else {
-                    const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0);
-                    file = await open(join(this.#directory, entry), flags);
-                    const info = await file.stat();
-                    if (!info.isFile() ||
-                        info.size > MAX_DESCRIPTOR_BYTES ||
-                        info.uid !== currentUid ||
-                        (info.mode & 0o077) !== 0)
-                        return undefined;
-                    const boundedBytes = await readBoundedFileBytes(file, MAX_DESCRIPTOR_BYTES);
+                    const boundedBytes = await withArtifactRegularFile(join(this.#directory, entry), this.#descriptorResources, signal, async (file) => {
+                        const info = await file.stat();
+                        if (info.size > MAX_DESCRIPTOR_BYTES ||
+                            info.uid !== currentUid ||
+                            (info.mode & 0o077) !== 0)
+                            return undefined;
+                        assertArtifactReadActive(signal);
+                        const bytes = await readBoundedFileBytes(file, MAX_DESCRIPTOR_BYTES);
+                        assertArtifactReadActive(signal);
+                        return bytes;
+                    });
                     if (boundedBytes === undefined)
                         return undefined;
                     bytes = boundedBytes;
                 }
+                assertArtifactReadActive(signal);
                 if (bytes.byteLength > MAX_DESCRIPTOR_BYTES)
                     return undefined;
                 const parsed = descriptorSchema.safeParse(JSON.parse(bytes.toString("utf8")));
@@ -512,13 +582,14 @@ export class CutterBridgeClient {
                     return undefined;
                 return parsed.data;
             }
-            catch {
+            catch (cause) {
+                if (cause instanceof ArtifactReaderFailure &&
+                    (cause.cleanup !== undefined || cause.reason === "cancelled"))
+                    throw cause;
                 return undefined;
             }
-            finally {
-                await file?.close().catch(() => undefined);
-            }
         });
+        assertArtifactReadActive(signal);
         return {
             descriptors: loaded.filter((value) => value !== undefined),
             security,
@@ -531,36 +602,39 @@ export class CutterBridgeClient {
                 port: descriptor.port,
             });
             const frames = new CutterBridgeResponseFrames();
-            let settled = false;
+            let completion;
             let requestSent = false;
             let authenticated = false;
             const clientNonce = randomBytes(32).toString("hex");
             let serverNonce = "";
             let connectionOrdinal;
             const finish = (complete) => {
-                if (settled)
+                if (completion !== undefined)
                     return;
-                settled = true;
+                completion = complete;
                 clearTimeout(timer);
                 signal?.removeEventListener("abort", onAbort);
-                complete();
+                // Retain this request until its owned socket has actually closed.
+                connection.destroy();
             };
             const rejectRequest = (message) => finish(() => reject(new CutterBridgeRequestFailure(message, requestSent)));
             const timer = setTimeout(() => {
                 rejectRequest("Cutter bridge request timed out");
-                connection.destroy();
             }, 25_000);
             const onAbort = () => {
                 rejectRequest("Cutter bridge request was cancelled");
-                connection.destroy();
             };
             signal?.addEventListener("abort", onAbort, { once: true });
             if (signal?.aborted)
                 onAbort();
             connection.once("connect", () => {
+                if (completion !== undefined)
+                    return;
                 connection.write(`${JSON.stringify({ kind: "rea-auth-v2", nonce: clientNonce })}\n`);
             });
             connection.on("data", (chunk) => {
+                if (completion !== undefined)
+                    return;
                 try {
                     frames.push(chunk, (line) => {
                         const frame = JSON.parse(line.toString("utf8"));
@@ -603,7 +677,6 @@ export class CutterBridgeClient {
                             if (!timingSafeEqual(expected, Buffer.from(envelope.proof, "hex")))
                                 throw new Error("response proof failed");
                             const response = JSON.parse(envelope.response);
-                            connection.end();
                             finish(() => resolve(response));
                             return false;
                         }
@@ -611,11 +684,77 @@ export class CutterBridgeClient {
                 }
                 catch {
                     rejectRequest("Cutter bridge peer authentication or response failed");
-                    connection.destroy();
                 }
             });
             connection.once("error", (cause) => rejectRequest(`Cutter bridge is unavailable: ${cause.message}`));
-            connection.once("close", () => rejectRequest("Cutter bridge closed before returning a complete response"));
+            connection.once("close", () => {
+                rejectRequest("Cutter bridge closed before returning a complete response");
+                completion?.();
+            });
         });
     }
 }
+const resolveBridgeDirectory = (configured, platform, localAppData, homeDirectory) => {
+    if (configured !== undefined && configured !== "") {
+        if (configured === "~")
+            return homeDirectory;
+        if (configured.startsWith("~/"))
+            return join(homeDirectory, configured.slice(2));
+        if (platform === "win32" && configured.startsWith("~\\"))
+            return join(homeDirectory, configured.slice(2));
+        return configured;
+    }
+    return platform === "win32" && localAppData
+        ? join(localAppData, "REA", "CutterBridge")
+        : join(homeDirectory, ".cache", "rea", "cutter-bridge");
+};
+class CutterDiscoveryFailure extends Error {
+    failures;
+    constructor(failures) {
+        super("Cutter discovery workers failed");
+        this.failures = failures;
+    }
+}
+const descriptorFailure = (cause, operation) => {
+    if (cause instanceof CutterDiscoveryFailure) {
+        const failures = cause.failures.map((failure) => {
+            const parsed = descriptorFailure(failure, operation);
+            return parsed instanceof AnalysisError
+                ? parsed
+                : new ProviderAdapterError("cutter", operation, { cause: parsed });
+        });
+        const cleanup = failures.filter((failure) => failure.cleanupIncomplete);
+        if (cleanup.length === 0)
+            return failures[0];
+        return new ProviderCleanupError("cutter", cleanup.flatMap((failure) => failure.cleanupResources), { reason: "Cutter descriptor discovery failed with unconfirmed closes" }, { operation, cause: new AggregateError(failures, cause.message) }).bindCleanupDependencies(cleanup);
+    }
+    if (!(cause instanceof ArtifactReaderFailure))
+        return cause;
+    if (cause.cleanup !== undefined) {
+        const cleanup = new ProviderCleanupError("cutter", cause.cleanup.resources, { reason: cause.cleanup.reason }, { operation, cause });
+        bindArtifactFileCleanup(cause, cleanup);
+        const outcome = cause instanceof ArtifactFileCleanupFailure
+            ? cause.fileCleanupFailure.outcome
+            : undefined;
+        const primary = outcome?.kind === "failed"
+            ? descriptorFailure(outcome.cause, operation)
+            : outcome?.kind === "completed" &&
+                cause instanceof ArtifactFileCleanupFailure &&
+                cause.fileCleanupFailure.completionCancellation !== undefined
+                ? new AnalysisCancelledError(operation, {
+                    cause: cause.fileCleanupFailure.completionCancellation.reason,
+                })
+                : undefined;
+        if (primary === undefined && outcome?.kind !== "failed")
+            return cleanup;
+        const original = primary instanceof AnalysisError
+            ? primary
+            : new ProviderAdapterError("cutter", operation, { cause: primary });
+        return analysisErrorWithCleanupFailure(original, cleanup, operation).bindCleanupDependencies([cleanup]);
+    }
+    if (cause.reason === "cancelled")
+        return new AnalysisCancelledError(operation, {
+            cause: artifactFileCancellationCause(cause),
+        });
+    return cause;
+};

package/dist/cutter/CutterBridgeService.js

@@ -1,3 +1,5 @@
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
@@ -39,15 +41,54 @@ export class CutterBridgeService {
         }
         return ok(null);
     }
-    listSessions() {
-        return this.client.listSessions();
+    async listSessions(options = {}) {
+        const { signal } = options;
+        try {
+            signal?.throwIfAborted();
+            const discovery = await this.client.listSessions(options);
+            signal?.throwIfAborted();
+            return ok(discovery);
+        }
+        catch (cause) {
+            if (cause instanceof AnalysisError &&
+                !(signal?.aborted && cause === signal.reason))
+                return err(cause);
+            if (signal?.aborted)
+                return err(new AnalysisCancelledError("list_cutter_sessions", {
+                    cause: signal.reason,
+                }));
+            return err(new AnalysisCapabilityUnavailableError("cutter", "list_cutter_sessions", cause instanceof Error ? cause.message : "Cutter discovery failed", { cause }));
+        }
+    }
+    async close() {
+        const pending = await this.retryCleanup();
+        try {
+            if (pending.ok)
+                await this.client.close?.();
+            else
+                await this.client.retryDescriptorCleanup?.();
+        }
+        catch (cause) {
+            const failure = cause instanceof AnalysisError
+                ? cause
+                : new ProviderCleanupError("cutter", [], {
+                    reason: cause instanceof Error ? cause.message : String(cause),
+                }, { cause });
+            throw pending.ok
+                ? failure
+                : analysisErrorWithCleanupFailure(pending.error, failure, "close_cutter").bindCleanupDependencies([pending.error, failure]);
+        }
+        if (!pending.ok)
+            throw pending.error;
     }
     async execute(rawInput, options = {}) {
         const parsed = cutterCommandInputSchema.safeParse(rawInput);
         if (!parsed.success)
             return err(new AnalysisInputError("cutter_command"));
         if (options.signal?.aborted)
-            return err(new AnalysisCancelledError("cutter_command"));
+            return err(new AnalysisCancelledError("cutter_command", {
+                cause: options.signal.reason,
+            }));
         const input = parsed.data;
         const cleanup = await this.retryCleanup();
         if (!cleanup.ok)
@@ -120,6 +161,11 @@ export class CutterBridgeService {
                 });
                 return err(failure);
             }
+            if (options.signal?.aborted)
+                return err(new AnalysisCancelledError("cutter_command", {
+                    cause: options.signal.reason,
+                    partialObservation: evidence,
+                }));
             return ok(evidence);
         }
         catch (cause) {
@@ -129,7 +175,9 @@ export class CutterBridgeService {
                 ? cause.message
                 : "Unknown Cutter bridge failure";
             if (options.signal?.aborted && !message.includes("may have completed"))
-                return err(new AnalysisCancelledError("cutter_command", { cause }));
+                return err(new AnalysisCancelledError("cutter_command", {
+                    cause: options.signal.reason,
+                }));
             return err(message.includes("generation changed") ||
                 message.includes("unavailable or stale")
                 ? new AnalysisInputError("cutter_command", { cause })

package/dist/doctorRuntime.js

@@ -3,10 +3,13 @@ import { fileURLToPath } from "node:url";
 import { inspectJadxProvider } from "./android/JadxDoctor.js";
 import { inspectSystemGhidraProvider } from "./ghidra/GhidraDoctor.js";
 import { inspectIdaRegistration } from "./ida/IdaDoctor.js";
+import { inspectKunaProvider } from "./kuna/KunaDoctor.js";
+import { readIdaConfiguration } from "./ida/IdaConfiguration.js";
 import { parseJebMcpEndpoint } from "./jeb/JebMcpEndpoint.js";
 import { selectLinuxPrivateDisplayStrategy } from "./hopper/LinuxPrivateDisplayProbe.js";
+import { ok } from "./domain/result.js";
 /** Compose provider diagnostics at the outer CLI adapter boundary. */
-export const createSystemDoctorHost = (environment = process.env) => {
+export const createSystemDoctorHost = (environment = process.env, signal) => {
     const selectedJebEndpoint = environment.REA_JEB_MCP_URL;
     const selectedJebRegistrationEnvironment = selectedJebEndpoint !== undefined &&
         selectedJebEndpoint.length > 0 &&
@@ -15,11 +18,29 @@ export const createSystemDoctorHost = (environment = process.env) => {
         : {};
     return systemDoctorHost({
         environment,
+        ...(signal === undefined ? {} : { signal }),
         providerRegistrationEnvironment: () => selectedJebRegistrationEnvironment,
-        providerInspections: async () => [
-            await inspectSystemGhidraProvider(environment),
+        resolveProviderRequestBudget: (analysisProvider, registrationEnvironment) => {
+            if (analysisProvider !== "ida" && analysisProvider !== "auto")
+                return ok(undefined);
+            const path = registrationEnvironment.REA_IDA_MCP_CONFIG;
+            if (path === undefined)
+                return ok(undefined);
+            const registration = readIdaConfiguration(path);
+            if (registration.ok)
+                return ok(registration.value.timeoutMs);
+            // An invalid IDA registration cannot be selected automatically. Keep it
+            // out of recommendations for another available provider, but surface the
+            // parser-owned error when IDA itself was explicitly selected.
+            return analysisProvider === "ida" ? registration : ok(undefined);
+        },
+        providerInspections: async (fileCloseResources, inspectionSignal) => [
+            await inspectSystemGhidraProvider(environment, fileCloseResources, inspectionSignal),
             inspectIdaRegistration(environment.REA_IDA_MCP_CONFIG),
-            await inspectJadxProvider(environment),
+            await inspectJadxProvider(environment, fileCloseResources, inspectionSignal),
+            await inspectKunaProvider(environment, process.platform, {
+                fileCloseResources,
+            }),
         ],
         linuxDemoRuntimeCheck: () => inspectLinuxPrivateDisplay(environment),
     });

package/dist/domain/adb/adbDeviceAnalysis.js

@@ -355,6 +355,17 @@ const pullFailure = z.strictObject({
     stage: z.enum(["resolve_paths", "pull", "digest"]),
     message: z.string().min(1),
 });
+/** Display ownership and source declarations, including unknown identities. */
+export const adbWindowFocusContextSchema = z.strictObject({
+    scope: z.enum(["display", "unscoped"]),
+    display_id: z.string().nullable(),
+    header_line: z.string().nullable(),
+    declarations: z.array(z.strictObject({
+        field: z.enum(["mCurrentFocus", "mFocusedApp"]),
+        value: z.string().nullable(),
+        raw_line: z.string().min(1),
+    })),
+});
 /** Portable ADB observations with explicit identity and coverage limitations. */
 export const adbResultSchemas = {
     inspect_adb_client: z.strictObject({
@@ -417,7 +428,11 @@ export const adbResultSchemas = {
         serial: z.string().min(1),
         package_name: packageNameSchema,
         version_name: z.string().nullable(),
-        version_code: z.number().int().nullable(),
+        version_code: z
+            .string()
+            .regex(/^-?\d+$/u)
+            .nullable()
+            .describe("Long version code exactly as dumpsys package prints it; may exceed the JSON safe-integer range"),
         first_install_time: z.string().nullable(),
         last_update_time: z.string().nullable(),
         installer_package_name: z.string().nullable(),
@@ -528,6 +543,9 @@ export const adbResultSchemas = {
     inspect_adb_window: z.strictObject({
         client,
         serial: z.string().min(1),
+        source_section: z.enum(["windows", "displays"]),
+        focus_contexts: z.array(adbWindowFocusContextSchema),
+        focus_summary: z.enum(["single_context", "ambiguous", "unavailable"]),
         focused_window: z.string().nullable(),
         focused_app: z.string().nullable(),
         observed_lines: z.array(z.string().min(1)),