rea-agents 4.0.0 → 4.1.0

package/dist/process/ProcessOwnership.js

@@ -1,10 +1,8 @@
 import { execFile } from "node:child_process";
-import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
-import { observeOwnedProcessGroupWithHost, observeOwnedProcessLineageWithHost, } from "./ProcessOwnershipObservation.js";
+import { createSystemProcessOwnershipHost, errorMessage, } from "./ProcessOwnershipObservation.js";
 import { launcherIdentityFailure } from "./ProcessOwnershipIdentity.js";
 import { descendantsOf, liveProcesses } from "./ProcessOwnershipProcessTree.js";
-import { execFileOutput } from "./ExecFileOutput.js";
 const execFileAsync = promisify(execFile);
 /**
  * Terminate one Windows process tree through the platform utility.
@@ -20,71 +18,16 @@ export const cleanupWindowsProcessTree = async (rootPid, host = systemWindowsPro
         const result = await host.terminateTree(rootPid);
         return { cleaned: true, signaled: result === "terminated" };
     }
-    catch {
+    catch (cause) {
+        // The reason string is a pinned validation contract; keep it stable and
+        // do not interpolate the cause into caller-visible diagnostics here.
+        void cause;
         return {
             cleaned: false,
             reason: "Windows P0 process-tree termination failed; Job Object ownership is unavailable",
         };
     }
 };
-/** Select the PTY root group and groups led by an observed captured process. */
-export const selectCapturedProcessGroupIds = (rootPid, samples) => {
-    const processGroupIds = new Set([rootPid]);
-    for (const sample of samples) {
-        // A sampled member may transiently inherit an unrelated group. POSIX group
-        // leaders have pid === pgid, so only that observation establishes that the
-        // group leader itself belonged to the captured tree. Token checks below
-        // remain the final authority immediately before observation or signaling.
-        if (sample.pid === sample.process_group_id)
-            processGroupIds.add(sample.pid);
-    }
-    return [...processGroupIds];
-};
-/** Parse the NUL-delimited Linux process environment without nameless keys. */
-export const parseProcessEnvironment = (value) => Object.fromEntries(value
-    .split("\0")
-    .filter((entry) => entry.indexOf("=") > 0)
-    .map((entry) => {
-    const separator = entry.indexOf("=");
-    return [entry.slice(0, separator), entry.slice(separator + 1)];
-}));
-/** Create the operating-system process inspector for an explicit host context. */
-export const createSystemProcessOwnershipHost = (platform = process.platform, hostEnvironment = process.env) => ({
-    platform,
-    async listProcesses() {
-        if (platform === "win32")
-            return [];
-        const { stdout } = await execFileOutput("ps", ["-axo", "pid=,ppid=,pgid=,stat=,command="], { env: hostEnvironment });
-        return stdout
-            .split("\n")
-            .map((line) => /\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)/u.exec(line))
-            .filter((match) => match !== null)
-            .map((match) => ({
-            pid: Number(match[1]),
-            parentPid: Number(match[2]),
-            processGroupId: Number(match[3]),
-            state: match[4] ?? "",
-            command: match[5] ?? "",
-        }));
-    },
-    async environment(pid) {
-        if (platform === "linux")
-            return parseProcessEnvironment(await readFile(`/proc/${pid}/environ`, "utf8"));
-        const { stdout } = await execFileOutput("ps", ["eww", "-p", String(pid)], {
-            env: hostEnvironment,
-        });
-        const observedEnvironment = {};
-        for (const match of stdout.matchAll(/(?:^|\s)([A-Za-z_][A-Za-z0-9_]*)=([^\s]*)/gu)) {
-            const name = match[1];
-            if (name !== undefined)
-                observedEnvironment[name] = match[2] ?? "";
-        }
-        return observedEnvironment;
-    },
-    signalGroup(processGroupId, signal) {
-        process.kill(-processGroupId, signal);
-    },
-});
 const systemHost = createSystemProcessOwnershipHost();
 const systemWindowsProcessTreeHost = {
     async terminateTree(rootPid) {
@@ -309,14 +252,3 @@ const scanTokenOwnedProcesses = async (processes, runId, host) => {
     }
     return { owned, failures };
 };
-const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
-/** Observe one group without signaling it, failing closed on identity doubt. */
-export const observeOwnedProcessGroup = async (ownership, host = systemHost) => observeOwnedProcessGroupWithHost(ownership, host);
-/**
- * Record the live launcher and descendant lineage after run-token validation.
- *
- * The observation is intentionally point-in-time. A verified empty descendant
- * list means no descendants were live during this observation, not that the
- * run never created a short-lived child.
- */
-export const observeOwnedProcessLineage = async (ownership, host = systemHost) => observeOwnedProcessLineageWithHost(ownership, host);

package/dist/process/ProcessOwnershipObservation.js

@@ -1,5 +1,7 @@
+import { readFile } from "node:fs/promises";
 import { launcherIdentityFailure } from "./ProcessOwnershipIdentity.js";
 import { descendantsOf, liveProcesses } from "./ProcessOwnershipProcessTree.js";
+import { execFileOutput } from "./ExecFileOutput.js";
 /** Observe one group without signaling it, failing closed on identity doubt. */
 export const observeOwnedProcessGroupWithHost = async (ownership, host) => {
     let members;
@@ -95,12 +97,70 @@ const unavailableLineage = (ownership, reason) => ({
     processGroupId: ownership.processGroupId,
     reason,
 });
+/** Parse the NUL-delimited Linux process environment without nameless keys. */
+export const parseProcessEnvironment = (value) => Object.fromEntries(value
+    .split("\0")
+    .filter((entry) => entry.indexOf("=") > 0)
+    .map((entry) => {
+    const separator = entry.indexOf("=");
+    return [entry.slice(0, separator), entry.slice(separator + 1)];
+}));
+/** Create the operating-system process inspector for an explicit host context. */
+export const createSystemProcessOwnershipHost = (platform = process.platform, hostEnvironment = process.env) => ({
+    platform,
+    async listProcesses() {
+        if (platform === "win32")
+            return [];
+        const { stdout } = await execFileOutput("ps", ["-axo", "pid=,ppid=,pgid=,stat=,command="], { env: hostEnvironment });
+        return stdout
+            .split("\n")
+            .map((line) => /\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)/u.exec(line))
+            .filter((match) => match !== null)
+            .map((match) => ({
+            pid: Number(match[1]),
+            parentPid: Number(match[2]),
+            processGroupId: Number(match[3]),
+            state: match[4] ?? "",
+            command: match[5] ?? "",
+        }));
+    },
+    async environment(pid) {
+        if (platform === "linux")
+            return parseProcessEnvironment(await readFile(`/proc/${pid}/environ`, "utf8"));
+        const { stdout } = await execFileOutput("ps", ["eww", "-p", String(pid)], {
+            env: hostEnvironment,
+        });
+        const observedEnvironment = {};
+        for (const match of stdout.matchAll(/(?:^|\s)([A-Za-z_][A-Za-z0-9_]*)=([^\s]*)/gu)) {
+            const name = match[1];
+            if (name !== undefined)
+                observedEnvironment[name] = match[2] ?? "";
+        }
+        return observedEnvironment;
+    },
+    signalGroup(processGroupId, signal) {
+        process.kill(-processGroupId, signal);
+    },
+});
+const systemHost = createSystemProcessOwnershipHost();
+/** Observe one group without signaling it, failing closed on identity doubt. */
+export const observeOwnedProcessGroup = async (ownership, host = systemHost) => observeOwnedProcessGroupWithHost(ownership, host);
+/**
+ * Record the live launcher and descendant lineage after run-token validation.
+ *
+ * The observation is intentionally point-in-time. A verified empty descendant
+ * list means no descendants were live during this observation, not that the
+ * run never created a short-lived child.
+ */
+export const observeOwnedProcessLineage = async (ownership, host = systemHost) => observeOwnedProcessLineageWithHost(ownership, host);
 const processIsGone = async (host, pid) => {
     try {
         return !liveProcesses(await host.listProcesses()).some((process) => process.pid === pid);
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional liveness probing; failure means not gone.
+        void cause;
         return false;
     }
 };
-const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+export const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);

package/dist/process/ProcessOwnershipProcessTree.js

@@ -20,3 +20,16 @@ export const descendantsOf = (launcherPid, processes) => {
     }
     return descendants;
 };
+/** Select the PTY root group and groups led by an observed captured process. */
+export const selectCapturedProcessGroupIds = (rootPid, samples) => {
+    const processGroupIds = new Set([rootPid]);
+    for (const sample of samples) {
+        // A sampled member may transiently inherit an unrelated group. POSIX group
+        // leaders have pid === pgid, so only that observation establishes that the
+        // group leader itself belonged to the captured tree. Token checks below
+        // remain the final authority immediately before observation or signaling.
+        if (sample.pid === sample.process_group_id)
+            processGroupIds.add(sample.pid);
+    }
+    return [...processGroupIds];
+};

package/dist/process/ProviderProcess.js

@@ -1,8 +1,9 @@
 import { spawn } from "node:child_process";
+import { WindowsOwnedProcess } from "../windows/WindowsOwnedProcess.js";
 const DEFAULT_TERMINATION_GRACE_MS = 250;
 const DEFAULT_KILL_GRACE_MS = 1_000;
 /**
- * Spawn a provider in a dedicated POSIX process group with an ownership token.
+ * Spawn a provider in an owned Windows job or dedicated POSIX process group.
  *
  * The caller remains responsible for persisting any ownership manifest and for
  * selecting provider-specific command arguments or environment values.
@@ -10,17 +11,33 @@ const DEFAULT_KILL_GRACE_MS = 1_000;
 export const spawnOwnedProviderProcess = async (options) => {
     const platform = options.platform ?? process.platform;
     const hostEnvironment = options.hostEnvironment ?? process.env;
+    const environment = {
+        ...hostEnvironment,
+        ...options.env,
+        REA_PROCESS_RUN_ID: options.runId,
+    };
+    if (platform === "win32" && process.platform === "win32") {
+        if (options.stdin === "pipe")
+            throw new Error("Owned Windows provider processes do not support protocol stdin");
+        const child = new WindowsOwnedProcess(options.command, options.arguments, options.cwd, environment, options.windowsVerbatimArguments ?? false);
+        return {
+            process: child,
+            ownership: {
+                runId: options.runId,
+                leaderPid: child.pid,
+                processGroupId: child.pid,
+                expectedParentPid: process.pid,
+            },
+            cleanup: () => child.cleanup(),
+        };
+    }
     const child = spawn(options.command, [...options.arguments], {
         shell: false,
         windowsHide: true,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: [options.stdin ?? "ignore", "pipe", "pipe"],
         detached: platform !== "win32",
         windowsVerbatimArguments: options.windowsVerbatimArguments ?? false,
-        env: {
-            ...hostEnvironment,
-            ...options.env,
-            REA_PROCESS_RUN_ID: options.runId,
-        },
+        env: environment,
         ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
     });
     await waitForSpawn(child);

package/dist/process/ProviderRunLineage.js

@@ -1,4 +1,4 @@
-import { observeOwnedProcessLineage } from "./ProcessOwnership.js";
+import { observeOwnedProcessLineage } from "./ProcessOwnershipObservation.js";
 /** Retain the latest truthful process-lineage observation for one client. */
 export class ProviderRunLineage {
     #observation = null;

package/dist/process/WindowsAuthority.js

@@ -1,5 +1,6 @@
+import { systemWindowsNativeAuthority } from "../windows/WindowsNativeLoader.js";
 /** Stable explanation used whenever the native Windows authority is absent. */
-export const WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON = "Verified Windows native authority is unavailable: Job Object process ownership, private runtime DACL enforcement, and reparse-safe path admission are not implemented; chmod(0700) is insufficient for Windows private DACL proof, and taskkill is not a Job Object security proof";
+export const WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON = "Windows native controls are unavailable in this runtime; use the Windows x64 REA package with its matching bundled native artifact.";
 /**
  * Describe native Windows controls without inferring them from taskkill,
  * chmod, symlink creation, or a numeric POSIX open flag.
@@ -17,6 +18,21 @@ export const windowsNativeCapabilities = (platform) => {
             reparse_safe_path_admission: notApplicable,
         };
     }
+    if (process.platform === "win32") {
+        const loaded = systemWindowsNativeAuthority();
+        const capability = loaded.available
+            ? { available: true, reason: null, proof: "native-authority" }
+            : {
+                available: false,
+                reason: loaded.reason,
+                proof: "not-proven",
+            };
+        return {
+            job_object_process_ownership: capability,
+            private_runtime_dacl: capability,
+            reparse_safe_path_admission: capability,
+        };
+    }
     const notProven = {
         available: false,
         reason: WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON,
@@ -30,3 +46,6 @@ export const windowsNativeCapabilities = (platform) => {
 };
 /** Whether every native control needed for Windows isolation is proven. */
 export const hasWindowsNativeAuthority = (platform) => Object.values(windowsNativeCapabilities(platform)).every(({ available }) => available);
+/** Preserve the actual loader or operating-system constraint in provider errors. */
+export const windowsNativeAuthorityUnavailableReason = (platform) => windowsNativeCapabilities(platform).job_object_process_ownership.reason ??
+    WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON;

package/dist/reference/ReferenceSourceReaderEntries.js

@@ -189,7 +189,11 @@ const applyExclusion = (shouldExclude, path) => {
     try {
         return { ok: true, value: shouldExclude?.(path) === true };
     }
-    catch {
+    catch (cause) {
+        // Exclusion predicates are caller-supplied; a throwing predicate fails
+        // closed and the caller-visible `{ ok: false }` preserves the rejection
+        // without propagating an arbitrary predicate cause.
+        void cause;
         return { ok: false };
     }
 };

package/dist/reference/ReferenceSourceReaderFile.js

@@ -102,6 +102,7 @@ export const readStableFile = async (request) => {
         return entryFailure(path, "file", "io", message, safeSize(expected.size));
     }
     finally {
+        // best-effort cleanup: file-handle close must not mask the read result.
         await handle?.close().catch(() => undefined);
     }
 };

package/dist/server/createServer.js

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/server";
+import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
 import { registerApplicationTools } from "./registerApplicationTools.js";
@@ -9,6 +10,12 @@ 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 { registerAndroidTools } from "./registerAndroidTools.js";
+import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
+import { JadxProvider } from "../android/JadxProvider.js";
 import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
 import { registerNativeTools } from "./registerNativeTools.js";
 import { registerOfficialTools } from "./registerOfficialTools.js";
@@ -22,6 +29,15 @@ const installSessionToolAvailability = (server, session, options) => {
         return undefined;
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
         optionalFeatures: {
+            firmwareInspectionEnabled: options.firmwareAnalysis !== undefined ||
+                (process.platform === "linux" &&
+                    isAbsolute(process.env.REA_BINWALK_COMMAND ?? "")),
+            firmwareExtractionEnabled: options.firmwareAnalysis !== undefined ||
+                (process.platform === "linux" &&
+                    isAbsolute(process.env.REA_UNBLOB_COMMAND ?? "")),
+            androidAnalysisEnabled: options.androidAnalysis !== undefined ||
+                ((process.platform === "linux" || process.platform === "darwin") &&
+                    isAbsolute(process.env.REA_JADX_MCP_JAR ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
@@ -53,18 +69,21 @@ export const createServer = (analysis, session, options = {}) => {
     const server = createMcpServer(session);
     const availability = installSessionToolAvailability(server, session, options);
     const toolLogger = logger.child({ layer: "server" });
-    const { activeTarget, recordEvidence, recordEvidenceWithUnknown } = createSessionRecorders(server, session);
+    const { evidenceById, activeTarget, recordEvidence, recordEvidenceWithUnknown, } = createSessionRecorders(server, session);
     const toolContext = {
         server,
         analysis,
         session,
         options,
         logger: toolLogger,
+        evidenceById,
         activeTarget,
         recordEvidence,
         recordEvidenceWithUnknown,
     };
     registerBinaryAnalysisTools(toolContext);
+    registerAndroidTools(server, new AndroidAnalysisService(options.androidAnalysis ?? new JadxProvider()), toolLogger, recordEvidence);
+    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? new FirmwareProvider()), toolLogger, recordEvidence);
     registerObservationTools(toolContext);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
@@ -79,6 +98,9 @@ export const createServer = (analysis, session, options = {}) => {
     return server;
 };
 const createSessionRecorders = (server, session) => ({
+    evidenceById: session === undefined
+        ? undefined
+        : (evidenceId) => session.evidenceById(evidenceId),
     activeTarget: session === undefined ? undefined : () => session.activeTarget(),
     recordEvidence: session === undefined
         ? undefined
@@ -125,7 +147,7 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
             session,
         });
 };
-const registerObservationTools = ({ server, options, logger, recordEvidence, recordEvidenceWithUnknown, }) => {
+const registerObservationTools = ({ evidenceById, server, options, logger, recordEvidence, recordEvidenceWithUnknown, }) => {
     const common = { logger, recordEvidence };
     registerBrowserTools(server, {
         ...common,
@@ -145,6 +167,7 @@ const registerObservationTools = ({ server, options, logger, recordEvidence, rec
         runtime: options.javascriptRuntimeObservation,
     });
     registerApplicationTools(server, {
+        evidenceById,
         logger,
         recordEvidence,
         recordEvidenceWithUnknown,

package/dist/server/mcpProgress.js

@@ -16,8 +16,9 @@ export const mcpProgressReporter = (context) => {
                 },
             });
         }
-        catch {
+        catch (cause) {
             // Progress is observational; transport failure cannot change tool truth.
+            void cause;
         }
     }, { minimumIntervalMs: 100 });
 };

package/dist/server/promptCompletion.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { uniqueSorted } from "../domain/canonicalOrdering.js";
 import { artifactInventoryResultSchema } from "../domain/artifactGraph.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 import { processCaptureSchema } from "../domain/processCapture.js";
@@ -14,7 +15,8 @@ export const createPromptCompletionSource = (analysis, session) => ({
     async complete(kind, value, context) {
         const candidates = await completionCandidates(kind, analysis, session, context);
         const prefix = normalize(value);
-        return uniqueSorted(candidates).filter((candidate) => normalize(candidate).startsWith(prefix));
+        const nonEmpty = candidates.filter((candidate) => candidate.length > 0);
+        return uniqueSorted(nonEmpty).filter((candidate) => normalize(candidate).startsWith(prefix));
     },
 });
 const completionCandidates = async (kind, analysis, session, context) => {
@@ -121,6 +123,4 @@ const unknownCandidates = (session) => session === undefined
         .listUnknowns()
         .filter(({ status }) => status !== "resolved")
         .map(({ unknown_id: id }) => id);
-const uniqueSorted = (values) => [...new Set(values.filter((value) => value.length > 0))].sort(compareText);
-const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 const normalize = (value) => value.normalize("NFKC").toLowerCase();

package/dist/server/registerAndroidTools.js

@@ -0,0 +1,30 @@
+import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind Android handlers to their exact named contracts through shared workflows. */
+export const registerAndroidTools = (server, service, logger, recordEvidence) => {
+    const handler = (contract) => {
+        const name = contract.name;
+        return async (input, context) => {
+            const result = await logToolExecution(logger, name, () => service.execute(name, input, { signal: context.mcpReq.signal }));
+            if (!result.ok)
+                return toCallToolResult(result, contract);
+            const recorded = recordEvidence?.(result.value);
+            return recorded !== undefined && !recorded.ok
+                ? toCallToolResult(recorded, contract)
+                : toCallToolResult(result, contract);
+        };
+    };
+    const packageContract = toolContract("inspect_android_package");
+    server.registerTool(packageContract.name, toolRegistrationOptions(packageContract), handler(packageContract));
+    const searchContract = toolContract("search_android_classes");
+    server.registerTool(searchContract.name, toolRegistrationOptions(searchContract), handler(searchContract));
+    const classContract = toolContract("inspect_android_class");
+    server.registerTool(classContract.name, toolRegistrationOptions(classContract), handler(classContract));
+    const methodContract = toolContract("inspect_android_method");
+    server.registerTool(methodContract.name, toolRegistrationOptions(methodContract), handler(methodContract));
+    const referencesContract = toolContract("trace_android_references");
+    server.registerTool(referencesContract.name, toolRegistrationOptions(referencesContract), handler(referencesContract));
+};

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,3 +1,4 @@
+import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
@@ -10,7 +11,10 @@ const contract = applicationToolContract("compare_javascript_export_shapes");
 /** Register the execution-free exact JavaScript export-shape comparison. */
 export const registerCompareJavaScriptExportShapesTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsed = input;
+        const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, contract);
+        const parsed = resolved.value;
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareJavaScriptExportShapesEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, contract);

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,3 +1,4 @@
+import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
@@ -10,11 +11,15 @@ const contract = applicationToolContract("compare_source_to_bundle");
 /** Register conservative historical-source to bundle comparison. */
 export const registerCompareSourceToBundleTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(input)));
+        const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, contract);
+        const parsed = resolved.value;
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
-            input.application,
+            parsed.application,
         ]);
         if (!recorded.ok)
             return toCallToolResult(recorded, contract);

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,3 +1,4 @@
+import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
@@ -10,7 +11,10 @@ const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
 export const registerCompareApplicationVersionsTool = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const parsed = input;
+        const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, compareContract);
+        const parsed = resolved.value;
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareApplicationVersionsEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, compareContract);

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,3 +1,4 @@
+import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
@@ -9,10 +10,14 @@ const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
 export const registerTraceFeatureTool = (server, options) => {
     server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
-        const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(input)));
+        const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, traceContract);
+        const parsed = resolved.value;
+        const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, traceContract);
-        const sources = [input.application, ...input.native_observations];
+        const sources = [parsed.application, ...parsed.native_observations];
         const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
             return toCallToolResult(recorded, traceContract);

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -1,3 +1,4 @@
+import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/JavaScriptSemanticTraceService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
@@ -9,11 +10,15 @@ const contract = applicationToolContract("trace_javascript_semantics");
 /** Register the bounded JavaScript semantic relation trace tool. */
 export const registerTraceJavaScriptSemanticsTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(input)));
+        const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
+        if (!resolved.ok)
+            return toCallToolResult(resolved, contract);
+        const parsed = resolved.value;
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
-            input.application,
+            parsed.application,
         ]);
         if (!recorded.ok)
             return toCallToolResult(recorded, contract);

package/dist/server/registerEnhancedTools.js

@@ -1,12 +1,13 @@
 import { EnhancedTools, } from "../application/EnhancedTools.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
 import { toolContract } from "../contracts/toolContracts.js";
-import { UnknownRegistryError } from "../domain/errors.js";
+import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
 import { createEvidence } from "../domain/evidence.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
+import { executeFunctionAnalysisEvidence } from "../application/FunctionAnalysisEvidence.js";
 /** Register composed workflows against the same port as direct bridge tools. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerEnhancedTools = (server, analysis, options) => {
@@ -93,6 +94,11 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
     });
     const parsedInput = validatedCall.input;
     const parameters = jsonParameters(parsedInput);
+    if (name === "analyze_function")
+        return executeFunctionTool(analysis, registration, contract, {
+            context,
+            parameters,
+        });
     const services = new EnhancedTools({
         execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
             ...executionOptions,
@@ -138,6 +144,27 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
     }
     return toCallToolResult(result, contract);
 };
+const executeFunctionTool = async (analysis, registration, contract, request) => {
+    const { context, parameters } = request;
+    const progress = mcpProgressReporter(context);
+    const result = await logToolExecution(registration.logger, "analyze_function", () => executeFunctionAnalysisEvidence(analysis, parameters, registration.activeTarget?.(), {
+        signal: context.mcpReq.signal,
+        progress,
+    }));
+    await progress.report({
+        phase: "analyze_function",
+        completed: 1,
+        total: 1,
+        message: result.ok ? "completed" : "failed",
+        terminal: true,
+    });
+    if (result.ok) {
+        const recorded = registration.recordEvidence?.(result.value);
+        if (recorded !== undefined && !recorded.ok)
+            return toCallToolResult(recorded, contract);
+    }
+    return toCallToolResult(result, contract);
+};
 const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
 const recordWorkflowUnknowns = ({ name, result, evidenceId, recordUnknown, }) => {
     if (!["trace_feature", "trace_call_path", "inspect_native_api"].includes(name) ||