phasegate 0.15.0

package/scripts/harness/quick-mode/presentation/formatters/human-quick-mode-formatter.ts

@@ -0,0 +1,48 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ *
+ * 開発者向けコンソール表示フォーマッター
+ */
+
+import type { QuickModeDecisionContract } from '../../application/dto/quick-mode-decision-contract.js';
+
+export class HumanQuickModeFormatter {
+  format(decision: QuickModeDecisionContract): string {
+    const { eligibility, relaxationProfile } = decision;
+    const lines: string[] = [];
+
+    if (eligibility.eligible) {
+      lines.push('Quick Mode 判定: ✓ 承認');
+
+      if (relaxationProfile) {
+        lines.push('緩和プロファイル:');
+        lines.push('  L1: 全維持 (L1-001〜L1-008)');
+
+        const l2Maintained = [...relaxationProfile.l2.maintained].join(', ');
+        const l2Skipped = [...relaxationProfile.l2.skipped].join(', ');
+        lines.push(`  L2: 維持=[${l2Maintained}] / スキップ=[${l2Skipped}]`);
+
+        const l3Maintained = [...relaxationProfile.l3.maintained].join(', ');
+        const l3Skipped = [...relaxationProfile.l3.skipped].join(', ');
+        lines.push(`  L3: 維持=[${l3Maintained}] / スキップ=[${l3Skipped}]`);
+
+        lines.push('  L4: 全スキップ');
+        lines.push('  2-Phase Execution: 緩和済み');
+      }
+    } else {
+      lines.push('Quick Mode 判定: ✗ 拒否');
+      lines.push(`ルール: ${eligibility.rejectionRule ?? ''}`);
+      lines.push(`理由: ${eligibility.reason}`);
+
+      if (eligibility.rejectedFiles && eligibility.rejectedFiles.length > 0) {
+        lines.push('拒否対象ファイル:');
+        for (const file of eligibility.rejectedFiles) {
+          lines.push(`  - ${file.filePath} (${file.changeKind})`);
+        }
+      }
+    }
+
+    return lines.join('\n') + '\n';
+  }
+}

package/scripts/harness/quick-mode/presentation/formatters/json-quick-mode-formatter.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ *
+ * JSON出力フォーマッター
+ */
+
+import type { QuickModeDecisionContract } from '../../application/dto/quick-mode-decision-contract.js';
+
+export class JsonQuickModeFormatter {
+  format(decision: QuickModeDecisionContract): string {
+    return JSON.stringify(decision, null, 2) + '\n';
+  }
+}

package/scripts/harness/quick-mode/presentation/handlers/ci-check-quick-mode-handler.ts

@@ -0,0 +1,63 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ *
+ * harness:ci-check --quick フラグを受け取り、ExecuteQuickCiCheckUseCase を呼ぶハンドラー
+ */
+
+import { HumanQuickModeFormatter } from '../formatters/human-quick-mode-formatter.js';
+import { AgentQuickModeFormatter } from '../formatters/agent-quick-mode-formatter.js';
+import { JsonQuickModeFormatter } from '../formatters/json-quick-mode-formatter.js';
+import type { ExecuteQuickCiCheckUseCase } from '../../application/usecases/execute-quick-ci-check-usecase.js';
+import type { QuickModeRenderOptions } from '../dto/quick-mode-render-options.js';
+
+export interface CiCheckQuickModeHandlerDeps {
+  useCase: Pick<ExecuteQuickCiCheckUseCase, 'execute'>;
+}
+
+export class CiCheckQuickModeHandler {
+  private readonly useCase: Pick<ExecuteQuickCiCheckUseCase, 'execute'>;
+
+  constructor(deps: CiCheckQuickModeHandlerDeps) {
+    this.useCase = deps.useCase;
+  }
+
+  async handle(options: QuickModeRenderOptions): Promise<void> {
+    const { files, dryRun = false, format = 'human', failOnReject = false } = options;
+
+    // --files 解析: カンマ区切りのファイルパスを MODIFY として扱う
+    let changedFiles: { filePath: string; changeKind: string }[] | undefined;
+    if (files) {
+      changedFiles = files.split(',').map((p) => ({
+        filePath: p.trim(),
+        changeKind: 'MODIFY',
+      }));
+    }
+
+    let decision: Awaited<ReturnType<typeof this.useCase.execute>>;
+
+    try {
+      decision = await this.useCase.execute({ changedFiles, dryRun });
+    } catch (err) {
+      process.exit(2);
+      return; // TypeScript フロー解析のため
+    }
+
+    // フォーマット選択と出力
+    let output: string;
+    if (format === 'json') {
+      output = new JsonQuickModeFormatter().format(decision);
+    } else if (format === 'agent') {
+      output = new AgentQuickModeFormatter().format(decision);
+    } else {
+      output = new HumanQuickModeFormatter().format(decision);
+    }
+
+    process.stdout.write(output);
+
+    // 終了コード決定
+    if (failOnReject && !decision.eligibility.eligible) {
+      process.exit(1);
+    }
+  }
+}

package/scripts/harness/regression-suite/application/dto/analyze-migration-input.ts

@@ -0,0 +1,5 @@
+export interface AnalyzeMigrationInput {
+  dryRun?: boolean;
+  outOfScopePattern?: string[];
+  orchestrationMigratedPattern?: string[];
+}

package/scripts/harness/regression-suite/application/dto/analyze-migration-output.ts

@@ -0,0 +1,6 @@
+export interface AnalyzeMigrationOutput {
+  totalCount: number;
+  migratedCount: number;
+  modifiedCount: number;
+  skippedCount: number;
+}

package/scripts/harness/regression-suite/application/dto/configure-ci-gate-input.ts

@@ -0,0 +1,8 @@
+import type { SuiteIdValue } from '../../domain/value-objects/suite-id.js';
+import type { ExecutionMode } from '../../domain/value-objects/ci-gate-config.js';
+
+export interface ConfigureCiGateInput {
+  requiredSuiteIds: SuiteIdValue[];
+  coverageThreshold?: number;
+  executionMode: ExecutionMode;
+}

package/scripts/harness/regression-suite/application/dto/configure-ci-gate-output.ts

@@ -0,0 +1,8 @@
+import type { SuiteIdValue } from '../../domain/value-objects/suite-id.js';
+import type { ExecutionMode } from '../../domain/value-objects/ci-gate-config.js';
+
+export interface ConfigureCiGateOutput {
+  requiredSuiteIds: SuiteIdValue[];
+  coverageThreshold: number;
+  executionMode: ExecutionMode;
+}

package/scripts/harness/regression-suite/application/dto/migrate-v0-tests-input.ts

@@ -0,0 +1,5 @@
+export interface MigrateV0TestsInput {
+  confirmExecute?: boolean;
+  outOfScopePattern?: string[];
+  biomeModificationRequired?: boolean;
+}

package/scripts/harness/regression-suite/application/dto/migrate-v0-tests-output.ts

@@ -0,0 +1,18 @@
+export interface MigrationMappingOutput {
+  v0TestId: string;
+  v1TestPath: string;
+  migrationStatus: 'migrated' | 'modified';
+  biomeModification: {
+    targetApi: string;
+    replacementApi: string;
+    modificationReason: string;
+  } | null;
+}
+
+export interface MigrateV0TestsOutput {
+  mappings: MigrationMappingOutput[];
+  totalCount: number;
+  migratedCount: number;
+  modifiedCount: number;
+  skippedCount: number;
+}

package/scripts/harness/regression-suite/application/dto/run-regression-suite-input.ts

@@ -0,0 +1,7 @@
+import type { SuiteIdValue } from '../../domain/value-objects/suite-id.js';
+
+export interface RunRegressionSuiteInput {
+  suiteId?: SuiteIdValue;
+  kNumberFilter?: string[];
+  coverageThreshold?: number;
+}

package/scripts/harness/regression-suite/application/dto/run-regression-suite-output.ts

@@ -0,0 +1,15 @@
+export interface TestFailureDetailOutput {
+  testCaseId: string;
+  errorMessage: string;
+  stackTrace?: string;
+}
+
+export interface RunRegressionSuiteOutput {
+  passedCount: number;
+  failedCount: number;
+  skippedCount: number;
+  totalCount: number;
+  coverageRate: number | null;
+  failures: TestFailureDetailOutput[];
+  gateResult: 'go' | 'no-go';
+}

package/scripts/harness/regression-suite/application/mappers/migration-mapping-mapper.ts

@@ -0,0 +1,23 @@
+import type { V0TestMigration } from '../../domain/aggregates/v0-test-migration.js';
+import type { MigrationMappingOutput } from '../dto/migrate-v0-tests-output.js';
+
+export class MigrationMappingMapper {
+  static toOutput(migration: V0TestMigration): MigrationMappingOutput | null {
+    if (migration.migrationStatus === 'migrated' || migration.migrationStatus === 'modified') {
+      const mapping = migration.toMigrationMapping();
+      return {
+        v0TestId: mapping.v0TestId.value,
+        v1TestPath: mapping.v1TestPath.value,
+        migrationStatus: mapping.migrationStatus,
+        biomeModification: mapping.biomeModification
+          ? {
+              targetApi: mapping.biomeModification.targetApi,
+              replacementApi: mapping.biomeModification.replacementApi,
+              modificationReason: mapping.biomeModification.modificationReason,
+            }
+          : null,
+      };
+    }
+    return null;
+  }
+}

package/scripts/harness/regression-suite/application/mappers/test-execution-summary-mapper.ts

@@ -0,0 +1,25 @@
+import type { TestExecutionSummary } from '../../domain/value-objects/test-execution-summary.js';
+import type { RunRegressionSuiteOutput } from '../dto/run-regression-suite-output.js';
+
+export class TestExecutionSummaryMapper {
+  static toOutput(
+    summary: TestExecutionSummary,
+    coverageThreshold: number
+  ): RunRegressionSuiteOutput {
+    const gateResult = summary.isPassedGate(coverageThreshold) ? 'go' : 'no-go';
+
+    return {
+      passedCount: summary.passedCount,
+      failedCount: summary.failedCount,
+      skippedCount: summary.skippedCount,
+      totalCount: summary.totalCount,
+      coverageRate: summary.coverageRate?.value ?? null,
+      failures: summary.failures.map((f) => ({
+        testCaseId: f.testCaseId,
+        errorMessage: f.errorMessage,
+        stackTrace: f.stackTrace,
+      })),
+      gateResult,
+    };
+  }
+}

package/scripts/harness/regression-suite/application/usecases/analyze-v0-migration-usecase.ts

@@ -0,0 +1,38 @@
+import { MigrationAnalyzer } from '../../domain/services/migration-analyzer.js';
+import type { V0SpecReaderPort } from '../../domain/ports/v0-spec-reader-port.js';
+import type { MigrationMappingRepositoryPort } from '../../domain/ports/migration-mapping-repository-port.js';
+import type { AnalyzeMigrationInput } from '../dto/analyze-migration-input.js';
+import type { AnalyzeMigrationOutput } from '../dto/analyze-migration-output.js';
+
+export class AnalyzeV0MigrationUseCase {
+  private readonly migrationAnalyzer: MigrationAnalyzer;
+
+  constructor(
+    v0SpecReaderPort: V0SpecReaderPort,
+    migrationMappingRepositoryPort: MigrationMappingRepositoryPort
+  ) {
+    this.migrationAnalyzer = new MigrationAnalyzer(
+      v0SpecReaderPort,
+      migrationMappingRepositoryPort
+    );
+  }
+
+  async execute(input: AnalyzeMigrationInput = {}): Promise<AnalyzeMigrationOutput> {
+    const migrations = await this.migrationAnalyzer.analyzeAll({
+      dryRun: input.dryRun ?? true,
+      outOfScopePattern: input.outOfScopePattern,
+      orchestrationMigratedPattern: input.orchestrationMigratedPattern,
+    });
+
+    const migratedCount = migrations.filter((m) => m.migrationStatus === 'migrated').length;
+    const modifiedCount = migrations.filter((m) => m.migrationStatus === 'modified').length;
+    const skippedCount = migrations.filter((m) => m.migrationStatus === 'skipped').length;
+
+    return {
+      totalCount: migrations.length,
+      migratedCount,
+      modifiedCount,
+      skippedCount,
+    };
+  }
+}

package/scripts/harness/regression-suite/application/usecases/configure-ci-gate-usecase.ts

@@ -0,0 +1,29 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { CiGateConfig } from '../../domain/value-objects/ci-gate-config.js';
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+import type { ConfigureCiGateInput } from '../dto/configure-ci-gate-input.js';
+import type { ConfigureCiGateOutput } from '../dto/configure-ci-gate-output.js';
+import type { SuiteIdValue } from '../../domain/value-objects/suite-id.js';
+
+export class ConfigureCiGateUseCase {
+  constructor(private readonly configQueryPort: ConfigQueryPort) {}
+
+  async execute(input: ConfigureCiGateInput): Promise<ConfigureCiGateOutput> {
+    const threshold =
+      input.coverageThreshold ?? (await this.configQueryPort.getCoverageThreshold());
+
+    const suiteIds = input.requiredSuiteIds.map((id) => SuiteId.create(id));
+
+    const config = CiGateConfig.create({
+      requiredSuiteIds: suiteIds,
+      coverageThreshold: threshold,
+      executionMode: input.executionMode,
+    });
+
+    return {
+      requiredSuiteIds: config.requiredSuiteIds.map((id) => id.value) as SuiteIdValue[],
+      coverageThreshold: config.coverageThreshold,
+      executionMode: config.executionMode,
+    };
+  }
+}

package/scripts/harness/regression-suite/application/usecases/migrate-v0-tests-usecase.ts

@@ -0,0 +1,44 @@
+import { MigrationAnalyzer } from '../../domain/services/migration-analyzer.js';
+import type { V0SpecReaderPort } from '../../domain/ports/v0-spec-reader-port.js';
+import type { MigrationMappingRepositoryPort } from '../../domain/ports/migration-mapping-repository-port.js';
+import { MigrationMappingMapper } from '../mappers/migration-mapping-mapper.js';
+import type { MigrateV0TestsInput } from '../dto/migrate-v0-tests-input.js';
+import type { MigrateV0TestsOutput } from '../dto/migrate-v0-tests-output.js';
+
+export class MigrateV0TestsUseCase {
+  private readonly migrationAnalyzer: MigrationAnalyzer;
+
+  constructor(
+    private readonly v0SpecReaderPort: V0SpecReaderPort,
+    private readonly migrationMappingRepositoryPort: MigrationMappingRepositoryPort
+  ) {
+    this.migrationAnalyzer = new MigrationAnalyzer(
+      v0SpecReaderPort,
+      migrationMappingRepositoryPort
+    );
+  }
+
+  async execute(input: MigrateV0TestsInput = {}): Promise<MigrateV0TestsOutput> {
+    const migrations = await this.migrationAnalyzer.analyzeAll({
+      dryRun: !(input.confirmExecute ?? false),
+      outOfScopePattern: input.outOfScopePattern,
+      biomeModificationRequired: input.biomeModificationRequired,
+    });
+
+    const migratedCount = migrations.filter((m) => m.migrationStatus === 'migrated').length;
+    const modifiedCount = migrations.filter((m) => m.migrationStatus === 'modified').length;
+    const skippedCount = migrations.filter((m) => m.migrationStatus === 'skipped').length;
+
+    const mappingOutputs = migrations
+      .map((m) => MigrationMappingMapper.toOutput(m))
+      .filter((m) => m !== null) as NonNullable<ReturnType<typeof MigrationMappingMapper.toOutput>>[];
+
+    return {
+      mappings: mappingOutputs,
+      totalCount: migrations.length,
+      migratedCount,
+      modifiedCount,
+      skippedCount,
+    };
+  }
+}

package/scripts/harness/regression-suite/application/usecases/run-agent-independence-guard-usecase.ts

@@ -0,0 +1,66 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { TestExecutionSummary } from '../../domain/value-objects/test-execution-summary.js';
+import { TestFailureDetail } from '../../domain/value-objects/test-failure-detail.js';
+import { ImportGuardService } from '../../domain/services/import-guard-service.js';
+import type { SuiteRegistryPort } from '../../domain/ports/suite-registry-port.js';
+import type { ImportAnalyzerPort } from '../../domain/ports/import-analyzer-port.js';
+import type { CiGateResultWriterPort } from '../../domain/ports/ci-gate-result-writer-port.js';
+import { TestExecutionSummaryMapper } from '../mappers/test-execution-summary-mapper.js';
+import type { RunRegressionSuiteInput } from '../dto/run-regression-suite-input.js';
+import type { RunRegressionSuiteOutput } from '../dto/run-regression-suite-output.js';
+import type { AgentIndependenceTest } from '../../domain/value-objects/agent-independence-test.js';
+
+export class RunAgentIndependenceGuardUseCase {
+  private readonly importGuardService: ImportGuardService;
+
+  constructor(
+    private readonly suiteRegistryPort: SuiteRegistryPort,
+    importAnalyzerPort: ImportAnalyzerPort,
+    private readonly ciGateResultWriterPort: CiGateResultWriterPort
+  ) {
+    this.importGuardService = new ImportGuardService(importAnalyzerPort);
+  }
+
+  async execute(input: RunRegressionSuiteInput = {}): Promise<RunRegressionSuiteOutput> {
+    const suiteId = SuiteId.create(input.suiteId ?? 'agent-independence');
+    const definition = await this.suiteRegistryPort.getDefinition(suiteId);
+
+    const agentTests = definition.testCases as AgentIndependenceTest[];
+    const allFailures: TestFailureDetail[] = [];
+
+    for (const test of agentTests) {
+      let violations;
+      try {
+        violations = await this.importGuardService.verify(test);
+      } catch (err) {
+        throw new Error(`ImportAnalysisPortError: ${err instanceof Error ? err.message : String(err)}`);
+      }
+
+      for (const v of violations) {
+        allFailures.push(
+          TestFailureDetail.create({
+            testCaseId: test.targetModule,
+            errorMessage: v.violationMessage,
+          })
+        );
+      }
+    }
+
+    const failedCount = allFailures.length;
+    const passedCount = failedCount === 0 ? agentTests.length : 0;
+    const totalCount = agentTests.length;
+
+    const summary = TestExecutionSummary.create({
+      passedCount,
+      failedCount,
+      skippedCount: 0,
+      totalCount,
+      coverageRate: null,
+      failures: allFailures,
+    });
+
+    await this.ciGateResultWriterPort.write(suiteId.value, summary);
+
+    return TestExecutionSummaryMapper.toOutput(summary, 0);
+  }
+}

package/scripts/harness/regression-suite/application/usecases/run-gng-gate-regression-usecase.ts

@@ -0,0 +1,41 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { TestExecutionSummary } from '../../domain/value-objects/test-execution-summary.js';
+import type { SuiteRegistryPort } from '../../domain/ports/suite-registry-port.js';
+import type { TestRunnerPort } from '../../domain/ports/test-runner-port.js';
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+import type { CiGateResultWriterPort } from '../../domain/ports/ci-gate-result-writer-port.js';
+import { TestExecutionSummaryMapper } from '../mappers/test-execution-summary-mapper.js';
+import type { RunRegressionSuiteInput } from '../dto/run-regression-suite-input.js';
+import type { RunRegressionSuiteOutput } from '../dto/run-regression-suite-output.js';
+
+export class RunGngGateRegressionUseCase {
+  constructor(
+    private readonly suiteRegistryPort: SuiteRegistryPort,
+    private readonly testRunnerPort: TestRunnerPort,
+    private readonly configQueryPort: ConfigQueryPort,
+    private readonly ciGateResultWriterPort: CiGateResultWriterPort
+  ) {}
+
+  async execute(input: RunRegressionSuiteInput = {}): Promise<RunRegressionSuiteOutput> {
+    const suiteId = SuiteId.create(input.suiteId ?? 'gng-gate');
+    const definition = await this.suiteRegistryPort.getDefinition(suiteId);
+
+    const runResult = await this.testRunnerPort.runSuite(definition.testCases);
+
+    const threshold =
+      input.coverageThreshold ?? (await this.configQueryPort.getCoverageThreshold());
+
+    const 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 TestExecutionSummaryMapper.toOutput(summary, threshold);
+  }
+}

package/scripts/harness/regression-suite/application/usecases/run-k-requirements-regression-usecase.ts

@@ -0,0 +1,59 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { TestExecutionSummary } from '../../domain/value-objects/test-execution-summary.js';
+import type { SuiteRegistryPort } from '../../domain/ports/suite-registry-port.js';
+import type { TestRunnerPort } from '../../domain/ports/test-runner-port.js';
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+import type { CiGateResultWriterPort } from '../../domain/ports/ci-gate-result-writer-port.js';
+import { TestExecutionSummaryMapper } from '../mappers/test-execution-summary-mapper.js';
+import type { RunRegressionSuiteInput } from '../dto/run-regression-suite-input.js';
+import type { RunRegressionSuiteOutput } from '../dto/run-regression-suite-output.js';
+import type { KRequirementTest } from '../../domain/value-objects/k-requirement-test.js';
+
+export class RunKRequirementsRegressionUseCase {
+  constructor(
+    private readonly suiteRegistryPort: SuiteRegistryPort,
+    private readonly testRunnerPort: TestRunnerPort,
+    private readonly configQueryPort: ConfigQueryPort,
+    private readonly ciGateResultWriterPort: CiGateResultWriterPort
+  ) {}
+
+  async execute(input: RunRegressionSuiteInput = {}): Promise<RunRegressionSuiteOutput> {
+    const suiteId = SuiteId.create(input.suiteId ?? 'k-requirements');
+
+    let definition;
+    try {
+      definition = await this.suiteRegistryPort.getDefinition(suiteId);
+    } catch (err) {
+      throw err;
+    }
+
+    // Filter by kNumberFilter if provided
+    let testCases = definition.testCases as KRequirementTest[];
+    if (input.kNumberFilter && input.kNumberFilter.length > 0) {
+      testCases = testCases.filter((tc) => input.kNumberFilter!.includes(tc.kNumber));
+    }
+
+    let runResult;
+    try {
+      runResult = await this.testRunnerPort.runSuite(testCases);
+    } catch (err) {
+      throw new Error(`TestRunnerPortError: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    const threshold =
+      input.coverageThreshold ?? (await this.configQueryPort.getCoverageThreshold());
+
+    const 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 TestExecutionSummaryMapper.toOutput(summary, threshold);
+  }
+}

package/scripts/harness/regression-suite/application/usecases/run-k14-k15-regression-usecase.ts

@@ -0,0 +1,46 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { TestExecutionSummary } from '../../domain/value-objects/test-execution-summary.js';
+import type { SuiteRegistryPort } from '../../domain/ports/suite-registry-port.js';
+import type { TestRunnerPort } from '../../domain/ports/test-runner-port.js';
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+import type { CiGateResultWriterPort } from '../../domain/ports/ci-gate-result-writer-port.js';
+import { TestExecutionSummaryMapper } from '../mappers/test-execution-summary-mapper.js';
+import type { RunRegressionSuiteInput } from '../dto/run-regression-suite-input.js';
+import type { RunRegressionSuiteOutput } from '../dto/run-regression-suite-output.js';
+import type { KRequirementTest } from '../../domain/value-objects/k-requirement-test.js';
+
+export class RunK14K15RegressionUseCase {
+  constructor(
+    private readonly suiteRegistryPort: SuiteRegistryPort,
+    private readonly testRunnerPort: TestRunnerPort,
+    private readonly configQueryPort: ConfigQueryPort,
+    private readonly ciGateResultWriterPort: CiGateResultWriterPort
+  ) {}
+
+  async execute(input: RunRegressionSuiteInput = {}): Promise<RunRegressionSuiteOutput> {
+    const suiteId = SuiteId.create(input.suiteId ?? 'k-requirements');
+    const definition = await this.suiteRegistryPort.getDefinition(suiteId);
+
+    const kFilter = input.kNumberFilter ?? ['K14', 'K15'];
+    let testCases = definition.testCases as KRequirementTest[];
+    testCases = testCases.filter((tc) => kFilter.includes(tc.kNumber));
+
+    const runResult = await this.testRunnerPort.runSuite(testCases);
+
+    const threshold =
+      input.coverageThreshold ?? (await this.configQueryPort.getCoverageThreshold());
+
+    const 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 TestExecutionSummaryMapper.toOutput(summary, threshold);
+  }
+}