phasegate 0.15.0

package/scripts/harness/validator-system/application/use-cases/run-l0-validators-usecase.ts

@@ -0,0 +1,60 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL0ValidatorsUseCase — L0 バリデータ実行
+ */
+import { ValidatorId } from '../../domain/value-objects/validator-id.js';
+import { ValidationResult } from '../../domain/value-objects/validation-result.js';
+import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
+import { ValidatorExecutionService } from '../../domain/services/validator-execution-service.js';
+import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+import type { RunL0ValidatorsInput } from '../dto/run-l0-validators-input.js';
+import type { ValidatorConfigPort } from '../../domain/ports/validator-config-port.js';
+
+export interface RunL0ValidatorsUseCaseDeps {
+  validatorRegistry: ValidatorRegistry;
+  validatorExecutionService: ValidatorExecutionService;
+  validatorConfigPort: ValidatorConfigPort;
+  contractMapper: ValidationResultContractMapper;
+}
+
+export class RunL0ValidatorsUseCase {
+  private readonly registry: ValidatorRegistry;
+  private readonly executionService: ValidatorExecutionService;
+  private readonly configPort: ValidatorConfigPort;
+  private readonly mapper: ValidationResultContractMapper;
+
+  constructor(deps: RunL0ValidatorsUseCaseDeps) {
+    this.registry = deps.validatorRegistry;
+    this.executionService = deps.validatorExecutionService;
+    this.configPort = deps.validatorConfigPort;
+    this.mapper = deps.contractMapper;
+  }
+
+  async execute(input: RunL0ValidatorsInput): Promise<readonly ValidationResultContract[]> {
+    let validatorIds: readonly ValidatorId[];
+    if (input.validatorIds && input.validatorIds.length > 0) {
+      validatorIds = input.validatorIds.map((id) => ValidatorId.create(id));
+    } else {
+      validatorIds = this.registry.listByLayer('L0').map((d) => d.validatorId);
+    }
+
+    const definitions = this.registry.select(validatorIds);
+
+    const layerConfig = await this.configPort.getLayerConfig('L0');
+    if (!layerConfig.enabled) {
+      return [];
+    }
+
+    const results = this.executionService.execute(definitions, [layerConfig]);
+    const finalResults = definitions.map(
+      (definition) => {
+        const result = results.find((r) => r.validatorId.value === definition.validatorId.value);
+        return result ?? ValidationResult.skip(definition.validatorId);
+      },
+    );
+    return this.mapper.toContracts(finalResults);
+  }
+}

package/scripts/harness/validator-system/application/use-cases/run-l1-validators-usecase.ts

@@ -0,0 +1,152 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL1ValidatorsUseCase — H08-07/H08-08: L1バリデータ実行
+ * L1-017 ITテスト内部モック検出、L1-018 スタブコメント残存検出を実行する。
+ */
+import { ValidatorId } from '../../domain/value-objects/validator-id.js';
+import { ValidationResult } from '../../domain/value-objects/validation-result.js';
+import { ItTestMockDetectionService } from '../../domain/services/it-test-mock-detection-service.js';
+import { StubCommentDetectionService } from '../../domain/services/stub-comment-detection-service.js';
+import { CliE2eTestExistenceService } from '../../domain/services/cli-e2e-test-existence-service.js';
+import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+import type { RunL1ValidatorsInput } from '../dto/run-l1-validators-input.js';
+import type { ItTestFileAnalyzerPort } from '../../domain/ports/it-test-file-analyzer-port.js';
+import type { SourceFileTextScannerPort } from '../../domain/ports/source-file-text-scanner-port.js';
+import type { CliCommandRegistryPort } from '../../domain/ports/cli-command-registry-port.js';
+import type { E2eTestFileRegistryPort } from '../../domain/ports/e2e-test-file-registry-port.js';
+
+export interface RunL1ValidatorsUseCaseDeps {
+  itTestFileAnalyzerPort: ItTestFileAnalyzerPort;
+  sourceFileTextScannerPort: SourceFileTextScannerPort;
+  cliCommandRegistryPort?: CliCommandRegistryPort;
+  e2eTestFileRegistryPort?: E2eTestFileRegistryPort;
+  contractMapper: ValidationResultContractMapper;
+}
+
+export class RunL1ValidatorsUseCase {
+  private readonly itTestFileAnalyzerPort: ItTestFileAnalyzerPort;
+  private readonly sourceFileTextScannerPort: SourceFileTextScannerPort;
+  private readonly cliCommandRegistryPort: CliCommandRegistryPort | undefined;
+  private readonly e2eTestFileRegistryPort: E2eTestFileRegistryPort | undefined;
+  private readonly mapper: ValidationResultContractMapper;
+  private readonly itTestMockDetectionService = new ItTestMockDetectionService();
+  private readonly stubCommentDetectionService = new StubCommentDetectionService();
+  private readonly cliE2eTestExistenceService = new CliE2eTestExistenceService();
+
+  constructor(deps: RunL1ValidatorsUseCaseDeps) {
+    this.itTestFileAnalyzerPort = deps.itTestFileAnalyzerPort;
+    this.sourceFileTextScannerPort = deps.sourceFileTextScannerPort;
+    this.cliCommandRegistryPort = deps.cliCommandRegistryPort;
+    this.e2eTestFileRegistryPort = deps.e2eTestFileRegistryPort;
+    this.mapper = deps.contractMapper;
+  }
+
+  async execute(input: RunL1ValidatorsInput): Promise<readonly ValidationResultContract[]> {
+    const results: ValidationResult[] = [];
+
+    results.push(await this.runL1017(input));
+    results.push(await this.runL1018(input));
+    results.push(await this.runL2013());
+
+    return this.mapper.toContracts(results);
+  }
+
+  /** H08-07: L1-017 ITテスト内部モック検出 */
+  private async runL1017(input: RunL1ValidatorsInput): Promise<ValidationResult> {
+    const validatorId = ValidatorId.create('L1-017');
+    const start = Date.now();
+    try {
+      const mockCalls = await this.itTestFileAnalyzerPort.findMockCallsInItTests(input.targetPaths);
+      const report = this.itTestMockDetectionService.detect(mockCalls);
+      const durationMs = Date.now() - start;
+      if (report.hasViolations()) {
+        const errors = report.toMessages().map((msg) => ({
+          code: { value: 'L1-017', toString: () => 'L1-017' },
+          severity: { value: 'error', toString: () => 'error' },
+          message: msg,
+          suggestion: 'IT tests should use real implementations. Remove vi.mock() on internal modules.',
+        }));
+        return ValidationResult.fail(validatorId, errors, durationMs);
+      }
+      return ValidationResult.pass(validatorId, durationMs);
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      return ValidationResult.fail(validatorId, [{
+        code: { value: 'L1-017', toString: () => 'L1-017' },
+        severity: { value: 'error', toString: () => 'error' },
+        message: `L1-017 execution failed: ${err instanceof Error ? err.message : String(err)}`,
+        suggestion: '',
+      }], durationMs);
+    }
+  }
+
+  /** H08-08: L1-018 スタブコメント残存検出 */
+  private async runL1018(input: RunL1ValidatorsInput): Promise<ValidationResult> {
+    const validatorId = ValidatorId.create('L1-018');
+    const start = Date.now();
+    try {
+      const matches = await this.sourceFileTextScannerPort.scanForPattern(
+        StubCommentDetectionService.STUB_COMMENT_PATTERN,
+        input.targetPaths,
+      );
+      const report = this.stubCommentDetectionService.detect(matches);
+      const durationMs = Date.now() - start;
+      if (report.hasViolations()) {
+        const errors = report.toMessages().map((msg) => ({
+          code: { value: 'L1-018', toString: () => 'L1-018' },
+          severity: { value: 'error', toString: () => 'error' },
+          message: msg,
+          suggestion: 'Replace stub implementations with real logic before merging.',
+        }));
+        return ValidationResult.fail(validatorId, errors, durationMs);
+      }
+      return ValidationResult.pass(validatorId, durationMs);
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      return ValidationResult.fail(validatorId, [{
+        code: { value: 'L1-018', toString: () => 'L1-018' },
+        severity: { value: 'error', toString: () => 'error' },
+        message: `L1-018 execution failed: ${err instanceof Error ? err.message : String(err)}`,
+        suggestion: '',
+      }], durationMs);
+    }
+  }
+
+  /** H08-09: L2-013 CLIコマンドE2Eテスト存在チェック (Should) */
+  private async runL2013(): Promise<ValidationResult> {
+    const validatorId = ValidatorId.create('L2-013');
+    if (!this.cliCommandRegistryPort || !this.e2eTestFileRegistryPort) {
+      return ValidationResult.skip(validatorId);
+    }
+    const start = Date.now();
+    try {
+      const commands = await this.cliCommandRegistryPort.getRegisteredCommands();
+      const e2eFiles = await this.e2eTestFileRegistryPort.getE2eTestFiles();
+      const report = this.cliE2eTestExistenceService.check(commands, e2eFiles);
+      const durationMs = Date.now() - start;
+      if (report.hasViolations()) {
+        const errors = report.toMessages().map((msg) => ({
+          code: { value: 'L2-013', toString: () => 'L2-013' },
+          severity: { value: 'error', toString: () => 'error' },
+          message: msg,
+          suggestion: 'Add an E2E test for each registered CLI command in cli-harness.test.ts.',
+        }));
+        return ValidationResult.fail(validatorId, errors, durationMs);
+      }
+      return ValidationResult.pass(validatorId, durationMs);
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      return ValidationResult.fail(validatorId, [{
+        code: { value: 'L2-013', toString: () => 'L2-013' },
+        severity: { value: 'error', toString: () => 'error' },
+        message: `L2-013 execution failed: ${err instanceof Error ? err.message : String(err)}`,
+        suggestion: '',
+      }], durationMs);
+    }
+  }
+}
+
+// @story-id H08-07

package/scripts/harness/validator-system/application/use-cases/run-l2-validators-usecase.ts

@@ -0,0 +1,130 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL2ValidatorsUseCase — H08-01: L2バリデータ実行
+ */
+import { readFile } from 'node:fs/promises';
+import { ValidatorId, InvalidValidatorIdError } from '../../domain/value-objects/validator-id.js';
+import { ValidationResult, type HarnessErrorLike } from '../../domain/value-objects/validation-result.js';
+import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
+import { ValidatorExecutionService, ValidatorExecutionError } from '../../domain/services/validator-execution-service.js';
+import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+import type { RunL2ValidatorsInput } from '../dto/run-l2-validators-input.js';
+import type { ValidatorConfigPort } from '../../domain/ports/validator-config-port.js';
+import type { PhaseGatePolicyPort } from '../../domain/ports/phase-gate-policy-port.js';
+import type { MetadataPolicyPort } from '../../domain/ports/metadata-policy-port.js';
+import type { TestQualityAnalyzerPort } from '../../domain/ports/test-quality-analyzer-port.js';
+
+export interface RunL2ValidatorsUseCaseDeps {
+  validatorRegistry: ValidatorRegistry;
+  validatorExecutionService: ValidatorExecutionService;
+  validatorConfigPort: ValidatorConfigPort;
+  contractMapper: ValidationResultContractMapper;
+  phaseGatePolicyPort?: PhaseGatePolicyPort;
+  metadataPolicyPort?: MetadataPolicyPort;
+  testQualityAnalyzerPort?: TestQualityAnalyzerPort;
+}
+
+export class RunL2ValidatorsUseCase {
+  private readonly registry: ValidatorRegistry;
+  private readonly executionService: ValidatorExecutionService;
+  private readonly configPort: ValidatorConfigPort;
+  private readonly mapper: ValidationResultContractMapper;
+  private readonly phaseGatePolicyPort?: PhaseGatePolicyPort;
+  private readonly metadataPolicyPort?: MetadataPolicyPort;
+  private readonly testQualityAnalyzerPort?: TestQualityAnalyzerPort;
+
+  constructor(deps: RunL2ValidatorsUseCaseDeps) {
+    this.registry = deps.validatorRegistry;
+    this.executionService = deps.validatorExecutionService;
+    this.configPort = deps.validatorConfigPort;
+    this.mapper = deps.contractMapper;
+    this.phaseGatePolicyPort = deps.phaseGatePolicyPort;
+    this.metadataPolicyPort = deps.metadataPolicyPort;
+    this.testQualityAnalyzerPort = deps.testQualityAnalyzerPort;
+  }
+
+  async execute(input: RunL2ValidatorsInput): Promise<readonly ValidationResultContract[]> {
+    // バリデータID解決
+    let validatorIds: readonly ValidatorId[];
+    if (input.validatorIds && input.validatorIds.length > 0) {
+      validatorIds = input.validatorIds.map((id) => ValidatorId.create(id));
+    } else {
+      validatorIds = this.registry.listByLayer('L2').map((d) => d.validatorId);
+    }
+
+    const definitions = this.registry.select(validatorIds);
+
+    // LayerConfig取得
+    let layerConfig;
+    try {
+      layerConfig = await this.configPort.getLayerConfig('L2');
+    } catch (err) {
+      throw new ValidatorExecutionError(`Failed to get L2 LayerConfig: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+
+    const results = this.executionService.execute(definitions, [layerConfig]);
+    const overrideMap = new Map<string, ValidationResult>(results.map((result) => [result.validatorId.value, result]));
+
+    if (this.phaseGatePolicyPort) {
+      const l2001Result = overrideMap.get('L2-001');
+      if (l2001Result && !l2001Result.skipped) {
+        const policyResult = await this.phaseGatePolicyPort.checkPrerequisites({
+          unitName: input.unitName,
+          currentPhase: input.currentPhase,
+        });
+        if (!policyResult.satisfied) {
+          overrideMap.set(
+            'L2-001',
+            ValidationResult.fail(
+              ValidatorId.create('L2-001'),
+              [...policyResult.violations],
+              0,
+            ),
+          );
+        }
+      }
+    }
+
+    if (this.metadataPolicyPort) {
+      const l2002Result = overrideMap.get('L2-002');
+      if (l2002Result && !l2002Result.skipped) {
+        const allErrors: HarnessErrorLike[] = [];
+        for (const filePath of input.targetPaths) {
+          try {
+            const fileContent = await readFile(filePath, 'utf-8');
+            const policyResult = await this.metadataPolicyPort.validateMetadata({ filePath, fileContent });
+            if (!policyResult.passed) {
+              allErrors.push(...policyResult.errors);
+            }
+          } catch {
+            // skip unreadable files
+          }
+        }
+        if (allErrors.length > 0) {
+          overrideMap.set('L2-002', ValidationResult.fail(ValidatorId.create('L2-002'), allErrors, 0));
+        }
+      }
+    }
+
+    if (this.testQualityAnalyzerPort) {
+      const l2003Result = overrideMap.get('L2-003');
+      if (l2003Result && !l2003Result.skipped) {
+        const analysisResult = await this.testQualityAnalyzerPort.analyzeTestFiles(input.targetPaths);
+        const allViolations: HarnessErrorLike[] = analysisResult.results
+          .filter((r) => !r.passed)
+          .flatMap((r) => [...r.violations]);
+        if (allViolations.length > 0) {
+          overrideMap.set('L2-003', ValidationResult.fail(ValidatorId.create('L2-003'), allViolations, 0));
+        }
+      }
+    }
+
+    const finalResults = definitions.map(
+      (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
+    );
+    return this.mapper.toContracts(finalResults);
+  }
+}

package/scripts/harness/validator-system/application/use-cases/run-l3-validators-usecase.ts

@@ -0,0 +1,156 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL3ValidatorsUseCase — H08-02: L3バリデータ実行
+ */
+import { ValidatorId } from '../../domain/value-objects/validator-id.js';
+import { ValidationResult } from '../../domain/value-objects/validation-result.js';
+import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
+import { ValidatorExecutionService, ValidatorExecutionError } from '../../domain/services/validator-execution-service.js';
+import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+import type { RunL3ValidatorsInput } from '../dto/run-l3-validators-input.js';
+import type { ValidatorConfigPort } from '../../domain/ports/validator-config-port.js';
+import type { AcCoveragePolicyPort } from '../../domain/ports/ac-coverage-policy-port.js';
+import type { SecurityPatternScannerPort } from '../../domain/ports/security-pattern-scanner-port.js';
+import type { PerformanceScannerPort } from '../../domain/ports/performance-scanner-port.js';
+
+export class CoverageReportNotFoundError extends Error {
+  constructor(path: string) {
+    super(`Coverage report not found: ${path}`);
+    this.name = 'CoverageReportNotFoundError';
+  }
+}
+
+export interface RunL3ValidatorsUseCaseDeps {
+  validatorRegistry: ValidatorRegistry;
+  validatorExecutionService: ValidatorExecutionService;
+  validatorConfigPort: ValidatorConfigPort;
+  contractMapper: ValidationResultContractMapper;
+  acCoveragePolicyPort?: AcCoveragePolicyPort;
+  coverageReportPort?: { getCoverage(): Promise<{ overallCoverage: number; perFileCoverage: readonly { filePath: string; coverage: number }[] }> };
+  securityScannerPort?: SecurityPatternScannerPort;
+  performanceScannerPort?: PerformanceScannerPort;
+}
+
+export class RunL3ValidatorsUseCase {
+  private readonly registry: ValidatorRegistry;
+  private readonly executionService: ValidatorExecutionService;
+  private readonly configPort: ValidatorConfigPort;
+  private readonly mapper: ValidationResultContractMapper;
+  private readonly acCoveragePolicyPort?: AcCoveragePolicyPort;
+  private readonly coverageReportPort?: RunL3ValidatorsUseCaseDeps['coverageReportPort'];
+  private readonly securityScannerPort?: SecurityPatternScannerPort;
+  private readonly performanceScannerPort?: PerformanceScannerPort;
+
+  constructor(deps: RunL3ValidatorsUseCaseDeps) {
+    this.registry = deps.validatorRegistry;
+    this.executionService = deps.validatorExecutionService;
+    this.configPort = deps.validatorConfigPort;
+    this.mapper = deps.contractMapper;
+    this.acCoveragePolicyPort = deps.acCoveragePolicyPort;
+    this.coverageReportPort = deps.coverageReportPort;
+    this.securityScannerPort = deps.securityScannerPort;
+    this.performanceScannerPort = deps.performanceScannerPort;
+  }
+
+  async execute(input: RunL3ValidatorsInput): Promise<readonly ValidationResultContract[]> {
+    let validatorIds: readonly ValidatorId[];
+    if (input.validatorIds && input.validatorIds.length > 0) {
+      validatorIds = input.validatorIds.map((id) => ValidatorId.create(id));
+    } else {
+      validatorIds = this.registry.listByLayer('L3').map((d) => d.validatorId);
+    }
+
+    const definitions = this.registry.select(validatorIds);
+
+    let layerConfig;
+    try {
+      layerConfig = await this.configPort.getLayerConfig('L3');
+    } catch (err) {
+      throw new ValidatorExecutionError(`Failed to get L3 LayerConfig: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+
+    // LayerConfig.enabled === false の場合は空を返す
+    if (!layerConfig.enabled) {
+      return [];
+    }
+
+    // coverageReportPort が存在する場合、カバレッジを取得して判定
+    if (this.coverageReportPort) {
+      const coverageData = await this.coverageReportPort.getCoverage();
+      const threshold = layerConfig.getThreshold('coverageThreshold');
+
+      // カバレッジ不足の場合は fail 結果を生成
+      if (threshold !== null && coverageData.overallCoverage < threshold) {
+        const deficit = threshold - coverageData.overallCoverage;
+
+        // 他のバリデータを実行
+        const otherDefs = definitions.filter((d) => d.validatorId.value !== 'L3-003');
+        const otherResults = this.executionService.execute(otherDefs, [layerConfig]);
+        const otherContracts = this.mapper.toContracts(otherResults);
+
+        return [
+          ...otherContracts.filter((r) => r.validatorId !== 'L3-003'),
+          {
+            validatorId: 'L3-003',
+            passed: false,
+            errors: [{ code: 'L3-003', severity: 'error', message: `カバレッジ不足: 現在値 ${coverageData.overallCoverage}%、不足 ${deficit}%` , suggestion: `テストカバレッジを ${threshold}% 以上に引き上げてください` }],
+            durationMs: 0,
+            skipped: false,
+          },
+        ];
+      }
+    }
+
+    const results = this.executionService.execute(definitions, [layerConfig]);
+    const overrideMap = new Map<string, ValidationResult>(results.map((result) => [result.validatorId.value, result]));
+
+    if (this.securityScannerPort) {
+      const l3001Result = overrideMap.get('L3-001');
+      if (l3001Result && !l3001Result.skipped) {
+        const scanResult = await this.securityScannerPort.scan(input.targetPaths);
+        if (!scanResult.passed) {
+          overrideMap.set('L3-001', ValidationResult.fail(ValidatorId.create('L3-001'), [...scanResult.findings], 0));
+        }
+      }
+    }
+
+    if (this.performanceScannerPort) {
+      const l3002Result = overrideMap.get('L3-002');
+      if (l3002Result && !l3002Result.skipped) {
+        const bundleSizeLimit = layerConfig.getThreshold('bundleSizeLimit');
+        const thresholds: Record<string, number> = bundleSizeLimit !== null ? { bundleSizeLimit } : {};
+        const scanResult = await this.performanceScannerPort.scan(input.targetPaths, thresholds);
+        if (!scanResult.passed) {
+          overrideMap.set('L3-002', ValidationResult.fail(ValidatorId.create('L3-002'), [...scanResult.findings], 0));
+        }
+      }
+    }
+
+    if (this.acCoveragePolicyPort) {
+      const l3004Result = overrideMap.get('L3-004');
+      if (l3004Result && !l3004Result.skipped) {
+        const policyResult = await this.acCoveragePolicyPort.checkCoverage({
+          matrixFilePath: input.requirementMatrixPath,
+        });
+        if (!policyResult.passed) {
+          overrideMap.set(
+            'L3-004',
+            ValidationResult.fail(
+              ValidatorId.create('L3-004'),
+              [...policyResult.errors],
+              0,
+            ),
+          );
+        }
+      }
+    }
+
+    const finalResults = definitions.map(
+      (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
+    );
+    return this.mapper.toContracts(finalResults);
+  }
+}

package/scripts/harness/validator-system/application/use-cases/run-l4-validators-usecase.ts

@@ -0,0 +1,124 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL4ValidatorsUseCase — H08-03: L4バリデータ実行
+ */
+import { ValidatorId } from '../../domain/value-objects/validator-id.js';
+import { ValidationResult } from '../../domain/value-objects/validation-result.js';
+import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
+import { ValidatorExecutionService, ValidatorExecutionError } from '../../domain/services/validator-execution-service.js';
+import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+import type { RunL4ValidatorsInput } from '../dto/run-l4-validators-input.js';
+import type { ValidatorConfigPort } from '../../domain/ports/validator-config-port.js';
+import type { DriftDetectionService } from '../../domain/services/l4/drift-detection-service.js';
+import type { ConsistencyCheckService } from '../../domain/services/l4/consistency-check-service.js';
+import type { DeadCodeDetectionService } from '../../domain/services/l4/dead-code-detection-service.js';
+
+export class DesignDocumentReadError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DesignDocumentReadError';
+  }
+}
+
+export interface RunL4ValidatorsUseCaseDeps {
+  validatorRegistry: ValidatorRegistry;
+  validatorExecutionService: ValidatorExecutionService;
+  validatorConfigPort: ValidatorConfigPort;
+  contractMapper: ValidationResultContractMapper;
+  driftDetectionService?: DriftDetectionService;
+  consistencyCheckService?: ConsistencyCheckService;
+  deadCodeDetectionService?: DeadCodeDetectionService;
+}
+
+export class RunL4ValidatorsUseCase {
+  private readonly registry: ValidatorRegistry;
+  private readonly executionService: ValidatorExecutionService;
+  private readonly configPort: ValidatorConfigPort;
+  private readonly mapper: ValidationResultContractMapper;
+  private readonly driftDetectionService?: DriftDetectionService;
+  private readonly consistencyCheckService?: ConsistencyCheckService;
+  private readonly deadCodeDetectionService?: DeadCodeDetectionService;
+
+  constructor(deps: RunL4ValidatorsUseCaseDeps) {
+    this.registry = deps.validatorRegistry;
+    this.executionService = deps.validatorExecutionService;
+    this.configPort = deps.validatorConfigPort;
+    this.mapper = deps.contractMapper;
+    this.driftDetectionService = deps.driftDetectionService;
+    this.consistencyCheckService = deps.consistencyCheckService;
+    this.deadCodeDetectionService = deps.deadCodeDetectionService;
+  }
+
+  async execute(input: RunL4ValidatorsInput): Promise<readonly ValidationResultContract[]> {
+    let validatorIds: readonly ValidatorId[];
+    if (input.validatorIds && input.validatorIds.length > 0) {
+      validatorIds = input.validatorIds.map((id) => ValidatorId.create(id));
+    } else {
+      validatorIds = this.registry.listByLayer('L4').map((d) => d.validatorId);
+    }
+
+    const definitions = this.registry.select(validatorIds);
+
+    let layerConfig;
+    try {
+      layerConfig = await this.configPort.getLayerConfig('L4');
+    } catch (err) {
+      throw new ValidatorExecutionError(`Failed to get L4 LayerConfig: ${err instanceof Error ? err.message : String(err)}`, err);
+    }
+
+    const results = this.executionService.execute(definitions, [layerConfig]);
+    const overrideMap = new Map<string, ValidationResult>(results.map((result) => [result.validatorId.value, result]));
+
+    if (this.driftDetectionService) {
+      const l4001Result = overrideMap.get('L4-001');
+      if (l4001Result && !l4001Result.skipped) {
+        const driftReports = await this.driftDetectionService.detect(input.targetUnits ? [...input.targetUnits] : undefined);
+        if (driftReports.length > 0) {
+          overrideMap.set(
+            'L4-001',
+            ValidationResult.fail(
+              ValidatorId.create('L4-001'),
+              driftReports.map((r) => r.toHarnessError()),
+              0,
+            ),
+          );
+        }
+      }
+    }
+
+    if (this.consistencyCheckService) {
+      const l4002Result = overrideMap.get('L4-002');
+      if (l4002Result && !l4002Result.skipped) {
+        const report = await this.consistencyCheckService.check(input.targetUnits ? [...input.targetUnits] : undefined);
+        if (report.hasMismatches()) {
+          overrideMap.set(
+            'L4-002',
+            ValidationResult.fail(ValidatorId.create('L4-002'), [...report.toHarnessErrors()], 0),
+          );
+        }
+      }
+    }
+
+    if (this.deadCodeDetectionService) {
+      const l4003Result = overrideMap.get('L4-003');
+      if (l4003Result && !l4003Result.skipped) {
+        const strictOnly = input.strictMode ?? layerConfig.strictOnly ?? false;
+        const report = await this.deadCodeDetectionService.detect({ strictOnly });
+        if (report.hasDeadCode()) {
+          overrideMap.set(
+            'L4-003',
+            ValidationResult.fail(ValidatorId.create('L4-003'), [...report.toHarnessErrors()], 0),
+          );
+        }
+      }
+    }
+
+    const finalResults = definitions.map(
+      (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
+    );
+    return this.mapper.toContracts(finalResults);
+  }
+}