diff --git a/docs/ida-provider.md b/docs/ida-provider.md
index 9f2a2f262a..685d638b9a 100644
--- a/docs/ida-provider.md
+++ b/docs/ida-provider.md
@@ -220,6 +220,12 @@ For guided registration, set `REA_IDA_MCP_CONFIG` before `rea setup --client <cl
 
 ## Coverage and evidence
 
+REA admits x86, x86_64, arm and arm64 executables through IDA. Every other CPU
+family, including families that REA recognizes later, is refused until REA
+admits it explicitly. Raw-binary and GameCube DOL targets are refused; open
+them with Ghidra. Admission is not verification: the real workflows under
+[Verification](#verification) cover x86_64 and arm64 only.
+
 All profiles support procedure/string inventory and literal or regex search, procedure resolution, pseudocode, assembly, raw function instructions, resolved callees, incoming address references, and a function dossier. Inventories and modern pseudocode/assembly follow upstream pagination. Upstream limits on modern xrefs and callees are retained as explicit truncation limitations. In the modern headless profile, targets that are not proven x86-only use processor-neutral `callgraph` edges instead of the x86 instruction checks in upstream `callees` (mrexodia/ida-pro-mcp#549). REA requests depth zero: the pinned upstream emits the root's outgoing edges without scanning child functions, then REA batches function-name lookup for those addresses. The graph covers recognized function destinations only; imports and other non-function targets remain unknown. A server without `callgraph` returns an empty relationship list with an explicit coverage limitation. Graph and path workflows retain those limitations alongside observed edges. A failed or inconsistent graph reply remains an error. A transport-level truncated preview is rejected rather than reported as complete evidence; the error preserves upstream retrieval guidance.
 
 All profiles expose `list_documents` as the single target admitted for the session. Attached mode verifies its digest against IDA metadata before returning it; headless mode binds the digest-checked private input. `inspect_address_context`, `trace_feature`, and `binary_overview` can therefore resolve that identity without upstream document-listing tools. Segment enumeration is optional: when the selected profile cannot provide it, `binary_overview` still returns document and procedure/string counts and omits `segments` and `segment_count`; omission means unobserved, not empty. The modern headless profile also supports `resolve_containing_procedure`. An address resolves through upstream `lookup_funcs` to the canonical entry of the function that contains it; the body stays unavailable like other IDA identities. When no function contains it, REA reads the database-scoped minimal `survey_binary` and reports `not_in_procedure` for an address inside one of its segments (ends are exclusive) and `outside_segments` otherwise. A missing, truncated or inconsistent survey fails the read instead of guessing a reason. `trace_feature` marks a trace truncated, with a residual unknown for that address, when upstream caps the references it returned. Attached profiles do not declare address containment resolution.
diff --git a/src/ida/IdaProvider.test.ts b/src/ida/IdaProvider.test.ts
index 048f77a907..ebcd1878dd 100644
--- a/src/ida/IdaProvider.test.ts
+++ b/src/ida/IdaProvider.test.ts
@@ -7,6 +7,10 @@ import { join } from "node:path";
 import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
 
 import { parseConfig } from "../config/parseConfig.js";
+import {
+  BINARY_ARCHITECTURES,
+  type BinaryTarget,
+} from "../domain/binaryTargetTypes.js";
 import {
   RecordingIdaMcp,
   createIdaTarget,
@@ -208,9 +212,36 @@ describe("IDA provider target support", () => {
     ).toMatchObject({
       status: "unsupported",
       code: "architecture_unsupported",
-      reason: expect.stringContaining("Hexagon"),
+      reason: expect.stringMatching(/hexagon.*Ghidra/su),
     });
   });
+  it("admits only the families IDA admits today, so new families stay refused", () => {
+    const config = parseConfig({});
+    if (!config.ok) throw new Error("expected valid configuration");
+    const provider = new IdaProvider(config.value, {});
+    const admitted: readonly string[] = ["x86", "x86_64", "arm", "arm64"];
+    for (const architecture of BINARY_ARCHITECTURES) {
+      // Admission reads only kind, format and family, so one ELF shape
+      // covers every recognized family, including any added later.
+      const support = provider.inspectTargetSupport({
+        path: "/tmp/fixture.elf",
+        sha256: "a".repeat(64),
+        kind: "executable",
+        format: "elf",
+        architecture,
+        availableArchitectures: [architecture],
+      } as BinaryTarget);
+      expect(support, architecture).toMatchObject(
+        admitted.includes(architecture)
+          ? { status: "supported" }
+          : {
+              status: "unsupported",
+              code: "architecture_unsupported",
+              reason: expect.stringContaining(architecture),
+            },
+      );
+    }
+  });
   it("declines thin arm64_32 Mach-O targets without a verified lane", () => {
     const config = parseConfig({});
     if (!config.ok) throw new Error("expected valid configuration");
diff --git a/src/ida/IdaProvider.ts b/src/ida/IdaProvider.ts
index f670c16e15..47730e621a 100644
--- a/src/ida/IdaProvider.ts
+++ b/src/ida/IdaProvider.ts
@@ -8,6 +8,7 @@ import {
 import type { AnalysisProfileCommitment } from "../domain/analysisProfile.js";
 import {
   isElfMetadataArchitecture,
+  type BinaryArchitecture,
   type BinaryTarget,
 } from "../domain/binaryTargetTypes.js";
 import { err, ok } from "../domain/result.js";
@@ -53,6 +54,17 @@ import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import type { ProviderInspectionScope } from "../application/ProviderInspectionScope.js";
 import type { ProviderRejectionCode } from "../domain/providerSelection.js";
 
+/**
+ * Families IDA admits today. Every other family is refused, including families
+ * that REA recognizes after this list was written.
+ */
+const IDA_ARCHITECTURES = new Set<BinaryArchitecture>([
+  "x86",
+  "x86_64",
+  "arm",
+  "arm64",
+]);
+
 /** Bring-your-own IDA MCP candidate; discovery performs no provider startup. */
 export class IdaProvider implements AnalysisProviderCandidate {
   readonly #ownedResources = new ArtifactResourceScope();
@@ -300,32 +312,6 @@ export class IdaProvider implements AnalysisProviderCandidate {
           "IDA does not admit caller-selected GameCube DOL images. Open the target with Ghidra and select format gamecube-dol.",
         diagnostics,
       };
-    if (
-      target.kind === "executable" &&
-      (isElfMetadataArchitecture(target.architecture) ||
-        target.architecture === "hexagon")
-    )
-      return {
-        status: "unsupported",
-        code: "architecture_unsupported",
-        reason: `REA's IDA adapter has no verified ${
-          target.architecture === "mips"
-            ? "MIPS"
-            : target.architecture === "riscv"
-              ? "RISC-V"
-              : target.architecture === "powerpc"
-                ? "PowerPC"
-                : "Hexagon"
-        } lane. Select a supported Ghidra profile instead.`,
-        diagnostics,
-      };
-    if (target.kind === "executable" && target.architecture === "arm64_32")
-      return {
-        status: "unsupported",
-        code: "architecture_unsupported",
-        reason: "REA's IDA adapter has no verified arm64_32 lane.",
-        diagnostics,
-      };
     if (target.kind !== "executable")
       return {
         status: "unsupported",
@@ -342,6 +328,18 @@ export class IdaProvider implements AnalysisProviderCandidate {
           "IDA does not admit headerless raw binaries. Open the target with Ghidra and supply architecture and entry_point.",
         diagnostics,
       };
+    if (!IDA_ARCHITECTURES.has(target.architecture))
+      return {
+        status: "unsupported",
+        code: "architecture_unsupported",
+        // Header-declared families that Ghidra admits keep the pointer there.
+        reason:
+          isElfMetadataArchitecture(target.architecture) ||
+          target.architecture === "hexagon"
+            ? `REA's IDA adapter has no verified ${target.architecture} lane. Select a supported Ghidra profile instead.`
+            : `REA's IDA adapter has no verified ${target.architecture} lane.`,
+        diagnostics,
+      };
     return target.format === "mach-o-universal"
       ? {
           status: "unknown",