phasegate 0.15.0

package/scripts/harness/regression-suite/composition-root.ts

@@ -0,0 +1,98 @@
+/**
+ * @unit regression-suite
+ *
+ * Composition Root - wires all dependencies together
+ */
+
+import * as path from 'node:path';
+
+// Infrastructure Adapters
+import { StaticSuiteRegistryAdapter } from './infrastructure/adapters/static-suite-registry-adapter.js';
+import { VitestTestRunnerAdapter } from './infrastructure/adapters/vitest-test-runner-adapter.js';
+import { HarnessConfigQueryAdapter } from './infrastructure/adapters/harness-config-query-adapter.js';
+import { JsonCiGateResultWriterAdapter } from './infrastructure/adapters/json-ci-gate-result-writer-adapter.js';
+import { BiomeAstImportAnalyzerAdapter } from './infrastructure/adapters/biome-ast-import-analyzer-adapter.js';
+import { FileSystemV0SpecReaderAdapter } from './infrastructure/adapters/file-system-v0-spec-reader-adapter.js';
+import { MarkdownMigrationMappingRepositoryAdapter } from './infrastructure/adapters/markdown-migration-mapping-repository-adapter.js';
+
+// Application Use Cases
+import { RunKRequirementsRegressionUseCase } from './application/usecases/run-k-requirements-regression-usecase.js';
+import { RunGngGateRegressionUseCase } from './application/usecases/run-gng-gate-regression-usecase.js';
+import { RunAgentIndependenceGuardUseCase } from './application/usecases/run-agent-independence-guard-usecase.js';
+import { RunK14K15RegressionUseCase } from './application/usecases/run-k14-k15-regression-usecase.js';
+import { ConfigureCiGateUseCase } from './application/usecases/configure-ci-gate-usecase.js';
+import { AnalyzeV0MigrationUseCase } from './application/usecases/analyze-v0-migration-usecase.js';
+import { MigrateV0TestsUseCase } from './application/usecases/migrate-v0-tests-usecase.js';
+
+export interface RegressionSuiteCompositionRoot {
+  runKRequirementsRegressionUseCase: RunKRequirementsRegressionUseCase;
+  runGngGateRegressionUseCase: RunGngGateRegressionUseCase;
+  runAgentIndependenceGuardUseCase: RunAgentIndependenceGuardUseCase;
+  runK14K15RegressionUseCase: RunK14K15RegressionUseCase;
+  configureCiGateUseCase: ConfigureCiGateUseCase;
+  analyzeV0MigrationUseCase: AnalyzeV0MigrationUseCase;
+  migrateV0TestsUseCase: MigrateV0TestsUseCase;
+}
+
+export function buildRegressionSuite(baseDir: string): RegressionSuiteCompositionRoot {
+  // Infrastructure adapters
+  const suiteRegistryPort = new StaticSuiteRegistryAdapter();
+  const testRunnerPort = new VitestTestRunnerAdapter();
+  const configQueryPort = new HarnessConfigQueryAdapter();
+  const ciGateResultWriterPort = new JsonCiGateResultWriterAdapter(baseDir);
+  const importAnalyzerPort = new BiomeAstImportAnalyzerAdapter();
+  const v0SpecReaderPort = new FileSystemV0SpecReaderAdapter(baseDir);
+  const migrationMappingRepositoryPort = new MarkdownMigrationMappingRepositoryAdapter(
+    path.join(baseDir, 'migration-mappings.md'),
+  );
+
+  // Use cases
+  const runKRequirementsRegressionUseCase = new RunKRequirementsRegressionUseCase(
+    suiteRegistryPort,
+    testRunnerPort,
+    configQueryPort,
+    ciGateResultWriterPort,
+  );
+
+  const runGngGateRegressionUseCase = new RunGngGateRegressionUseCase(
+    suiteRegistryPort,
+    testRunnerPort,
+    configQueryPort,
+    ciGateResultWriterPort,
+  );
+
+  const runAgentIndependenceGuardUseCase = new RunAgentIndependenceGuardUseCase(
+    suiteRegistryPort,
+    importAnalyzerPort,
+    ciGateResultWriterPort,
+  );
+
+  const runK14K15RegressionUseCase = new RunK14K15RegressionUseCase(
+    suiteRegistryPort,
+    testRunnerPort,
+    configQueryPort,
+    ciGateResultWriterPort,
+  );
+
+  const configureCiGateUseCase = new ConfigureCiGateUseCase(configQueryPort);
+
+  const analyzeV0MigrationUseCase = new AnalyzeV0MigrationUseCase(
+    v0SpecReaderPort,
+    migrationMappingRepositoryPort,
+  );
+
+  const migrateV0TestsUseCase = new MigrateV0TestsUseCase(
+    v0SpecReaderPort,
+    migrationMappingRepositoryPort,
+  );
+
+  return {
+    runKRequirementsRegressionUseCase,
+    runGngGateRegressionUseCase,
+    runAgentIndependenceGuardUseCase,
+    runK14K15RegressionUseCase,
+    configureCiGateUseCase,
+    analyzeV0MigrationUseCase,
+    migrateV0TestsUseCase,
+  };
+}

package/scripts/harness/regression-suite/domain/aggregates/v0-test-migration.ts

@@ -0,0 +1,94 @@
+import type { V0TestId } from '../value-objects/v0-test-id.js';
+import type { V1TestPath } from '../value-objects/v1-test-path.js';
+import type { BiomeModificationSpec } from '../value-objects/biome-modification-spec.js';
+import { MigrationMapping } from '../value-objects/migration-mapping.js';
+
+export type MigrationStatus = 'pending' | 'migrated' | 'modified' | 'skipped';
+export type SkipReason = 'out-of-scope' | 'orchestration-migrated';
+
+export class V0TestMigration {
+  readonly v0TestId: V0TestId;
+  private _migrationStatus: MigrationStatus;
+  private _v1TestPath: V1TestPath | null;
+  private _biomeModificationSpec: BiomeModificationSpec | null;
+  private _skipReason: SkipReason | null;
+
+  private constructor(v0TestId: V0TestId) {
+    this.v0TestId = v0TestId;
+    this._migrationStatus = 'pending';
+    this._v1TestPath = null;
+    this._biomeModificationSpec = null;
+    this._skipReason = null;
+  }
+
+  static create(v0TestId: V0TestId): V0TestMigration {
+    // V0TestId already validates that path is non-empty
+    return new V0TestMigration(v0TestId);
+  }
+
+  get migrationStatus(): MigrationStatus {
+    return this._migrationStatus;
+  }
+
+  get v1TestPath(): V1TestPath | null {
+    return this._v1TestPath;
+  }
+
+  get biomeModificationSpec(): BiomeModificationSpec | null {
+    return this._biomeModificationSpec;
+  }
+
+  get skipReason(): SkipReason | null {
+    return this._skipReason;
+  }
+
+  migrate(v1TestPath: V1TestPath): void {
+    if (this._migrationStatus !== 'pending') {
+      throw new Error(
+        `MigrationAlreadyCompletedError: Cannot migrate from status '${this._migrationStatus}'`
+      );
+    }
+    this._migrationStatus = 'migrated';
+    this._v1TestPath = v1TestPath;
+    this._biomeModificationSpec = null;
+    this._skipReason = null;
+  }
+
+  migrateWithModification(v1TestPath: V1TestPath, biomeSpec: BiomeModificationSpec): void {
+    if (this._migrationStatus !== 'pending') {
+      throw new Error(
+        `MigrationAlreadyCompletedError: Cannot migrateWithModification from status '${this._migrationStatus}'`
+      );
+    }
+    this._migrationStatus = 'modified';
+    this._v1TestPath = v1TestPath;
+    this._biomeModificationSpec = biomeSpec;
+    this._skipReason = null;
+  }
+
+  skip(reason: SkipReason): void {
+    if (this._migrationStatus !== 'pending') {
+      throw new Error(
+        `MigrationAlreadyCompletedError: Cannot skip from status '${this._migrationStatus}'`
+      );
+    }
+    this._migrationStatus = 'skipped';
+    this._skipReason = reason;
+    this._v1TestPath = null;
+    this._biomeModificationSpec = null;
+  }
+
+  toMigrationMapping(): MigrationMapping {
+    if (this._migrationStatus !== 'migrated' && this._migrationStatus !== 'modified') {
+      throw new Error(
+        `InvalidMigrationStateError: Cannot create MigrationMapping from status '${this._migrationStatus}'`
+      );
+    }
+    return MigrationMapping.create({
+      v0TestId: this.v0TestId,
+      v1TestPath: this._v1TestPath!,
+      migrationStatus: this._migrationStatus,
+      biomeModification: this._biomeModificationSpec,
+    });
+  }
+}

package/scripts/harness/regression-suite/domain/ports/ci-gate-result-writer-port.ts

@@ -0,0 +1,6 @@
+import type { SuiteIdValue } from '../value-objects/suite-id.js';
+import type { TestExecutionSummary } from '../value-objects/test-execution-summary.js';
+
+export interface CiGateResultWriterPort {
+  write(suiteId: SuiteIdValue, summary: TestExecutionSummary): Promise<void>;
+}

package/scripts/harness/regression-suite/domain/ports/config-query-port.ts

@@ -0,0 +1,3 @@
+export interface ConfigQueryPort {
+  getCoverageThreshold(): Promise<number>;
+}

package/scripts/harness/regression-suite/domain/ports/import-analyzer-port.ts

@@ -0,0 +1,3 @@
+export interface ImportAnalyzerPort {
+  analyzeImports(targetModule: string): Promise<string[]>;
+}

package/scripts/harness/regression-suite/domain/ports/migration-mapping-repository-port.ts

@@ -0,0 +1,9 @@
+import type { V0TestMigration } from '../aggregates/v0-test-migration.js';
+import type { V0TestId } from '../value-objects/v0-test-id.js';
+import type { MigrationMapping } from '../value-objects/migration-mapping.js';
+
+export interface MigrationMappingRepositoryPort {
+  save(migration: V0TestMigration): Promise<void>;
+  findAll(): Promise<MigrationMapping[]>;
+  findById(v0TestId: V0TestId): Promise<MigrationMapping | null>;
+}

package/scripts/harness/regression-suite/domain/ports/suite-registry-port.ts

@@ -0,0 +1,6 @@
+import type { SuiteId } from '../value-objects/suite-id.js';
+import type { RegressionSuiteDefinition } from '../value-objects/regression-suite-definition.js';
+
+export interface SuiteRegistryPort {
+  getDefinition(suiteId: SuiteId): Promise<RegressionSuiteDefinition>;
+}

package/scripts/harness/regression-suite/domain/ports/test-runner-port.ts

@@ -0,0 +1,16 @@
+import type { TestCase } from '../value-objects/regression-suite-definition.js';
+import type { CoverageRate } from '../value-objects/coverage-rate.js';
+import type { TestFailureDetail } from '../value-objects/test-failure-detail.js';
+
+export interface TestRunnerResult {
+  passedCount: number;
+  failedCount: number;
+  skippedCount: number;
+  totalCount: number;
+  coverageRate: CoverageRate | null;
+  failures: TestFailureDetail[];
+}
+
+export interface TestRunnerPort {
+  runSuite(testCases: ReadonlyArray<TestCase>): Promise<TestRunnerResult>;
+}

package/scripts/harness/regression-suite/domain/ports/v0-spec-reader-port.ts

@@ -0,0 +1,5 @@
+import type { V0TestId } from '../value-objects/v0-test-id.js';
+
+export interface V0SpecReaderPort {
+  readAll(): Promise<V0TestId[]>;
+}

package/scripts/harness/regression-suite/domain/services/import-guard-service.ts

@@ -0,0 +1,38 @@
+import type { AgentIndependenceTest } from '../value-objects/agent-independence-test.js';
+import { ImportViolation } from '../value-objects/import-violation.js';
+import type { ImportAnalyzerPort } from '../ports/import-analyzer-port.js';
+
+export class ImportGuardService {
+  constructor(private readonly importAnalyzerPort: ImportAnalyzerPort) {}
+
+  async verify(test: AgentIndependenceTest): Promise<ImportViolation[]> {
+    const foundImports = await this.importAnalyzerPort.analyzeImports(test.targetModule);
+
+    // Check if target module is in allowed paths
+    const isAllowed = test.allowedPaths.some((allowedPath) =>
+      test.targetModule.includes(allowedPath)
+    );
+
+    if (isAllowed) {
+      return [];
+    }
+
+    const violations: ImportViolation[] = [];
+    for (const foundImport of foundImports) {
+      for (const forbiddenPattern of test.forbiddenPatterns) {
+        if (foundImport.includes(forbiddenPattern)) {
+          violations.push(
+            ImportViolation.create({
+              modulePath: test.targetModule,
+              forbiddenPackage: forbiddenPattern,
+              violationMessage: `Forbidden import detected: ${forbiddenPattern} in ${test.targetModule}`,
+            })
+          );
+          break;
+        }
+      }
+    }
+
+    return violations;
+  }
+}

package/scripts/harness/regression-suite/domain/services/migration-analyzer.ts

@@ -0,0 +1,72 @@
+import { V0TestMigration } from '../aggregates/v0-test-migration.js';
+import { V1TestPath } from '../value-objects/v1-test-path.js';
+import { BiomeModificationSpec } from '../value-objects/biome-modification-spec.js';
+import type { V0SpecReaderPort } from '../ports/v0-spec-reader-port.js';
+import type { MigrationMappingRepositoryPort } from '../ports/migration-mapping-repository-port.js';
+
+export interface MigrationAnalyzerOptions {
+  dryRun?: boolean;
+  outOfScopePattern?: string[];
+  orchestrationMigratedPattern?: string[];
+  biomeModificationRequired?: boolean;
+}
+
+export class MigrationAnalyzer {
+  constructor(
+    private readonly v0SpecReaderPort: V0SpecReaderPort,
+    private readonly migrationMappingRepositoryPort: MigrationMappingRepositoryPort
+  ) {}
+
+  async analyzeAll(options: MigrationAnalyzerOptions = {}): Promise<readonly V0TestMigration[]> {
+    let v0TestIds;
+    try {
+      v0TestIds = await this.v0SpecReaderPort.readAll();
+    } catch (err) {
+      throw new Error(`V0SpecReadError: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    const migrations: V0TestMigration[] = [];
+
+    for (const v0TestId of v0TestIds) {
+      const migration = V0TestMigration.create(v0TestId);
+
+      // Check out-of-scope patterns
+      if (options.outOfScopePattern?.some((pattern) => v0TestId.value.includes(pattern))) {
+        migration.skip('out-of-scope');
+      } else if (
+        options.orchestrationMigratedPattern?.some((pattern) => v0TestId.value.includes(pattern))
+      ) {
+        migration.skip('orchestration-migrated');
+      } else if (options.biomeModificationRequired) {
+        // Biome modification required
+        const v1TestPath = V1TestPath.create(
+          v0TestId.value.replace('scripts/__tests__/', 'scripts/harness/__tests__/unit/')
+        );
+        const biomeSpec = BiomeModificationSpec.create({
+          targetApi: 'eslint-plugin-api',
+          replacementApi: 'biome-lint-rule',
+          modificationReason: 'ESLint固有APIをBiome対応APIに置換',
+        });
+        migration.migrateWithModification(v1TestPath, biomeSpec);
+      } else {
+        // Normal migration
+        const v1TestPath = V1TestPath.create(
+          v0TestId.value.replace('scripts/__tests__/', 'scripts/harness/__tests__/unit/')
+        );
+        migration.migrate(v1TestPath);
+      }
+
+      if (!options.dryRun) {
+        try {
+          await this.migrationMappingRepositoryPort.save(migration);
+        } catch (err) {
+          throw new Error(`MigrationPersistenceError: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+
+      migrations.push(migration);
+    }
+
+    return migrations;
+  }
+}

package/scripts/harness/regression-suite/domain/services/regression-runner.ts

@@ -0,0 +1,90 @@
+import type { SuiteId } from '../value-objects/suite-id.js';
+import { TestExecutionSummary } from '../value-objects/test-execution-summary.js';
+import { TestFailureDetail } from '../value-objects/test-failure-detail.js';
+import type { AgentIndependenceTest } from '../value-objects/agent-independence-test.js';
+import type { SuiteRegistryPort } from '../ports/suite-registry-port.js';
+import type { TestRunnerPort } from '../ports/test-runner-port.js';
+import type { ConfigQueryPort } from '../ports/config-query-port.js';
+import type { CiGateResultWriterPort } from '../ports/ci-gate-result-writer-port.js';
+import type { ImportGuardService } from './import-guard-service.js';
+
+export class RegressionRunner {
+  constructor(
+    private readonly suiteRegistryPort: SuiteRegistryPort,
+    private readonly testRunnerPort: TestRunnerPort,
+    private readonly importGuardService: ImportGuardService,
+    private readonly configQueryPort: ConfigQueryPort,
+    private readonly ciGateResultWriterPort: CiGateResultWriterPort
+  ) {}
+
+  async execute(suiteId: SuiteId, coverageThreshold?: number): Promise<TestExecutionSummary> {
+    let definition;
+    try {
+      definition = await this.suiteRegistryPort.getDefinition(suiteId);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes('SuiteDefinitionNotFoundError')) {
+        throw err;
+      }
+      throw new Error(`SuiteDefinitionNotFoundError: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    const threshold = coverageThreshold ?? (await this.configQueryPort.getCoverageThreshold());
+
+    let summary: TestExecutionSummary;
+
+    if (suiteId.value === 'agent-independence') {
+      // Run import guard checks
+      const agentTests = definition.testCases as AgentIndependenceTest[];
+      const allViolations: Array<{ testCaseId: string; errorMessage: string }> = [];
+
+      for (const test of agentTests) {
+        try {
+          const violations = await this.importGuardService.verify(test);
+          for (const v of violations) {
+            allViolations.push({
+              testCaseId: test.targetModule,
+              errorMessage: v.violationMessage,
+            });
+          }
+        } catch (err) {
+          throw new Error(`ImportAnalysisPortError: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+
+      const failedCount = allViolations.length;
+      const passedCount = agentTests.length - (failedCount > 0 ? failedCount : 0);
+      const totalCount = agentTests.length;
+
+      summary = TestExecutionSummary.create({
+        passedCount: failedCount > 0 ? 0 : passedCount,
+        failedCount,
+        skippedCount: 0,
+        totalCount,
+        coverageRate: null,
+        failures: allViolations.map((v) =>
+          TestFailureDetail.create({ testCaseId: v.testCaseId, errorMessage: v.errorMessage })
+        ),
+      });
+    } else {
+      let runResult;
+      try {
+        runResult = await this.testRunnerPort.runSuite(definition.testCases);
+      } catch (err) {
+        throw new Error(`TestRunnerPortError: ${err instanceof Error ? err.message : String(err)}`);
+      }
+
+      summary = TestExecutionSummary.create({
+        passedCount: runResult.passedCount,
+        failedCount: runResult.failedCount,
+        skippedCount: runResult.skippedCount,
+        totalCount: runResult.totalCount,
+        coverageRate: runResult.coverageRate,
+        failures: runResult.failures,
+      });
+    }
+
+    await this.ciGateResultWriterPort.write(suiteId.value, summary);
+
+    return summary;
+  }
+}

package/scripts/harness/regression-suite/domain/value-objects/agent-independence-test.ts

@@ -0,0 +1,35 @@
+export interface AgentIndependenceTestProps {
+  targetModule: string;
+  forbiddenPatterns: string[];
+  allowedPaths: string[];
+}
+
+export class AgentIndependenceTest {
+  readonly targetModule: string;
+  readonly forbiddenPatterns: ReadonlyArray<string>;
+  readonly allowedPaths: ReadonlyArray<string>;
+
+  private constructor(props: AgentIndependenceTestProps) {
+    this.targetModule = props.targetModule;
+    this.forbiddenPatterns = Object.freeze([...props.forbiddenPatterns]);
+    this.allowedPaths = Object.freeze([...props.allowedPaths]);
+    Object.freeze(this);
+  }
+
+  static create(props: AgentIndependenceTestProps): AgentIndependenceTest {
+    if (!props.targetModule || props.targetModule.trim().length === 0) {
+      throw new Error('InvalidAgentIndependenceTestError: targetModule must not be empty');
+    }
+    if (!props.forbiddenPatterns || props.forbiddenPatterns.length === 0) {
+      throw new Error('EmptyForbiddenPatternsError: forbiddenPatterns must have at least one entry');
+    }
+    return new AgentIndependenceTest(props);
+  }
+
+  equals(other: AgentIndependenceTest): boolean {
+    return (
+      this.targetModule === other.targetModule &&
+      JSON.stringify(this.forbiddenPatterns) === JSON.stringify(other.forbiddenPatterns)
+    );
+  }
+}

package/scripts/harness/regression-suite/domain/value-objects/biome-modification-spec.ts

@@ -0,0 +1,38 @@
+export interface BiomeModificationSpecProps {
+  targetApi: string;
+  replacementApi: string;
+  modificationReason: string;
+}
+
+export class BiomeModificationSpec {
+  readonly targetApi: string;
+  readonly replacementApi: string;
+  readonly modificationReason: string;
+
+  private constructor(props: BiomeModificationSpecProps) {
+    this.targetApi = props.targetApi;
+    this.replacementApi = props.replacementApi;
+    this.modificationReason = props.modificationReason;
+    Object.freeze(this);
+  }
+
+  static create(props: BiomeModificationSpecProps): BiomeModificationSpec {
+    if (!props.targetApi || props.targetApi.trim().length === 0) {
+      throw new Error('InvalidBiomeModificationSpecError: targetApi must not be empty');
+    }
+    if (!props.replacementApi || props.replacementApi.trim().length === 0) {
+      throw new Error('InvalidBiomeModificationSpecError: replacementApi must not be empty');
+    }
+    if (!props.modificationReason || props.modificationReason.trim().length === 0) {
+      throw new Error('InvalidBiomeModificationSpecError: modificationReason must not be empty');
+    }
+    if (props.targetApi === props.replacementApi) {
+      throw new Error('InvalidBiomeModificationSpecError: targetApi and replacementApi must be different');
+    }
+    return new BiomeModificationSpec(props);
+  }
+
+  equals(other: BiomeModificationSpec): boolean {
+    return this.targetApi === other.targetApi && this.replacementApi === other.replacementApi;
+  }
+}

package/scripts/harness/regression-suite/domain/value-objects/ci-gate-config.ts

@@ -0,0 +1,47 @@
+import type { SuiteId } from './suite-id.js';
+
+export type ExecutionMode = 'parallel' | 'sequential';
+
+export interface CiGateConfigProps {
+  requiredSuiteIds: SuiteId[];
+  coverageThreshold: number;
+  executionMode: ExecutionMode;
+}
+
+export class CiGateConfig {
+  readonly requiredSuiteIds: ReadonlyArray<SuiteId>;
+  readonly coverageThreshold: number;
+  readonly executionMode: ExecutionMode;
+
+  private constructor(props: CiGateConfigProps) {
+    this.requiredSuiteIds = Object.freeze([...props.requiredSuiteIds]);
+    this.coverageThreshold = props.coverageThreshold;
+    this.executionMode = props.executionMode;
+    Object.freeze(this);
+  }
+
+  static create(props: CiGateConfigProps): CiGateConfig {
+    if (props.coverageThreshold <= 0 || props.coverageThreshold > 100) {
+      throw new Error(
+        `InvalidCoverageThresholdError: coverageThreshold must be > 0 and <= 100, got ${props.coverageThreshold}`
+      );
+    }
+    if (!props.requiredSuiteIds || props.requiredSuiteIds.length === 0) {
+      throw new Error('InvalidCiGateConfigError: requiredSuiteIds must have at least one entry');
+    }
+    return new CiGateConfig(props);
+  }
+
+  isRequired(suiteId: SuiteId): boolean {
+    return this.requiredSuiteIds.some((id) => id.equals(suiteId));
+  }
+
+  equals(other: CiGateConfig): boolean {
+    return (
+      this.coverageThreshold === other.coverageThreshold &&
+      this.executionMode === other.executionMode &&
+      JSON.stringify(this.requiredSuiteIds.map((id) => id.value)) ===
+        JSON.stringify(other.requiredSuiteIds.map((id) => id.value))
+    );
+  }
+}

package/scripts/harness/regression-suite/domain/value-objects/coverage-rate.ts

@@ -0,0 +1,27 @@
+export class CoverageRate {
+  readonly value: number;
+
+  private constructor(value: number) {
+    this.value = value;
+    Object.freeze(this);
+  }
+
+  static create(value: number): CoverageRate {
+    if (value < 0 || value > 100) {
+      throw new Error(`InvalidCoverageRateError: CoverageRate must be between 0 and 100, got ${value}`);
+    }
+    return new CoverageRate(value);
+  }
+
+  meetsThreshold(threshold: number): boolean {
+    return this.value >= threshold;
+  }
+
+  equals(other: CoverageRate): boolean {
+    return this.value === other.value;
+  }
+
+  toString(): string {
+    return `${this.value}%`;
+  }
+}

package/scripts/harness/regression-suite/domain/value-objects/gng-condition-test.ts

@@ -0,0 +1,41 @@
+export interface GngConditionTestProps {
+  gngNumber: string;
+  targetUnit: string;
+  verificationCondition: string;
+}
+
+const VALID_GNG_NUMBERS: ReadonlySet<string> = new Set(['GNG-4', 'GNG-5', 'GNG-8']);
+
+export class GngConditionTest {
+  readonly gngNumber: string;
+  readonly targetUnit: string;
+  readonly verificationCondition: string;
+
+  private constructor(props: GngConditionTestProps) {
+    this.gngNumber = props.gngNumber;
+    this.targetUnit = props.targetUnit;
+    this.verificationCondition = props.verificationCondition;
+    Object.freeze(this);
+  }
+
+  static create(props: GngConditionTestProps): GngConditionTest {
+    if (!VALID_GNG_NUMBERS.has(props.gngNumber)) {
+      throw new Error(`InvalidGngNumberError: '${props.gngNumber}' is not a valid GNG number (GNG-4, GNG-5, GNG-8)`);
+    }
+    if (!props.targetUnit || props.targetUnit.trim().length === 0) {
+      throw new Error('InvalidGngConditionTestError: targetUnit must not be empty');
+    }
+    if (!props.verificationCondition || props.verificationCondition.trim().length === 0) {
+      throw new Error('InvalidGngConditionTestError: verificationCondition must not be empty');
+    }
+    return new GngConditionTest(props);
+  }
+
+  equals(other: GngConditionTest): boolean {
+    return (
+      this.gngNumber === other.gngNumber &&
+      this.targetUnit === other.targetUnit &&
+      this.verificationCondition === other.verificationCondition
+    );
+  }
+}