@mcp-abap-adt/core 5.0.10 → 5.1.0

package/docs/superpowers/plans/2026-04-13-high-level-check-tools.md

@@ -0,0 +1,1740 @@
+# High-Level Check Tools Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add 13 high-level Check tools that wrap existing low-level check handlers, stripping session fields and adding a normalized `object_name` response field.
+
+**Architecture:** Each high-level Check handler delegates to its low-level counterpart, then normalizes the response via a shared `normalizeCheckResponse()` utility. All 13 handlers are registered in `HighLevelHandlersGroup`. Integration tests use `LambdaTester` to call handlers and verify the normalized response contract.
+
+**Tech Stack:** TypeScript, Jest, LambdaTester, existing ADT client library
+
+**Spec:** `docs/superpowers/specs/2026-04-13-high-level-check-tools-design.md`
+
+---
+
+### Task 1: Create shared normalizeCheckResponse utility
+
+**Files:**
+- Create: `src/lib/normalizeCheckResponse.ts`
+- Create: `src/__tests__/unit/normalizeCheckResponse.test.ts`
+
+- [ ] **Step 1: Write failing unit tests**
+
+Create `src/__tests__/unit/normalizeCheckResponse.test.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../lib/normalizeCheckResponse';
+
+describe('normalizeCheckResponse', () => {
+  it('should add object_name and strip session fields from success response', () => {
+    const lowLevelResult = {
+      isError: false,
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            success: true,
+            class_name: 'ZCL_TEST',
+            check_result: { success: true, status: 'processed', errors: [], warnings: [], info: [], total_messages: 0, has_errors: false, has_warnings: false, message: '' },
+            session_id: 'abc123',
+            session_state: { cookies: 'x=y' },
+            message: 'Class ZCL_TEST has no syntax errors',
+          }),
+        },
+      ],
+    };
+
+    const result = normalizeCheckResponse(lowLevelResult, 'ZCL_TEST');
+
+    expect(result.isError).toBe(false);
+    const data = JSON.parse(result.content[0].text);
+    expect(data.object_name).toBe('ZCL_TEST');
+    expect(data.class_name).toBe('ZCL_TEST');
+    expect(data.success).toBe(true);
+    expect(data.check_result).toBeDefined();
+    expect(data.message).toBeDefined();
+    expect(data).not.toHaveProperty('session_id');
+    expect(data).not.toHaveProperty('session_state');
+  });
+
+  it('should pass through error responses unchanged', () => {
+    const errorResult = {
+      isError: true,
+      content: [{ type: 'text' as const, text: 'Error: Class not found' }],
+    };
+
+    const result = normalizeCheckResponse(errorResult, 'ZCL_TEST');
+
+    expect(result).toBe(errorResult);
+  });
+
+  it('should pass through non-JSON responses unchanged', () => {
+    const nonJsonResult = {
+      isError: false,
+      content: [{ type: 'text' as const, text: 'not valid json' }],
+    };
+
+    const result = normalizeCheckResponse(nonJsonResult, 'ZCL_TEST');
+
+    expect(result).toBe(nonJsonResult);
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npx jest src/__tests__/unit/normalizeCheckResponse.test.ts --no-coverage`
+Expected: FAIL — module not found
+
+- [ ] **Step 3: Implement normalizeCheckResponse**
+
+Create `src/lib/normalizeCheckResponse.ts`:
+
+```typescript
+type McpResponse = {
+  isError: boolean;
+  content: Array<{ type: string; text: string }>;
+};
+
+/**
+ * Normalizes a low-level check handler response for high-level consumption.
+ * - Strips session_id and session_state from JSON payload
+ * - Adds object_name as canonical shared field
+ * - Passes through error responses and non-JSON payloads unchanged
+ */
+export function normalizeCheckResponse(
+  result: McpResponse,
+  objectName: string,
+): McpResponse {
+  if (result.isError) return result;
+
+  try {
+    const data = JSON.parse(result.content[0].text);
+    delete data.session_id;
+    delete data.session_state;
+    data.object_name = objectName;
+    return {
+      isError: false,
+      content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+  } catch {
+    return result;
+  }
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx jest src/__tests__/unit/normalizeCheckResponse.test.ts --no-coverage`
+Expected: PASS — all 3 tests green
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/normalizeCheckResponse.ts src/__tests__/unit/normalizeCheckResponse.test.ts
+git commit -m "feat: add normalizeCheckResponse utility for high-level check tools (#54)"
+```
+
+---
+
+### Task 2: Create CheckBehaviorDefinition high-level handler
+
+**Files:**
+- Create: `src/handlers/behavior_definition/high/handleCheckBehaviorDefinition.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/behavior_definition/high/handleCheckBehaviorDefinition.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckBehaviorDefinition as handleCheckBdefLow } from '../low/handleCheckBehaviorDefinition';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckBehaviorDefinition',
+  available_in: ['onprem', 'cloud'] as const,
+  description:
+    'Perform syntax check on an ABAP behavior definition (BDEF). Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description: 'BehaviorDefinition name (e.g., ZI_MY_BDEF).',
+      },
+    },
+    required: ['name'],
+  },
+} as const;
+
+export async function handleCheckBehaviorDefinition(
+  context: HandlerContext,
+  args: { name: string },
+) {
+  const result = await handleCheckBdefLow(context, args);
+  return normalizeCheckResponse(result, args.name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/behavior_definition/high/handleCheckBehaviorDefinition.ts
+git commit -m "feat: add CheckBehaviorDefinition high-level handler (#54)"
+```
+
+---
+
+### Task 3: Create CheckClass high-level handler
+
+**Files:**
+- Create: `src/handlers/class/high/handleCheckClass.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/class/high/handleCheckClass.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckClass as handleCheckClassLow } from '../low/handleCheckClass';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckClass',
+  available_in: ['onprem', 'cloud', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP class. Can check existing class (active/inactive) or validate hypothetical source code. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      class_name: {
+        type: 'string',
+        description: 'Class name (e.g., ZCL_MY_CLASS).',
+      },
+      version: {
+        type: 'string',
+        description:
+          "Version to check: 'active' (last activated) or 'inactive' (current unsaved). Default: active.",
+        enum: ['active', 'inactive'],
+      },
+      source_code: {
+        type: 'string',
+        description:
+          'Optional: source code to validate. If provided, validates hypothetical code without creating object. Must include complete CLASS DEFINITION and IMPLEMENTATION sections.',
+      },
+    },
+    required: ['class_name'],
+  },
+} as const;
+
+export async function handleCheckClass(
+  context: HandlerContext,
+  args: { class_name: string; version?: string; source_code?: string },
+) {
+  const result = await handleCheckClassLow(context, args);
+  return normalizeCheckResponse(result, args.class_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/class/high/handleCheckClass.ts
+git commit -m "feat: add CheckClass high-level handler (#54)"
+```
+
+---
+
+### Task 4: Create CheckDataElement high-level handler
+
+**Files:**
+- Create: `src/handlers/data_element/high/handleCheckDataElement.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/data_element/high/handleCheckDataElement.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckDataElement as handleCheckDataElementLow } from '../low/handleCheckDataElement';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckDataElement',
+  available_in: ['onprem', 'cloud'] as const,
+  description:
+    'Perform syntax check on an ABAP data element. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      data_element_name: {
+        type: 'string',
+        description: 'Data element name (e.g., ZDE_MY_ELEMENT).',
+      },
+    },
+    required: ['data_element_name'],
+  },
+} as const;
+
+export async function handleCheckDataElement(
+  context: HandlerContext,
+  args: { data_element_name: string },
+) {
+  const result = await handleCheckDataElementLow(context, args);
+  return normalizeCheckResponse(result, args.data_element_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/data_element/high/handleCheckDataElement.ts
+git commit -m "feat: add CheckDataElement high-level handler (#54)"
+```
+
+---
+
+### Task 5: Create CheckDomain high-level handler
+
+**Files:**
+- Create: `src/handlers/domain/high/handleCheckDomain.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/domain/high/handleCheckDomain.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckDomain as handleCheckDomainLow } from '../low/handleCheckDomain';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckDomain',
+  available_in: ['onprem', 'cloud'] as const,
+  description:
+    'Perform syntax check on an ABAP domain. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      domain_name: {
+        type: 'string',
+        description: 'Domain name (e.g., ZDM_MY_DOMAIN).',
+      },
+    },
+    required: ['domain_name'],
+  },
+} as const;
+
+export async function handleCheckDomain(
+  context: HandlerContext,
+  args: { domain_name: string },
+) {
+  const result = await handleCheckDomainLow(context, args);
+  return normalizeCheckResponse(result, args.domain_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/domain/high/handleCheckDomain.ts
+git commit -m "feat: add CheckDomain high-level handler (#54)"
+```
+
+---
+
+### Task 6: Create CheckFunctionGroup high-level handler
+
+**Files:**
+- Create: `src/handlers/function/high/handleCheckFunctionGroup.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/function/high/handleCheckFunctionGroup.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckFunctionGroup as handleCheckFunctionGroupLow } from '../low/handleCheckFunctionGroup';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckFunctionGroup',
+  available_in: ['onprem', 'cloud', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP function group. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      function_group_name: {
+        type: 'string',
+        description: 'Function group name (e.g., ZFGRP_MY_GROUP).',
+      },
+    },
+    required: ['function_group_name'],
+  },
+} as const;
+
+export async function handleCheckFunctionGroup(
+  context: HandlerContext,
+  args: { function_group_name: string },
+) {
+  const result = await handleCheckFunctionGroupLow(context, args);
+  return normalizeCheckResponse(result, args.function_group_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/function/high/handleCheckFunctionGroup.ts
+git commit -m "feat: add CheckFunctionGroup high-level handler (#54)"
+```
+
+---
+
+### Task 7: Create CheckFunctionModule high-level handler
+
+**Files:**
+- Create: `src/handlers/function/high/handleCheckFunctionModule.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/function/high/handleCheckFunctionModule.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckFunctionModule as handleCheckFunctionModuleLow } from '../low/handleCheckFunctionModule';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckFunctionModule',
+  available_in: ['onprem', 'cloud', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP function module. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      function_group_name: {
+        type: 'string',
+        description: 'Function group name containing the function module.',
+      },
+      function_module_name: {
+        type: 'string',
+        description: 'Function module name (e.g., Z_MY_FUNCTION).',
+      },
+      version: {
+        type: 'string',
+        description:
+          "Version to check: 'active' or 'inactive'. Default: active.",
+        enum: ['active', 'inactive'],
+      },
+    },
+    required: ['function_group_name', 'function_module_name'],
+  },
+} as const;
+
+export async function handleCheckFunctionModule(
+  context: HandlerContext,
+  args: { function_group_name: string; function_module_name: string; version?: string },
+) {
+  const result = await handleCheckFunctionModuleLow(context, args);
+  return normalizeCheckResponse(result, args.function_module_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/function/high/handleCheckFunctionModule.ts
+git commit -m "feat: add CheckFunctionModule high-level handler (#54)"
+```
+
+---
+
+### Task 8: Create CheckInterface high-level handler
+
+**Files:**
+- Create: `src/handlers/interface/high/handleCheckInterface.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/interface/high/handleCheckInterface.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckInterface as handleCheckInterfaceLow } from '../low/handleCheckInterface';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckInterface',
+  available_in: ['onprem', 'cloud', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP interface. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      interface_name: {
+        type: 'string',
+        description: 'Interface name (e.g., ZIF_MY_INTERFACE).',
+      },
+    },
+    required: ['interface_name'],
+  },
+} as const;
+
+export async function handleCheckInterface(
+  context: HandlerContext,
+  args: { interface_name: string },
+) {
+  const result = await handleCheckInterfaceLow(context, args);
+  return normalizeCheckResponse(result, args.interface_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/interface/high/handleCheckInterface.ts
+git commit -m "feat: add CheckInterface high-level handler (#54)"
+```
+
+---
+
+### Task 9: Create CheckMetadataExtension high-level handler
+
+**Files:**
+- Create: `src/handlers/ddlx/high/handleCheckMetadataExtension.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/ddlx/high/handleCheckMetadataExtension.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckMetadataExtension as handleCheckMetadataExtensionLow } from '../low/handleCheckMetadataExtension';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckMetadataExtension',
+  available_in: ['onprem', 'cloud'] as const,
+  description:
+    'Perform syntax check on an ABAP metadata extension (DDLX). Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description: 'Metadata extension name (e.g., ZC_MY_DDLX).',
+      },
+    },
+    required: ['name'],
+  },
+} as const;
+
+export async function handleCheckMetadataExtension(
+  context: HandlerContext,
+  args: { name: string },
+) {
+  const result = await handleCheckMetadataExtensionLow(context, args);
+  return normalizeCheckResponse(result, args.name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/ddlx/high/handleCheckMetadataExtension.ts
+git commit -m "feat: add CheckMetadataExtension high-level handler (#54)"
+```
+
+---
+
+### Task 10: Create CheckPackage high-level handler
+
+**Files:**
+- Create: `src/handlers/package/high/handleCheckPackage.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/package/high/handleCheckPackage.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckPackage as handleCheckPackageLow } from '../low/handleCheckPackage';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckPackage',
+  available_in: ['onprem', 'cloud', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP package. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      package_name: {
+        type: 'string',
+        description: 'Package name (e.g., ZMY_PACKAGE).',
+      },
+      super_package: {
+        type: 'string',
+        description: 'Super package name (parent package).',
+      },
+    },
+    required: ['package_name', 'super_package'],
+  },
+} as const;
+
+export async function handleCheckPackage(
+  context: HandlerContext,
+  args: { package_name: string; super_package: string },
+) {
+  const result = await handleCheckPackageLow(context, args);
+  return normalizeCheckResponse(result, args.package_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/package/high/handleCheckPackage.ts
+git commit -m "feat: add CheckPackage high-level handler (#54)"
+```
+
+---
+
+### Task 11: Create CheckProgram high-level handler
+
+**Files:**
+- Create: `src/handlers/program/high/handleCheckProgram.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/program/high/handleCheckProgram.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckProgram as handleCheckProgramLow } from '../low/handleCheckProgram';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckProgram',
+  available_in: ['onprem', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP program. Returns syntax errors, warnings, and messages. Not available on cloud.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      program_name: {
+        type: 'string',
+        description: 'Program name (e.g., ZMCP_MY_PROGRAM).',
+      },
+    },
+    required: ['program_name'],
+  },
+} as const;
+
+export async function handleCheckProgram(
+  context: HandlerContext,
+  args: { program_name: string },
+) {
+  const result = await handleCheckProgramLow(context, args);
+  return normalizeCheckResponse(result, args.program_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/program/high/handleCheckProgram.ts
+git commit -m "feat: add CheckProgram high-level handler (#54)"
+```
+
+---
+
+### Task 12: Create CheckStructure high-level handler
+
+**Files:**
+- Create: `src/handlers/structure/high/handleCheckStructure.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/structure/high/handleCheckStructure.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckStructure as handleCheckStructureLow } from '../low/handleCheckStructure';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckStructure',
+  available_in: ['onprem', 'cloud'] as const,
+  description:
+    'Perform syntax check on an ABAP structure. Can check existing structure (active/inactive) or validate hypothetical DDL code. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      structure_name: {
+        type: 'string',
+        description: 'Structure name (e.g., ZST_MY_STRUCTURE).',
+      },
+      version: {
+        type: 'string',
+        description:
+          "Version to check: 'active' or 'inactive'. Default: inactive.",
+        enum: ['active', 'inactive'],
+      },
+      ddl_code: {
+        type: 'string',
+        description:
+          'Optional: DDL source code to validate instead of the saved version.',
+      },
+    },
+    required: ['structure_name'],
+  },
+} as const;
+
+export async function handleCheckStructure(
+  context: HandlerContext,
+  args: { structure_name: string; version?: string; ddl_code?: string },
+) {
+  const result = await handleCheckStructureLow(context, args);
+  return normalizeCheckResponse(result, args.structure_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/structure/high/handleCheckStructure.ts
+git commit -m "feat: add CheckStructure high-level handler (#54)"
+```
+
+---
+
+### Task 13: Create CheckTable high-level handler
+
+**Files:**
+- Create: `src/handlers/table/high/handleCheckTable.ts`
+
+- [ ] **Step 1: Create handler**
+
+Note: `reporter` parameter is excluded from high-level API per spec. Low-level default `abapCheckRun` is used.
+
+Create `src/handlers/table/high/handleCheckTable.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckTable as handleCheckTableLow } from '../low/handleCheckTable';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckTable',
+  available_in: ['onprem', 'cloud'] as const,
+  description:
+    'Perform syntax check on an ABAP table. Can check existing table (active/inactive) or validate hypothetical DDL code. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      table_name: {
+        type: 'string',
+        description: 'Table name (e.g., ZMCP_MY_TABLE).',
+      },
+      version: {
+        type: 'string',
+        description:
+          "Version to check: 'active', 'inactive', or 'new'. Default: new.",
+        enum: ['active', 'inactive', 'new'],
+      },
+      ddl_code: {
+        type: 'string',
+        description:
+          'Optional: DDL source code to validate instead of the saved version.',
+      },
+    },
+    required: ['table_name'],
+  },
+} as const;
+
+export async function handleCheckTable(
+  context: HandlerContext,
+  args: { table_name: string; version?: string; ddl_code?: string },
+) {
+  const result = await handleCheckTableLow(context, args);
+  return normalizeCheckResponse(result, args.table_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/table/high/handleCheckTable.ts
+git commit -m "feat: add CheckTable high-level handler (#54)"
+```
+
+---
+
+### Task 14: Create CheckView high-level handler
+
+**Files:**
+- Create: `src/handlers/view/high/handleCheckView.ts`
+
+- [ ] **Step 1: Create handler**
+
+Create `src/handlers/view/high/handleCheckView.ts`:
+
+```typescript
+import { normalizeCheckResponse } from '../../../lib/normalizeCheckResponse';
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import { handleCheckView as handleCheckViewLow } from '../low/handleCheckView';
+
+export const TOOL_DEFINITION = {
+  name: 'CheckView',
+  available_in: ['onprem', 'cloud', 'legacy'] as const,
+  description:
+    'Perform syntax check on an ABAP CDS view. Can check existing view (active/inactive) or validate hypothetical DDL source. Returns syntax errors, warnings, and messages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      view_name: {
+        type: 'string',
+        description: 'CDS view name (e.g., ZI_MY_VIEW).',
+      },
+      version: {
+        type: 'string',
+        description:
+          "Version to check: 'active' or 'inactive'. Default: inactive.",
+        enum: ['active', 'inactive'],
+      },
+      ddl_source: {
+        type: 'string',
+        description:
+          'Optional: DDL source code to validate instead of the saved version.',
+      },
+    },
+    required: ['view_name'],
+  },
+} as const;
+
+export async function handleCheckView(
+  context: HandlerContext,
+  args: { view_name: string; version?: string; ddl_source?: string },
+) {
+  const result = await handleCheckViewLow(context, args);
+  return normalizeCheckResponse(result, args.view_name?.toUpperCase());
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add src/handlers/view/high/handleCheckView.ts
+git commit -m "feat: add CheckView high-level handler (#54)"
+```
+
+---
+
+### Task 15: Register all 13 Check handlers in HighLevelHandlersGroup
+
+**Files:**
+- Modify: `src/lib/handlers/groups/HighLevelHandlersGroup.ts`
+
+- [ ] **Step 1: Add imports**
+
+Add these imports at the top of `src/lib/handlers/groups/HighLevelHandlersGroup.ts`, alongside the existing imports for each object type:
+
+```typescript
+import {
+  TOOL_DEFINITION as CheckBehaviorDefinition_Tool,
+  handleCheckBehaviorDefinition,
+} from '../../../handlers/behavior_definition/high/handleCheckBehaviorDefinition';
+import {
+  TOOL_DEFINITION as CheckClass_Tool,
+  handleCheckClass,
+} from '../../../handlers/class/high/handleCheckClass';
+import {
+  TOOL_DEFINITION as CheckDataElement_Tool,
+  handleCheckDataElement,
+} from '../../../handlers/data_element/high/handleCheckDataElement';
+import {
+  TOOL_DEFINITION as CheckMetadataExtension_Tool,
+  handleCheckMetadataExtension,
+} from '../../../handlers/ddlx/high/handleCheckMetadataExtension';
+import {
+  TOOL_DEFINITION as CheckDomain_Tool,
+  handleCheckDomain,
+} from '../../../handlers/domain/high/handleCheckDomain';
+import {
+  TOOL_DEFINITION as CheckFunctionGroup_Tool,
+  handleCheckFunctionGroup,
+} from '../../../handlers/function/high/handleCheckFunctionGroup';
+import {
+  TOOL_DEFINITION as CheckFunctionModule_Tool,
+  handleCheckFunctionModule,
+} from '../../../handlers/function/high/handleCheckFunctionModule';
+import {
+  TOOL_DEFINITION as CheckInterface_Tool,
+  handleCheckInterface,
+} from '../../../handlers/interface/high/handleCheckInterface';
+import {
+  TOOL_DEFINITION as CheckPackage_Tool,
+  handleCheckPackage,
+} from '../../../handlers/package/high/handleCheckPackage';
+import {
+  TOOL_DEFINITION as CheckProgram_Tool,
+  handleCheckProgram,
+} from '../../../handlers/program/high/handleCheckProgram';
+import {
+  TOOL_DEFINITION as CheckStructure_Tool,
+  handleCheckStructure,
+} from '../../../handlers/structure/high/handleCheckStructure';
+import {
+  TOOL_DEFINITION as CheckTable_Tool,
+  handleCheckTable,
+} from '../../../handlers/table/high/handleCheckTable';
+import {
+  TOOL_DEFINITION as CheckView_Tool,
+  handleCheckView,
+} from '../../../handlers/view/high/handleCheckView';
+```
+
+- [ ] **Step 2: Add handler entries to getHandlers() return array**
+
+Add these entries inside the `return [...]` array in the `getHandlers()` method. Place them as a group (e.g., after existing per-type Activate entries or at the end of the array, but grouped together):
+
+```typescript
+      // Per-type Check handlers (high-level)
+      {
+        toolDefinition: CheckBehaviorDefinition_Tool,
+        handler: withContext(handleCheckBehaviorDefinition),
+      },
+      {
+        toolDefinition: CheckClass_Tool,
+        handler: withContext(handleCheckClass),
+      },
+      {
+        toolDefinition: CheckDataElement_Tool,
+        handler: withContext(handleCheckDataElement),
+      },
+      {
+        toolDefinition: CheckDomain_Tool,
+        handler: withContext(handleCheckDomain),
+      },
+      {
+        toolDefinition: CheckFunctionGroup_Tool,
+        handler: withContext(handleCheckFunctionGroup),
+      },
+      {
+        toolDefinition: CheckFunctionModule_Tool,
+        handler: withContext(handleCheckFunctionModule),
+      },
+      {
+        toolDefinition: CheckInterface_Tool,
+        handler: withContext(handleCheckInterface),
+      },
+      {
+        toolDefinition: CheckMetadataExtension_Tool,
+        handler: withContext(handleCheckMetadataExtension),
+      },
+      {
+        toolDefinition: CheckPackage_Tool,
+        handler: withContext(handleCheckPackage),
+      },
+      {
+        toolDefinition: CheckProgram_Tool,
+        handler: withContext(handleCheckProgram),
+      },
+      {
+        toolDefinition: CheckStructure_Tool,
+        handler: withContext(handleCheckStructure),
+      },
+      {
+        toolDefinition: CheckTable_Tool,
+        handler: withContext(handleCheckTable),
+      },
+      {
+        toolDefinition: CheckView_Tool,
+        handler: withContext(handleCheckView),
+      },
+```
+
+- [ ] **Step 3: Verify TypeScript compiles**
+
+Run: `npx tsc --noEmit`
+Expected: No errors
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/lib/handlers/groups/HighLevelHandlersGroup.ts
+git commit -m "feat: register 13 high-level Check handlers in HighLevelHandlersGroup (#54)"
+```
+
+---
+
+### Task 16: Add test configuration for high-level Check handlers
+
+**Files:**
+- Modify: `tests/test-config.yaml.template`
+
+- [ ] **Step 1: Add check test cases to test-config.yaml.template**
+
+Add the following test case configurations to `tests/test-config.yaml.template`. These use existing shared objects (created by `npm run shared:setup`) so no new SAP objects need to be created. Place after existing handler test configurations:
+
+```yaml
+# ============================================================================
+# Check Handlers (High-Level) — syntax/semantic validation
+# Uses existing shared objects, no CRUD needed
+# ============================================================================
+
+# CheckClass
+check_class_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud", "legacy"]
+      description: "Check an existing ABAP class for syntax errors"
+      params:
+        class_name: "ZCL_MCP_SHARED_CLS"   # shared class from shared:setup, or any existing class
+
+# CheckBehaviorDefinition
+check_bdef_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud"]
+      description: "Check an existing behavior definition for syntax errors"
+      params:
+        name: "ZI_MCP_SHR_ROOT"            # shared BDEF from shared:setup
+
+# CheckView
+check_view_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud", "legacy"]
+      description: "Check an existing CDS view for syntax errors"
+      params:
+        view_name: "ZI_MCP_SHR_ROOT"       # shared CDS view from shared:setup
+
+# CheckDomain
+check_domain_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud"]
+      description: "Check an existing domain for syntax errors"
+      params:
+        domain_name: "ZMCP_SHR_DOMAIN"      # any existing domain, or shared one
+
+# CheckDataElement
+check_data_element_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud"]
+      description: "Check an existing data element for syntax errors"
+      params:
+        data_element_name: "ZMCP_SHR_DTEL"  # any existing data element
+
+# CheckTable
+check_table_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud"]
+      description: "Check an existing table for syntax errors"
+      params:
+        table_name: "ZMCP_SHR_RTABL"        # shared table from shared:setup
+
+# CheckStructure
+check_structure_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud"]
+      description: "Check an existing structure for syntax errors"
+      params:
+        structure_name: "ZMCP_SHR_STRUCT"    # any existing structure
+
+# CheckInterface
+check_interface_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud", "legacy"]
+      description: "Check an existing interface for syntax errors"
+      params:
+        interface_name: "ZIF_MCP_SHARED"     # any existing interface
+
+# CheckPackage
+check_package_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud", "legacy"]
+      description: "Check an existing package for syntax errors"
+      params:
+        package_name: "ZMCP_SHARED"          # shared package from shared:setup
+        super_package: ""                     # super package (from shared_dependencies)
+
+# CheckProgram
+check_program_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "legacy"]
+      description: "Check an existing program for syntax errors (not available on cloud)"
+      params:
+        program_name: "ZMCP_SHR_PROG"       # any existing program
+
+# CheckFunctionGroup
+check_function_group_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud", "legacy"]
+      description: "Check an existing function group for syntax errors"
+      params:
+        function_group_name: "ZMCP_SHR_FGRP" # any existing function group
+
+# CheckFunctionModule
+check_function_module_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud", "legacy"]
+      description: "Check an existing function module for syntax errors"
+      params:
+        function_group_name: "ZMCP_SHR_FGRP"
+        function_module_name: "Z_MCP_SHR_FM"  # any existing FM in that group
+
+# CheckMetadataExtension
+check_metadata_extension_high:
+  test_cases:
+    - name: "check_existing"
+      enabled: true
+      available_in: ["onprem", "cloud"]
+      description: "Check an existing metadata extension for syntax errors"
+      params:
+        name: "ZC_MCP_SHR_DDLX"             # any existing DDLX
+```
+
+- [ ] **Step 2: Copy new entries to local test-config.yaml**
+
+After updating the template, also add these entries to the local `tests/test-config.yaml` with object names appropriate for the test system.
+
+- [ ] **Step 3: Commit template changes**
+
+```bash
+git add tests/test-config.yaml.template
+git commit -m "feat: add test configuration for high-level Check handlers (#54)"
+```
+
+---
+
+### Task 17: Create integration tests for high-level Check handlers
+
+**Files:**
+- Create: `src/__tests__/integration/high/check/CheckHighHandlers.test.ts`
+
+- [ ] **Step 1: Create integration test file**
+
+Create `src/__tests__/integration/high/check/CheckHighHandlers.test.ts`:
+
+```typescript
+/**
+ * Integration tests for Check High-Level Handlers
+ *
+ * Tests high-level Check handlers that perform syntax/semantic validation:
+ * Each handler wraps a low-level check, strips session fields,
+ * and adds normalized object_name field.
+ *
+ * Run: npm test -- --testPathPattern=integration/high/check
+ */
+
+import { handleCheckBehaviorDefinition } from '../../../../handlers/behavior_definition/high/handleCheckBehaviorDefinition';
+import { handleCheckClass } from '../../../../handlers/class/high/handleCheckClass';
+import { handleCheckDataElement } from '../../../../handlers/data_element/high/handleCheckDataElement';
+import { handleCheckMetadataExtension } from '../../../../handlers/ddlx/high/handleCheckMetadataExtension';
+import { handleCheckDomain } from '../../../../handlers/domain/high/handleCheckDomain';
+import { handleCheckFunctionGroup } from '../../../../handlers/function/high/handleCheckFunctionGroup';
+import { handleCheckFunctionModule } from '../../../../handlers/function/high/handleCheckFunctionModule';
+import { handleCheckInterface } from '../../../../handlers/interface/high/handleCheckInterface';
+import { handleCheckPackage } from '../../../../handlers/package/high/handleCheckPackage';
+import { handleCheckProgram } from '../../../../handlers/program/high/handleCheckProgram';
+import { handleCheckStructure } from '../../../../handlers/structure/high/handleCheckStructure';
+import { handleCheckTable } from '../../../../handlers/table/high/handleCheckTable';
+import { handleCheckView } from '../../../../handlers/view/high/handleCheckView';
+import { getTimeout } from '../../helpers/configHelpers';
+import { createTestLogger } from '../../helpers/loggerHelpers';
+import { LambdaTester } from '../../helpers/testers/LambdaTester';
+import type { LambdaTesterContext } from '../../helpers/testers/types';
+import {
+  createHandlerContext,
+  parseHandlerResponse,
+} from '../../helpers/testHelpers';
+
+/**
+ * Helper: assert normalized check response contract
+ * Verifies: object_name present, session fields absent, core fields present
+ */
+function assertNormalizedCheckResponse(data: any, expectedObjectName: string) {
+  // Normalized common fields
+  expect(data.object_name).toBe(expectedObjectName.toUpperCase());
+  expect(data.success).toBeDefined();
+  expect(data.message).toBeDefined();
+  expect(data.check_result).toBeDefined();
+
+  // Session fields must be absent
+  expect(data).not.toHaveProperty('session_id');
+  expect(data).not.toHaveProperty('session_state');
+}
+
+describe('Check High-Level Handlers Integration', () => {
+  const logger = createTestLogger('check-high');
+
+  // CheckClass
+  describe('CheckClass', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_class_high',
+        'check_existing',
+        'check-class-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing class and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-class');
+        const response = await tester.invokeToolOrHandler(
+          'CheckClass',
+          { class_name: params.class_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckClass(ctx, { class_name: params.class_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.class_name);
+        expect(data.class_name).toBe(params.class_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckBehaviorDefinition
+  describe('CheckBehaviorDefinition', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_bdef_high',
+        'check_existing',
+        'check-bdef-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing BDEF and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-bdef');
+        const response = await tester.invokeToolOrHandler(
+          'CheckBehaviorDefinition',
+          { name: params.name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckBehaviorDefinition(ctx, { name: params.name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.name);
+        expect(data.name).toBe(params.name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckView
+  describe('CheckView', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_view_high',
+        'check_existing',
+        'check-view-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing CDS view and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-view');
+        const response = await tester.invokeToolOrHandler(
+          'CheckView',
+          { view_name: params.view_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckView(ctx, { view_name: params.view_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.view_name);
+        expect(data.view_name).toBe(params.view_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckDomain
+  describe('CheckDomain', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_domain_high',
+        'check_existing',
+        'check-domain-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing domain and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-domain');
+        const response = await tester.invokeToolOrHandler(
+          'CheckDomain',
+          { domain_name: params.domain_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckDomain(ctx, { domain_name: params.domain_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.domain_name);
+        expect(data.domain_name).toBe(params.domain_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckDataElement
+  describe('CheckDataElement', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_data_element_high',
+        'check_existing',
+        'check-dtel-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing data element and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-dtel');
+        const response = await tester.invokeToolOrHandler(
+          'CheckDataElement',
+          { data_element_name: params.data_element_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckDataElement(ctx, { data_element_name: params.data_element_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.data_element_name);
+        expect(data.data_element_name).toBe(params.data_element_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckTable
+  describe('CheckTable', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_table_high',
+        'check_existing',
+        'check-table-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing table and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-table');
+        const response = await tester.invokeToolOrHandler(
+          'CheckTable',
+          { table_name: params.table_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckTable(ctx, { table_name: params.table_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.table_name);
+        expect(data.table_name).toBe(params.table_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckStructure
+  describe('CheckStructure', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_structure_high',
+        'check_existing',
+        'check-structure-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing structure and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-structure');
+        const response = await tester.invokeToolOrHandler(
+          'CheckStructure',
+          { structure_name: params.structure_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckStructure(ctx, { structure_name: params.structure_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.structure_name);
+        expect(data.structure_name).toBe(params.structure_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckInterface
+  describe('CheckInterface', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_interface_high',
+        'check_existing',
+        'check-interface-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing interface and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-interface');
+        const response = await tester.invokeToolOrHandler(
+          'CheckInterface',
+          { interface_name: params.interface_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckInterface(ctx, { interface_name: params.interface_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.interface_name);
+        expect(data.interface_name).toBe(params.interface_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckPackage
+  describe('CheckPackage', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_package_high',
+        'check_existing',
+        'check-package-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing package and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-package');
+        const response = await tester.invokeToolOrHandler(
+          'CheckPackage',
+          { package_name: params.package_name, super_package: params.super_package },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckPackage(ctx, {
+              package_name: params.package_name,
+              super_package: params.super_package,
+            });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.package_name);
+        expect(data.package_name).toBe(params.package_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckProgram (onprem/legacy only)
+  describe('CheckProgram', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_program_high',
+        'check_existing',
+        'check-program-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing program and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-program');
+        const response = await tester.invokeToolOrHandler(
+          'CheckProgram',
+          { program_name: params.program_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckProgram(ctx, { program_name: params.program_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.program_name);
+        expect(data.program_name).toBe(params.program_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckFunctionGroup
+  describe('CheckFunctionGroup', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_function_group_high',
+        'check_existing',
+        'check-fgrp-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing function group and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-fgrp');
+        const response = await tester.invokeToolOrHandler(
+          'CheckFunctionGroup',
+          { function_group_name: params.function_group_name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckFunctionGroup(ctx, { function_group_name: params.function_group_name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.function_group_name);
+        expect(data.function_group_name).toBe(params.function_group_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckFunctionModule
+  describe('CheckFunctionModule', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_function_module_high',
+        'check_existing',
+        'check-fm-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing function module and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-fm');
+        const response = await tester.invokeToolOrHandler(
+          'CheckFunctionModule',
+          {
+            function_group_name: params.function_group_name,
+            function_module_name: params.function_module_name,
+          },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckFunctionModule(ctx, {
+              function_group_name: params.function_group_name,
+              function_module_name: params.function_module_name,
+            });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.function_module_name);
+        expect(data.function_module_name).toBe(params.function_module_name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+
+  // CheckMetadataExtension
+  describe('CheckMetadataExtension', () => {
+    let tester: LambdaTester;
+
+    beforeAll(async () => {
+      tester = new LambdaTester(
+        'check_metadata_extension_high',
+        'check_existing',
+        'check-ddlx-high',
+      );
+      await tester.beforeAll(async () => {}, async () => {});
+    }, getTimeout('long'));
+
+    afterAll(async () => { await tester.afterAll(async () => {}); });
+    beforeEach(async () => { await tester.beforeEach(async () => {}); });
+    afterEach(async () => { await tester.afterEach(); });
+
+    it('should check existing metadata extension and return normalized response', async () => {
+      await tester.run(async (context: LambdaTesterContext) => {
+        const { connection, params } = context;
+        const checkLogger = createTestLogger('check-ddlx');
+        const response = await tester.invokeToolOrHandler(
+          'CheckMetadataExtension',
+          { name: params.name },
+          async () => {
+            const ctx = createHandlerContext({ connection, logger: checkLogger });
+            return handleCheckMetadataExtension(ctx, { name: params.name });
+          },
+        );
+
+        expect(response.isError).toBe(false);
+        const data = parseHandlerResponse(response);
+        assertNormalizedCheckResponse(data, params.name);
+        expect(data.name).toBe(params.name.toUpperCase());
+      });
+    }, getTimeout('medium'));
+  });
+});
+```
+
+- [ ] **Step 2: Run unit tests to verify no compile errors**
+
+Run: `npx tsc --noEmit`
+Expected: No errors
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/__tests__/integration/high/check/CheckHighHandlers.test.ts
+git commit -m "feat: add integration tests for high-level Check handlers (#54)"
+```
+
+---
+
+### Task 18: Verify build and run unit tests
+
+**Files:** None (verification only)
+
+- [ ] **Step 1: Run TypeScript compilation**
+
+Run: `npx tsc --noEmit`
+Expected: No errors
+
+- [ ] **Step 2: Run unit tests**
+
+Run: `npx jest src/__tests__/unit/normalizeCheckResponse.test.ts --no-coverage`
+Expected: All 3 tests pass
+
+- [ ] **Step 3: Run lint**
+
+Run: `npm run lint` (or `npx biome check src/lib/normalizeCheckResponse.ts src/handlers/*/high/handleCheck*.ts`)
+Expected: No errors. Fix any lint issues before committing.
+
+- [ ] **Step 4: Final commit if lint fixes needed**
+
+```bash
+git add -u
+git commit -m "fix: lint fixes for high-level Check handlers (#54)"
+```