rea-agents 2.5.0 → 3.0.0

package/dist/application/AnalysisContextQueries.js

@@ -0,0 +1,130 @@
+import { AnalysisOutputError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+const parameters = (document, address) => ({
+    ...(document === undefined ? {} : { document }),
+    ...(address === undefined ? {} : { address }),
+});
+const executionOptions = (signal) => signal === undefined ? {} : { signal };
+/** Compose the provider's volatile selection state into one coherent query. */
+export const getNavigationContext = async (analysis, input, signal) => {
+    const document = input.document ??
+        (await analysis.execute("current_document", {}, executionOptions(signal)));
+    if (typeof document !== "string" && !document.ok)
+        return document;
+    const documentName = typeof document === "string" ? document : document.value.result;
+    const documentArgs = typeof documentName === "string" ? parameters(documentName) : {};
+    const address = await analysis.execute("current_address", documentArgs, executionOptions(signal));
+    if (!address.ok)
+        return address;
+    if (typeof address.value.result !== "string")
+        return ok({
+            document: documentName,
+            address: address.value.result,
+            procedure: null,
+        });
+    const procedure = await analysis.execute("resolve_containing_procedure", parameters(typeof documentName === "string" ? documentName : undefined, address.value.result), executionOptions(signal));
+    if (!procedure.ok) {
+        if (!isMissingCurrentProcedure(procedure.error))
+            return procedure;
+        return ok({
+            document: documentName,
+            address: address.value.result,
+            procedure: null,
+        });
+    }
+    return ok({
+        document: documentName,
+        address: address.value.result,
+        procedure: containingProcedureName(procedure.value.result),
+    });
+};
+/** Inspect bounded provider-neutral facets at one explicit reproducible address. */
+export const inspectAddressContext = async (analysis, input, signal) => {
+    const document = await resolveDocument(analysis, input.document, signal);
+    if (!document.ok)
+        return document;
+    const args = parameters(document.value, input.address);
+    const operations = [
+        "address_name",
+        "resolve_containing_procedure",
+        "comment",
+        "inline_comment",
+        "list_bookmarks",
+    ];
+    const results = await Promise.all(operations.map((operation) => analysis.execute(operation, operation === "list_bookmarks" ? parameters(document.value) : args, executionOptions(signal))));
+    for (const result of results) {
+        if (!result.ok && isRequestLevelFailure(result.error))
+            return result;
+    }
+    const name = facet(results[0], operations[0]);
+    const procedure = facet(results[1], operations[1]);
+    const comment = facet(results[2], operations[2]);
+    const inlineComment = facet(results[3], operations[3]);
+    const bookmarks = facet(results[4], operations[4]);
+    return ok({
+        address: input.address,
+        document: document.value,
+        name,
+        procedure,
+        comment,
+        inline_comment: inlineComment,
+        bookmarks: bookmarks.state === "available"
+            ? {
+                state: "available",
+                value: matchingBookmarks(bookmarks.value, resolvedAddress(results[1], input.address)),
+            }
+            : bookmarks,
+    });
+};
+const resolveDocument = async (analysis, document, signal) => {
+    if (document !== undefined)
+        return ok(document);
+    const current = await analysis.execute("current_document", {}, executionOptions(signal));
+    if (!current.ok)
+        return current;
+    return typeof current.value.result === "string"
+        ? ok(current.value.result)
+        : err(new AnalysisOutputError("current_document", "expected a document identity string"));
+};
+const facet = (result, operation) => result?.ok === true
+    ? { state: "available", value: result.value.result }
+    : {
+        state: "unavailable",
+        reason: result?.error.message ?? `${operation} returned no result`,
+        remediation: `Call ${operation} directly to inspect provider availability and diagnostics.`,
+    };
+const isMissingCurrentProcedure = (error) => /(?:no procedure exists|not in a procedure)/iu.test(error.message);
+const isRequestLevelFailure = (error) => error._tag === "AnalysisCancelledError" ||
+    error._tag === "AnalysisTimeoutError" ||
+    error._tag === "NoBinaryOpenError" ||
+    error._tag === "PermissionRequiredError";
+const containingProcedureName = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    if (value.found !== true)
+        return null;
+    const procedure = value.procedure;
+    if (typeof procedure !== "object" ||
+        procedure === null ||
+        Array.isArray(procedure))
+        return null;
+    return typeof procedure.name === "string" ? procedure.name : null;
+};
+const resolvedAddress = (result, fallback) => {
+    if (result?.ok !== true)
+        return fallback;
+    const value = result.value.result;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return fallback;
+    return typeof value.query_address === "string"
+        ? value.query_address
+        : fallback;
+};
+const matchingBookmarks = (value, address) => {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((bookmark) => typeof bookmark === "object" &&
+        bookmark !== null &&
+        !Array.isArray(bookmark) &&
+        bookmark.address === address);
+};

package/dist/application/AnalysisSnapshotCache.js

@@ -1,7 +1,7 @@
 import { EvidenceIntegrityError, NoBinaryOpenError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisQueryId, createAnalysisSnapshotEntry, snapshotBinding, snapshotMatchesProfile, snapshotMatchesTarget, snapshotTarget, } from "../domain/analysisSnapshot.js";
-import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 const STATEFUL_OPERATIONS = new Set([
     "health",
     "current_address",
@@ -19,7 +19,9 @@ const CURSOR_DEFAULT_OPERATIONS = new Set([
     "prev_address",
     "xrefs",
 ]);
-const DOCUMENT_SCOPED_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name).filter((name) => name !== "current_document" &&
+const DOCUMENT_SCOPED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy")
+    .map(({ name }) => name)
+    .filter((name) => name !== "current_document" &&
     name !== "list_documents" &&
     name !== "set_current_document"));
 /** Whether an operation is immutable and independent of provider UI state. */

package/dist/application/ArtifactInventory/scanCanonical.js

@@ -12,7 +12,7 @@ export const scanCanonicalArtifactInventory = async (path, limits, options = {})
     const integrity = options.integrity ?? STRICT_INTEGRITY_POLICY;
     if (integrity.mode === "record-and-continue" &&
         (!integrity.approved || !integrity.enabled))
-        throw new ArtifactReaderFailure("unavailable", "Integrity continuation requires explicit approval and operator policy");
+        throw new ArtifactReaderFailure("policy", "Integrity continuation requires explicit approval and operator policy");
     const metadata = await lstat(path);
     const rootFormat = await classifyRoot(path, metadata.isDirectory());
     const rootDigest = metadata.isDirectory()

package/dist/application/BinarySession.js

@@ -2,15 +2,15 @@ import { randomUUID } from "node:crypto";
 import { analysisProfilesEqual, } from "../domain/analysisProfile.js";
 import { AnalysisCancelledError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { enhancedToolNameSchema } from "../contracts/enhancedInputs.js";
-import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { SessionProviderRouter, } from "./SessionProviderRouter.js";
 import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, } from "./BinarySessionOpen.js";
 import { prepareSessionExecution } from "./BinarySessionExecution.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
-const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
+const OFFICIAL_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy").map(({ name }) => name));
+const ENHANCED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "enhanced").map(({ name }) => name));
 /**
  * Owns the single active target shared by CLI and MCP adapters.
  *
@@ -42,7 +42,7 @@ export class BinarySession extends BinarySessionRecords {
             const exact = route.capabilities?.get(operation)?.provider;
             if (exact !== undefined)
                 selected = exact;
-            else if (enhancedToolNameSchema.safeParse(operation).success) {
+            else if (ENHANCED_OPERATIONS.has(operation)) {
                 const providers = new Map();
                 for (const descriptor of route.capabilities?.values() ?? [])
                     if (descriptor.available &&
@@ -112,6 +112,7 @@ export class BinarySession extends BinarySessionRecords {
                     if (!imported.ok)
                         return imported;
                 }
+                this.resetSnapshotInvalidation();
                 return ok(target);
             }
             await this.#drainCalls();

package/dist/application/BinarySessionComposition.js

@@ -0,0 +1,21 @@
+import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
+import { BinarySession } from "./BinarySession.js";
+import { SessionProviderRouter } from "./SessionProviderRouter.js";
+const normalizeBinarySessionOptions = (optionsOrResolver) => typeof optionsOrResolver === "function"
+    ? { resolveAnalysisProfile: optionsOrResolver }
+    : (optionsOrResolver ?? {});
+/**
+ * Compose one provider-neutral session from deep-provider selection and
+ * disjoint auxiliary operation families.
+ */
+export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(registry instanceof SessionProviderRouter
+    ? registry
+    : SessionProviderRouter.selectable(registry, auxiliaryProviders));
+/**
+ * Compose a session through the same internal seam for focused adapter tests.
+ * The constructor remains private to this composition module, so callers test
+ * provider behavior without coupling to BinarySession construction.
+ */
+export const composeBinarySessionFromFactory = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));
+/** Compose a focused session from any provider-shaped test seam. */
+export const composeBinarySessionFromProvider = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));

package/dist/application/BinarySessionRecords.js

@@ -1,24 +1,37 @@
 import { createEvidence } from "../domain/evidence.js";
-import { evidenceBundleForTarget } from "../domain/evidenceBundle.js";
-import { EvidenceIntegrityError, } from "../domain/errors.js";
+import { evidenceBundleForTarget, serializeEvidenceBundle, } from "../domain/evidenceBundle.js";
+import { EvidenceIntegrityError, EvidenceLimitError, } from "../domain/errors.js";
 import { parseInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
 import { parseReconstructionCoverageWorkspace, } from "../domain/reconstructionCoverage.js";
-import { err } from "../domain/result.js";
+import { err, ok } from "../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
 import { EvidenceLedger } from "./EvidenceLedger.js";
 import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
 /** Owns session evidence, snapshots, workspaces, and residual unknowns. */
 export class BinarySessionRecords {
+    static MAX_RETAINED_BUNDLES = 16;
+    static MAX_RETAINED_BUNDLE_BYTES = 64 * 1024 * 1024;
     #evidence = new EvidenceLedger({
         maxRecords: 10_000,
         maxBytes: 64 * 1024 * 1024,
     });
     #snapshot = new AnalysisSnapshotCache();
+    #retainedBundles = new Map();
+    #retainedBundleBytes = 0;
     #investigationWorkspaces = new Map();
     #coverageWorkspaces = new Map();
     #snapshotInvalidated = false;
+    #snapshotListeners = new Set();
+    /** Observe changes to the mutable current analysis snapshot resource. */
+    onAnalysisSnapshotChanged(listener) {
+        this.#snapshotListeners.add(listener);
+        return () => this.#snapshotListeners.delete(listener);
+    }
     recordEvidence(evidence) {
-        return this.#evidence.record(evidence);
+        const recorded = this.#evidence.record(evidence);
+        if (recorded.ok && recorded.value === "added")
+            this.#emitSnapshotChanged();
+        return recorded;
     }
     hasEvidence(evidenceId) {
         return this.#evidence.has(evidenceId);
@@ -29,8 +42,38 @@ export class BinarySessionRecords {
     exportEvidenceBundle() {
         return this.#evidence.export();
     }
+    snapshotEvidenceBundle() {
+        const bundle = this.#evidence.export();
+        const encoded = serializeEvidenceBundle(bundle);
+        const digest = createHash("sha256").update(encoded).digest("hex");
+        const existing = this.#retainedBundles.get(digest);
+        if (existing === undefined) {
+            if (this.#retainedBundles.size >= BinarySessionRecords.MAX_RETAINED_BUNDLES)
+                return err(new EvidenceLimitError("records", BinarySessionRecords.MAX_RETAINED_BUNDLES));
+            const bytes = Buffer.byteLength(encoded);
+            if (this.#retainedBundleBytes + bytes >
+                BinarySessionRecords.MAX_RETAINED_BUNDLE_BYTES)
+                return err(new EvidenceLimitError("bytes", BinarySessionRecords.MAX_RETAINED_BUNDLE_BYTES));
+            this.#retainedBundles.set(digest, encoded);
+            this.#retainedBundleBytes += bytes;
+        }
+        return ok({
+            bundleDigest: digest,
+            bundleVersion: 2,
+            bytes: Buffer.byteLength(existing ?? encoded),
+            records: bundle.records.length,
+            unknowns: bundle.unknowns.length,
+            uri: `rea://evidence-bundle/${digest}`,
+        });
+    }
+    retainedEvidenceBundle(digest) {
+        return this.#retainedBundles.get(digest);
+    }
     importEvidenceBundle(bundle) {
-        return this.#evidence.import(bundle);
+        const imported = this.#evidence.import(bundle);
+        if (imported.ok && imported.value > 0)
+            this.#emitSnapshotChanged();
+        return imported;
     }
     exportAnalysisSnapshot() {
         const active = this.activeAnalysisBinding();
@@ -48,36 +91,53 @@ export class BinarySessionRecords {
         const active = this.activeAnalysisBinding();
         if (active?.profile === null)
             return err(new EvidenceIntegrityError("Analysis snapshot profile_mismatch: the active target has no concrete analysis profile"));
-        return this.#snapshot.import(snapshot, active === undefined
+        const imported = this.#snapshot.import(snapshot, active === undefined
             ? undefined
             : { target: active.target, profile: active.profile }, (bundle) => this.#evidence.import(bundle));
+        if (imported.ok)
+            this.#emitSnapshotChanged();
+        return imported;
     }
     matchesSnapshot(target, profile) {
         return this.#snapshot.matches(target, profile ?? undefined);
     }
     selectSnapshot(target, profile) {
         this.#snapshot.select(target, profile);
+        this.#emitSnapshotChanged();
     }
     lookupSnapshot(target, profile, operation, parameters) {
         return this.#snapshot.lookup(target, profile, operation, parameters);
     }
     recordSnapshot(input) {
         this.#snapshot.record(input);
+        this.#emitSnapshotChanged();
     }
     invalidateSnapshot() {
         this.#snapshot.clear();
         this.#snapshotInvalidated = true;
+        this.#emitSnapshotChanged();
     }
     resetSnapshotInvalidation() {
+        if (!this.#snapshotInvalidated)
+            return;
         this.#snapshotInvalidated = false;
+        this.#emitSnapshotChanged();
     }
     clearSnapshot() {
         this.#snapshot.clear();
+        this.#emitSnapshotChanged();
     }
     clearSessionRecords() {
         this.#evidence.clear();
         this.#snapshot.clear();
         this.#snapshotInvalidated = false;
+        this.#retainedBundles.clear();
+        this.#retainedBundleBytes = 0;
+        this.#emitSnapshotChanged();
+    }
+    #emitSnapshotChanged() {
+        for (const listener of this.#snapshotListeners)
+            void listener();
     }
     retainInvestigationWorkspace(workspace) {
         const parsed = parseInvestigationWorkspace(workspace);
@@ -111,10 +171,16 @@ export class BinarySessionRecords {
     }
     recordUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
-        return this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
+        const recorded = this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
+        if (recorded.ok)
+            this.#emitSnapshotChanged();
+        return recorded;
     }
     recordEvidenceWithUnknown(evidence, input) {
-        return this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, input));
+        const recorded = this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, input));
+        if (recorded.ok)
+            this.#emitSnapshotChanged();
+        return recorded;
     }
     updateUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
@@ -133,7 +199,10 @@ export class BinarySessionRecords {
                 "Registry mutation evidence records analyst intent, not proof of the answer.",
             ],
         });
-        return this.#evidence.updateUnknown(input, evidence);
+        const updated = this.#evidence.updateUnknown(input, evidence);
+        if (updated.ok)
+            this.#emitSnapshotChanged();
+        return updated;
     }
     listUnknowns(filters = {}) {
         return this.#evidence.listUnknowns(filters);
@@ -147,3 +216,4 @@ const sortedWorkspaces = (workspaces) => [...workspaces]
     .sort((left, right) => left.workspace_id.localeCompare(right.workspace_id) ||
     left.revision - right.revision)
     .map((workspace) => structuredClone(workspace));
+import { createHash } from "node:crypto";

package/dist/application/CapabilityInventory.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 const statusSchema = z.object({
     open: z.boolean(),
     kind: z.enum(["executable", "database", "archive", "artifact"]).optional(),
@@ -38,6 +38,7 @@ const ENHANCED_REQUIREMENTS = {
         "list_strings",
     ],
     analyze_function: ["analyze_function"],
+    inspect_native_api: ["analyze_function"],
     trace_feature: [
         "list_strings",
         "list_procedures",
@@ -45,6 +46,13 @@ const ENHANCED_REQUIREMENTS = {
         "resolve_containing_procedure",
     ],
 };
+const SESSION_COMPOSITION_REQUIREMENTS = {
+    get_navigation_context: [
+        "current_document",
+        "current_address",
+        "resolve_containing_procedure",
+    ],
+};
 /** Build stable per-operation availability for discovery and tool visibility. */
 export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures = NO_CLIENT_FEATURES) => {
     const status = statusSchema.parse(sessionStatus);
@@ -56,7 +64,7 @@ export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures =
             availability_code: descriptor.availability_code ?? null,
         },
     ]));
-    return TOOL_CONTRACTS.map((contract) => {
+    return GENERATED_MCP_TOOL_CATALOG.map((contract) => {
         const availability = availabilityFor({
             name: contract.name,
             kind: contract.kind,
@@ -101,6 +109,9 @@ const clientRequirementsFor = (name, clientFeatures) => {
     };
 };
 const availabilityFor = (context) => {
+    const sessionComposition = SESSION_COMPOSITION_REQUIREMENTS[context.name];
+    if (sessionComposition !== undefined)
+        return composedAvailabilityFor(sessionComposition, context.descriptors);
     const javascriptApplication = javascriptApplicationAvailability(context);
     if (javascriptApplication !== null)
         return javascriptApplication;
@@ -240,6 +251,9 @@ const composedAvailability = (name, descriptors) => {
             reason: "provider_missing",
             remediation: "No provider composition is declared for this operation.",
         };
+    return composedAvailabilityFor(requirements, descriptors);
+};
+const composedAvailabilityFor = (requirements, descriptors) => {
     const missing = requirements.find((operation) => !descriptors.has(operation));
     if (missing !== undefined)
         return {

package/dist/application/ClientRegistrationStatus.js

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
+import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
 import { supportedClients } from "./SupportedClients.js";
 const objectSchema = z.record(z.string(), z.unknown());
 const registrationSchema = z
@@ -41,7 +42,9 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
 };
 const registrationAligned = (registration, client, currentCommandPath) => {
     const command = [registration.command, ...registration.args];
-    if (client === "codex" && registration.startup_timeout_sec !== 30)
+    if (client === "codex" &&
+        registration.startup_timeout_sec !==
+            MCP_STARTUP_POLICY.codexStartupTimeoutSeconds)
         return false;
     if (command.length === 4 &&
         command[0] === "npx" &&

package/dist/application/DirectAnalysis.js

@@ -182,6 +182,7 @@ const executeAnalysisTool = async (input) => {
     const { session, tool, signal, evidenceProfile } = input;
     if (tool === "binary_overview" ||
         tool === "analyze_function" ||
+        tool === "inspect_native_api" ||
         tool === "trace_feature") {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
@@ -247,15 +248,18 @@ const prepareSnapshot = async (options) => {
         return err(new EvidenceIntegrityError("Analysis snapshot target does not match the requested binary"));
     return ok({ snapshot: loaded.value });
 };
-const replayProviderFor = (session, tool) => tool === "binary_overview" || tool === "trace_feature"
+const replayProviderFor = (session, tool) => isWorkflowEvidenceTool(tool)
     ? REA_WORKFLOW_PROVIDER
     : session.providerIdentity(tool);
 const analysisProfileForEvidence = (session, tool) => {
-    if (tool !== "binary_overview" && tool !== "trace_feature")
+    if (!isWorkflowEvidenceTool(tool))
         return session.analysisProfile(tool);
     const upstream = session.analysisProfile();
     return upstream === undefined ? undefined : workflowAnalysisProfile(upstream);
 };
+const isWorkflowEvidenceTool = (tool) => tool === "binary_overview" ||
+    tool === "inspect_native_api" ||
+    tool === "trace_feature";
 const fileExists = async (path) => {
     try {
         await access(path);

package/dist/application/EnhancedTools.js

@@ -1,12 +1,14 @@
 import { enhancedInputSchemas } from "../contracts/enhancedInputs.js";
 import { AnalysisCancelledError, AnalysisOutputError, projectAnalysisError, } from "../domain/errors.js";
-import { addressDistance, parseDocuments, parseFunctionDossier, parseListCount, parseRelatedAddresses, parseSegments, } from "../domain/hopperValues.js";
+import { addressDistance, functionDossierSchema, parseDocuments, parseFunctionDossier, parseListCount, parseRelatedAddresses, parseSegments, } from "../domain/hopperValues.js";
 import { err, ok } from "../domain/result.js";
 import { categorizeSwiftTypes, discoverObjcClasses, discoverObjcProtocols, discoverSwiftClasses, } from "../domain/symbolAnalysis.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
 import { invalidEnhancedInput, } from "./EnhancedToolTypes.js";
 import { readAllAddressed } from "./EnhancedToolPagination.js";
 import { traceCallPath } from "./CallPathTracing.js";
 import { traceLiteralFeature } from "./EnhancedLiteralTracing.js";
+import { projectNativeApiInspection } from "./NativeApiInspection.js";
 /**
  * Composes direct provider operations into bounded reverse-engineering tools.
  * Direct callers use `execute`; adapters that own validation use
@@ -23,6 +25,8 @@ export class EnhancedTools {
             name === "find_code_for_string" ||
             name === "trace_call_path")
             return this.#executeTracing(name, input, signal);
+        if (name === "analyze_function" || name === "inspect_native_api")
+            return this.#executeFunctionAnalysis(name, input, signal);
         switch (name) {
             case "swift_classes": {
                 const parsed = enhancedInputSchemas.swift_classes.safeParse(input);
@@ -64,12 +68,6 @@ export class EnhancedTools {
                     ? this.executeValidated({ name, input: parsed.data }, signal)
                     : invalidEnhancedInput(name, parsed.error);
             }
-            case "analyze_function": {
-                const parsed = enhancedInputSchemas.analyze_function.safeParse(input);
-                return parsed.success
-                    ? this.executeValidated({ name, input: parsed.data }, signal)
-                    : invalidEnhancedInput(name, parsed.error);
-            }
         }
     }
     /** Dispatch input already parsed by a trusted adapter boundary. */
@@ -93,6 +91,8 @@ export class EnhancedTools {
                 return this.#binaryOverview(call.input, signal);
             case "analyze_function":
                 return this.#analyzeFunction(call.input, signal);
+            case "inspect_native_api":
+                return this.#inspectNativeApi(call.input, signal);
             case "trace_feature":
                 return traceLiteralFeature((name, arguments_, operationSignal) => this.#call(name, arguments_, operationSignal), call.input, "feature", signal);
             case "find_code_for_string":
@@ -115,10 +115,40 @@ export class EnhancedTools {
             input: enhancedInputSchemas[name].parse(parsed.data),
         }, signal);
     }
+    #executeFunctionAnalysis(name, input, signal) {
+        const parsed = enhancedInputSchemas[name].safeParse(input);
+        if (!parsed.success)
+            return invalidEnhancedInput(name, parsed.error);
+        if (name === "analyze_function")
+            return this.executeValidated({
+                name,
+                input: enhancedInputSchemas.analyze_function.parse(parsed.data),
+            }, signal);
+        return this.executeValidated({
+            name,
+            input: enhancedInputSchemas.inspect_native_api.parse(parsed.data),
+        }, signal);
+    }
     async #analyzeFunction(input, signal) {
         const result = await this.#call("analyze_function", input, signal);
         return result.ok ? parseFunctionDossier(result.value) : result;
     }
+    async #inspectNativeApi(input, signal) {
+        const analysisInput = enhancedInputSchemas.analyze_function.parse({
+            procedure: input.procedure,
+            include_assembly: true,
+            max_pseudocode_chars: input.max_pseudocode_chars,
+            max_instructions: input.max_instructions,
+        });
+        const result = await this.#call("analyze_function", analysisInput, signal);
+        if (!result.ok)
+            return result;
+        const parsed = parseFunctionDossier(result.value);
+        if (!parsed.ok)
+            return parsed;
+        const dossier = functionDossierSchema.parse(parsed.value);
+        return ok(jsonValueSchema.parse(projectNativeApiInspection(dossier)));
+    }
     async #swiftClasses(pattern, signal) {
         const procedures = await this.#allAddressed("list_procedures", signal);
         return procedures.ok