phasegate 0.15.0

package/scripts/harness/regression-suite/infrastructure/registry/k-requirements-suite-definition.ts

@@ -0,0 +1,32 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { RegressionSuiteDefinition } from '../../domain/value-objects/regression-suite-definition.js';
+import { KRequirementTest } from '../../domain/value-objects/k-requirement-test.js';
+
+export class KRequirementsSuiteDefinition {
+  static get(): RegressionSuiteDefinition {
+    const testCases = [
+      KRequirementTest.create({ kNumber: 'K1', targetUnit: 'validator-system', verificationCondition: 'ValidatorIdRegistryが正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K2', targetUnit: 'phase-dependency-model', verificationCondition: 'PhaseGateResultの3層構造が正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K3', targetUnit: 'biome-ast-engine', verificationCondition: 'Biome AST解析結果が正しく返されること' }),
+      KRequirementTest.create({ kNumber: 'K3.5', targetUnit: 'traceability-model', verificationCondition: 'メタデータ仕様が正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K4', targetUnit: 'validator-system', verificationCondition: 'テスト品質要件が満たされること' }),
+      KRequirementTest.create({ kNumber: 'K5', targetUnit: 'validator-system', verificationCondition: 'DDDスキル要件が満たされること' }),
+      KRequirementTest.create({ kNumber: 'K6', targetUnit: 'harness-api', verificationCondition: '2フェーズ実行が正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K7', targetUnit: 'harness-api', verificationCondition: 'ドキュメント分割が正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K8', targetUnit: 'harness-api', verificationCondition: 'カスケード更新が正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K9', targetUnit: 'ci-governance', verificationCondition: 'エージェントレッスンが正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K10', targetUnit: 'harness-api', verificationCondition: 'セキュリティ・パフォーマンス要件が満たされること' }),
+      KRequirementTest.create({ kNumber: 'K11', targetUnit: 'validator-system', verificationCondition: 'ドリフト検出が正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K12', targetUnit: 'validator-system', verificationCondition: '一貫性チェッカーが正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K13', targetUnit: 'config-foundation', verificationCondition: 'PresetIdRegistryが正しく動作すること' }),
+      KRequirementTest.create({ kNumber: 'K14', targetUnit: 'phase-dependency-model', verificationCondition: 'フェーズ依存性要件が満たされること' }),
+      KRequirementTest.create({ kNumber: 'K15', targetUnit: 'harness-api', verificationCondition: '計画ドキュメント要件が満たされること' }),
+    ];
+
+    return RegressionSuiteDefinition.create({
+      suiteId: SuiteId.create('k-requirements'),
+      testCases,
+      description: 'K要件回帰テストスイート（K1〜K15）',
+    });
+  }
+}

package/scripts/harness/regression-suite/infrastructure/registry/v0-migration-suite-definition.ts

@@ -0,0 +1,23 @@
+import { SuiteId } from '../../domain/value-objects/suite-id.js';
+import { RegressionSuiteDefinition } from '../../domain/value-objects/regression-suite-definition.js';
+import { KRequirementTest } from '../../domain/value-objects/k-requirement-test.js';
+
+export class V0MigrationSuiteDefinition {
+  static get(): RegressionSuiteDefinition {
+    // v0-migration suite uses K requirement tests as placeholder
+    // In real usage, this would be populated from MigrationMapping repository
+    const testCases = [
+      KRequirementTest.create({
+        kNumber: 'K1',
+        targetUnit: 'regression-suite',
+        verificationCondition: 'v0テスト移行マッピングが正しく管理されること',
+      }),
+    ];
+
+    return RegressionSuiteDefinition.create({
+      suiteId: SuiteId.create('v0-migration'),
+      testCases,
+      description: 'v0テスト移行スイート（H15-02 CIゲート化）',
+    });
+  }
+}

package/scripts/harness/setup/skill-deployer.ts

@@ -0,0 +1,217 @@
+/**
+ * @layer infrastructure
+ *
+ * Harnessスキルのデプロイメントインフラ。
+ * パッケージルートの skills/ を対象プロジェクトの .claude/skills/ にコピーする。
+ * harness init / harness update-skills コマンドから呼び出される。
+ *
+ * Note: import.meta.url を使わず、呼び出し元 (main.ts) がパスを解決して渡す設計。
+ */
+
+import { join } from 'node:path';
+import { promises as fs } from 'node:fs';
+
+const HARNESS_VERSION_FILE = '.harness-version';
+const SKILLS_SOURCE_DIR = 'skills';
+const SKILLS_TARGET_DIR = join('.claude', 'skills');
+const HARNESS_CONFIG_FILE = 'phasegate.config.json';
+const HOOKS_TEMPLATE_DIR = join('templates', '.claude');
+const HOOKS_TARGET_DIR = '.claude';
+
+export interface DeployResult {
+  deployedSkills: string[];
+  targetDir: string;
+  version: string;
+  deployedAt: string;
+}
+
+export interface VersionInfo {
+  version: string;
+  deployedAt: string;
+}
+
+interface PkgJson {
+  version: string;
+}
+
+export async function getHarnessVersion(harnessRoot: string): Promise<string> {
+  const packageJsonPath = join(harnessRoot, 'package.json');
+  const content = await fs.readFile(packageJsonPath, 'utf-8');
+  const pkg: PkgJson = JSON.parse(content);
+  return pkg.version;
+}
+
+async function copyDirectory(src: string, dest: string): Promise<number> {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  let count = 0;
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      count += await copyDirectory(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await fs.copyFile(srcPath, destPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * skills/ ディレクトリを対象プロジェクトの .claude/skills/ にデプロイする。
+ * 既存ファイルは上書きされる（update-skills でも同じ関数を使う）。
+ *
+ * @param harnessRoot - harnessパッケージのルートディレクトリ（skills/がある場所）
+ * @param projectRoot - デプロイ先プロジェクトのルートディレクトリ
+ */
+export async function deploySkills(harnessRoot: string, projectRoot: string): Promise<DeployResult> {
+  const skillsSource = join(harnessRoot, SKILLS_SOURCE_DIR);
+  const skillsTarget = join(projectRoot, SKILLS_TARGET_DIR);
+  const version = await getHarnessVersion(harnessRoot);
+  const deployedAt = new Date().toISOString();
+
+  const skillDirs = await fs.readdir(skillsSource, { withFileTypes: true });
+  const skills = skillDirs.filter((d) => d.isDirectory()).map((d) => d.name);
+
+  await fs.mkdir(skillsTarget, { recursive: true });
+
+  for (const skill of skills) {
+    const srcSkillDir = join(skillsSource, skill);
+    const destSkillDir = join(skillsTarget, skill);
+    await copyDirectory(srcSkillDir, destSkillDir);
+  }
+
+  const versionInfo: VersionInfo = { version, deployedAt };
+  await fs.writeFile(
+    join(skillsTarget, HARNESS_VERSION_FILE),
+    JSON.stringify(versionInfo, null, 2) + '\n',
+    'utf-8',
+  );
+
+  return { deployedSkills: skills, targetDir: skillsTarget, version, deployedAt };
+}
+
+/**
+ * デプロイ済みバージョン情報を読み取る。
+ * .harness-version ファイルが存在しない場合は null を返す。
+ */
+export async function getDeployedVersion(projectRoot: string): Promise<VersionInfo | null> {
+  const versionFile = join(projectRoot, SKILLS_TARGET_DIR, HARNESS_VERSION_FILE);
+  try {
+    const content = await fs.readFile(versionFile, 'utf-8');
+    const info: VersionInfo = JSON.parse(content);
+    return info;
+  } catch {
+    return null;
+  }
+}
+
+export interface DeployHooksResult {
+  scriptsDeployed: number;
+  settingsCreated: boolean;
+}
+
+/**
+ * templates/.claude/scripts/ を対象プロジェクトの .claude/scripts/ にデプロイする。
+ * templates/.claude/settings.json も存在しなければ作成する。
+ * 既存のスクリプトは上書き、settings.json は既存があればスキップ。
+ *
+ * @param harnessRoot - harnessパッケージのルートディレクトリ
+ * @param projectRoot - デプロイ先プロジェクトのルートディレクトリ
+ */
+export async function deployHookScripts(
+  harnessRoot: string,
+  projectRoot: string,
+): Promise<DeployHooksResult> {
+  const templateDir = join(harnessRoot, HOOKS_TEMPLATE_DIR);
+  const targetDir = join(projectRoot, HOOKS_TARGET_DIR);
+
+  // scripts/ ディレクトリをコピー
+  const scriptsSource = join(templateDir, 'scripts');
+  const scriptsTarget = join(targetDir, 'scripts');
+  let scriptsDeployed = 0;
+
+  try {
+    await fs.access(scriptsSource);
+    scriptsDeployed = await copyDirectory(scriptsSource, scriptsTarget);
+
+    // シェルスクリプトに実行権限を付与
+    const entries = await fs.readdir(scriptsTarget);
+    for (const entry of entries) {
+      if (entry.endsWith('.sh')) {
+        await fs.chmod(join(scriptsTarget, entry), 0o755);
+      }
+    }
+  } catch {
+    // テンプレートが存在しない場合はスキップ
+  }
+
+  // settings.json を作成（既存があればスキップ）
+  const settingsSource = join(templateDir, 'settings.json');
+  const settingsTarget = join(targetDir, 'settings.json');
+  let settingsCreated = false;
+
+  try {
+    await fs.access(settingsTarget);
+    // 既存あり → スキップ
+  } catch {
+    try {
+      await fs.access(settingsSource);
+      await fs.mkdir(targetDir, { recursive: true });
+      await fs.copyFile(settingsSource, settingsTarget);
+      settingsCreated = true;
+    } catch {
+      // テンプレートが存在しない場合はスキップ
+    }
+  }
+
+  return { scriptsDeployed, settingsCreated };
+}
+
+/**
+ * phasegate.config.json のデフォルトテンプレートを生成する。
+ * 対象プロジェクトに phasegate.config.json が存在しない場合のみ作成する。
+ */
+export async function initHarnessConfig(
+  projectRoot: string,
+  projectName: string,
+): Promise<{ created: boolean; path: string }> {
+  const configPath = join(projectRoot, HARNESS_CONFIG_FILE);
+  try {
+    await fs.access(configPath);
+    return { created: false, path: configPath };
+  } catch {
+    // ファイルが存在しない場合はテンプレートを作成
+  }
+
+  const template = {
+    project: {
+      name: projectName,
+      preset: 'standard',
+    },
+    layers: {},
+    quickMode: {},
+    phaseDependencies: {
+      preset: 'default',
+      override: false,
+      customRules: [],
+    },
+    planningMode: {
+      default: 'interactive',
+      perPhase: {},
+    },
+    harnesses: {},
+    paths: {
+      designDocs: 'docs/product/construction',
+      inceptionDocs: 'docs/inception',
+    },
+    reporting: {
+      format: 'json',
+      outputDir: 'reports',
+    },
+  };
+
+  await fs.writeFile(configPath, JSON.stringify(template, null, 2) + '\n', 'utf-8');
+  return { created: true, path: configPath };
+}

package/scripts/harness/shared-kernel/harness-api.ts

@@ -0,0 +1,5 @@
+// harness-api.ts — Shared Kernel public entry for harness-api types
+
+export type { HarnessApiResponseContract } from '../harness-api/application/dto/harness-api-response-contract.js';
+export { HarnessApiResponse } from '../harness-api/domain/value-objects/harness-api-response.js';
+export type { ResponseStatus, ExitCode, HarnessError, ResponseSummary } from '../harness-api/domain/value-objects/harness-api-response.js';

package/scripts/harness/shared-kernel/quick-mode.ts

@@ -0,0 +1,15 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * quick-mode ユニットの Shared Kernel 公開面（Cross-Unit Contract 再エクスポート）
+ */
+
+// Public DTOs (Shared Kernel contracts)
+export type { QuickModeDecisionContract } from '../quick-mode/application/dto/quick-mode-decision-contract.js';
+export type { QuickModeEligibilityContract } from '../quick-mode/application/dto/quick-mode-eligibility-contract.js';
+export type { ValidatorRelaxationProfileContract } from '../quick-mode/application/dto/validator-relaxation-profile-contract.js';
+
+// Composition Root
+export { createQuickModeCompositionRoot } from '../quick-mode/composition-root.js';
+export type { QuickModeCompositionRoot } from '../quick-mode/composition-root.js';

package/scripts/harness/shared-kernel/validator-system.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer shared-kernel
+ * @unit validator-system
+ *
+ * Cross-Unit Contract 再エクスポート
+ * ValidatorRegistry インターフェース + ValidationResult Contract
+ */
+export type { ValidationResultContract } from '../validator-system/application/dto/validation-result-contract.js';
+export type { ValidatorRelaxationProfile } from '../validator-system/application/dto/validator-relaxation-profile.js';
+export type { AggregatedValidationReport } from '../validator-system/application/dto/aggregated-validation-report.js';
+export { ValidatorId, InvalidValidatorIdError } from '../validator-system/domain/value-objects/validator-id.js';
+export { ValidatorRegistry, UnknownValidatorError } from '../validator-system/domain/services/validator-registry.js';
+export { createValidatorSystemModule } from '../validator-system/composition-root.js';
+export type { ValidatorSystemModule } from '../validator-system/composition-root.js';

package/scripts/harness/skill-quality/application/dto/apply-cascade-update-input.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface ApplyCascadeUpdateInput {
+  readonly storyId: string;
+  readonly dryRun?: boolean;
+}

package/scripts/harness/skill-quality/application/dto/apply-cascade-update-output.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface ApplyCascadeUpdateOutput {
+  readonly updatedCount: number;
+  readonly appliedStoryIds: readonly string[];
+  readonly errors: readonly string[];
+}

package/scripts/harness/skill-quality/application/dto/check-coverage-input.ts

@@ -0,0 +1,7 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface CheckCoverageInput {
+  readonly storyId: string;
+}

package/scripts/harness/skill-quality/application/dto/check-coverage-output.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { CoverageReport } from '../../domain/value-objects/coverage-report.js';
+
+export interface CheckCoverageOutput {
+  readonly coverageReport: CoverageReport;
+  readonly meetsThreshold: boolean;
+  readonly requirementThreshold: number;
+  readonly codeThreshold: number;
+}

package/scripts/harness/skill-quality/application/dto/collect-lessons-input.ts

@@ -0,0 +1,7 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface CollectLessonsInput {
+  readonly sources: readonly string[];
+}

package/scripts/harness/skill-quality/application/dto/collect-lessons-output.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { Lesson } from '../../domain/value-objects/lesson.js';
+
+export interface CollectLessonsOutput {
+  readonly lessons: readonly Lesson[];
+  readonly totalCollected: number;
+  readonly deduplicatedCount: number;
+}

package/scripts/harness/skill-quality/application/dto/execute-tdd-cycle-input.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface ExecuteTddCycleInput {
+  readonly unit: string;
+  readonly storyId: string;
+  readonly description: string;
+  readonly phase: 'RED' | 'GREEN' | 'REFACTOR';
+  readonly passed: boolean;
+}

package/scripts/harness/skill-quality/application/dto/execute-tdd-cycle-output.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { ValidationViolation } from '../../domain/types/validation-violation.js';
+
+export interface ExecuteTddCycleOutput {
+  readonly ready: boolean;
+  readonly violations: readonly ValidationViolation[];
+  readonly committedMessage: string | null;
+}

package/scripts/harness/skill-quality/application/dto/run-plan-checker-loop-input.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface RunPlanCheckerLoopInput {
+  readonly planDocument: string;
+  readonly storyId: string;
+}

package/scripts/harness/skill-quality/application/dto/run-plan-checker-loop-output.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { LoopStatus } from '../../domain/types/loop-status.js';
+import type { LoopAttempt } from '../../domain/value-objects/loop-attempt.js';
+
+export interface RunPlanCheckerLoopOutput {
+  readonly status: LoopStatus;
+  readonly loopHistory: readonly LoopAttempt[];
+  readonly escalationRequired: boolean;
+}

package/scripts/harness/skill-quality/application/dto/validate-skill-structure-input.ts

@@ -0,0 +1,7 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface ValidateSkillStructureInput {
+  readonly skillFilePath: string;
+}

package/scripts/harness/skill-quality/application/dto/validate-skill-structure-output.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { SkillValidationResult } from '../../domain/value-objects/skill-validation-result.js';
+
+export interface ValidateSkillStructureOutput {
+  readonly result: SkillValidationResult;
+}

package/scripts/harness/skill-quality/application/dto/write-lesson-artifact-input.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { Lesson } from '../../domain/value-objects/lesson.js';
+
+export interface WriteLessonArtifactInput {
+  readonly storyId: string;
+  readonly lessons: readonly Lesson[];
+}

package/scripts/harness/skill-quality/application/dto/write-lesson-artifact-output.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+export interface WriteLessonArtifactOutput {
+  readonly outputPath: string;
+  readonly lessonCount: number;
+}

package/scripts/harness/skill-quality/application/mappers/cascade-update-result-mapper.ts

@@ -0,0 +1,16 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { CascadeUpdateResult } from '../../domain/value-objects/cascade-update-result.js';
+import type { ApplyCascadeUpdateOutput } from '../dto/apply-cascade-update-output.js';
+
+export class CascadeUpdateResultMapper {
+  static toOutput(result: CascadeUpdateResult): ApplyCascadeUpdateOutput {
+    return {
+      updatedCount: result.updatedCount,
+      appliedStoryIds: result.appliedStoryIds,
+      errors: result.errors,
+    };
+  }
+}

package/scripts/harness/skill-quality/application/mappers/coverage-report-mapper.ts

@@ -0,0 +1,37 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { CoverageReport } from '../../domain/value-objects/coverage-report.js';
+
+export interface CoverageReportDto {
+  readonly requirementCoverage: {
+    readonly total: number;
+    readonly covered: number;
+    readonly coverageRate: number;
+    readonly uncoveredIds: readonly string[];
+  };
+  readonly codeCoverage: {
+    readonly lineCoverage: number;
+    readonly branchCoverage: number;
+    readonly functionCoverage: number;
+  };
+}
+
+export class CoverageReportMapper {
+  static toDto(report: CoverageReport): CoverageReportDto {
+    return {
+      requirementCoverage: {
+        total: report.requirementCoverage.total,
+        covered: report.requirementCoverage.covered,
+        coverageRate: report.requirementCoverage.coverageRate,
+        uncoveredIds: report.requirementCoverage.uncoveredIds,
+      },
+      codeCoverage: {
+        lineCoverage: report.codeCoverage.lineCoverage,
+        branchCoverage: report.codeCoverage.branchCoverage,
+        functionCoverage: report.codeCoverage.functionCoverage,
+      },
+    };
+  }
+}

package/scripts/harness/skill-quality/application/mappers/lesson-artifact-mapper.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import type { LessonArtifact, LessonArtifactJson } from '../../domain/aggregates/lesson-artifact.js';
+
+export class LessonArtifactMapper {
+  static toJson(artifact: LessonArtifact): LessonArtifactJson {
+    return artifact.toJson();
+  }
+}

package/scripts/harness/skill-quality/application/usecases/apply-cascade-update-usecase.ts

@@ -0,0 +1,61 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import { CascadeUpdateResult } from '../../domain/value-objects/cascade-update-result.js';
+import type { CascadeUpdateService } from '../../domain/services/cascade-update-service.js';
+import type { FileSystemPort } from '../../domain/ports/file-system-port.js';
+import type { ApplyCascadeUpdateInput } from '../dto/apply-cascade-update-input.js';
+import type { ApplyCascadeUpdateOutput } from '../dto/apply-cascade-update-output.js';
+
+export class ApplyCascadeUpdateUseCase {
+  constructor(
+    private readonly cascadeUpdateService: CascadeUpdateService,
+    private readonly fileSystemPort: FileSystemPort,
+  ) {}
+
+  async execute(input: ApplyCascadeUpdateInput): Promise<ApplyCascadeUpdateOutput> {
+    const targets = await this.cascadeUpdateService.resolve(input.storyId);
+
+    let updatedCount = 0;
+    const appliedStoryIds: string[] = [];
+    const errors: string[] = [];
+
+    for (const target of targets) {
+      try {
+        const isGlobPattern = target.filePath.includes('*');
+        const filePaths = isGlobPattern
+          ? await this.fileSystemPort.glob(target.filePath)
+          : [target.filePath];
+
+        for (const filePath of filePaths) {
+          try {
+            const content = await this.fileSystemPort.read(filePath);
+            // Append story-id tag if not already present
+            const updatedContent = content.includes(target.storyIdTag)
+              ? content
+              : `${content}\n${target.storyIdTag}`;
+            if (!input.dryRun) {
+              await this.fileSystemPort.write(filePath, updatedContent);
+            }
+            updatedCount++;
+            if (!appliedStoryIds.includes(target.storyIdTag)) {
+              appliedStoryIds.push(target.storyIdTag);
+            }
+          } catch (err) {
+            errors.push(`Failed to update ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      } catch (err) {
+        errors.push(`Failed to process ${target.filePath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+
+    const result = CascadeUpdateResult.create({ updatedCount, appliedStoryIds, errors });
+    return {
+      updatedCount: result.updatedCount,
+      appliedStoryIds: result.appliedStoryIds,
+      errors: result.errors,
+    };
+  }
+}

package/scripts/harness/skill-quality/application/usecases/check-coverage-usecase.ts

@@ -0,0 +1,39 @@
+/**
+ * @layer application
+ * @unit skill-quality
+ */
+import { CoverageReport } from '../../domain/value-objects/coverage-report.js';
+import { RequirementCoverageResult } from '../../domain/value-objects/requirement-coverage-result.js';
+import type { RequirementTestMatrixPort } from '../../domain/ports/requirement-test-matrix-port.js';
+import type { CoverageRunnerPort } from '../../domain/ports/coverage-runner-port.js';
+import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
+import type { CheckCoverageInput } from '../dto/check-coverage-input.js';
+import type { CheckCoverageOutput } from '../dto/check-coverage-output.js';
+
+export class CheckCoverageUseCase {
+  constructor(
+    private readonly requirementTestMatrixPort: RequirementTestMatrixPort,
+    private readonly coverageRunnerPort: CoverageRunnerPort,
+    private readonly configQueryPort: ConfigQueryPort,
+  ) {}
+
+  async execute(input: CheckCoverageInput): Promise<CheckCoverageOutput> {
+    const threshold = await this.configQueryPort.getCoverageThreshold();
+    const matrix = await this.requirementTestMatrixPort.read(input.storyId);
+    const requirementCoverage = RequirementCoverageResult.create(
+      matrix.total,
+      matrix.covered,
+      matrix.uncoveredIds,
+    );
+    const codeCoverage = await this.coverageRunnerPort.run(input.storyId);
+    const coverageReport = CoverageReport.create(requirementCoverage, codeCoverage);
+    const meetsThreshold = coverageReport.meetsThreshold(threshold.requirement, threshold.code);
+
+    return {
+      coverageReport,
+      meetsThreshold,
+      requirementThreshold: threshold.requirement,
+      codeThreshold: threshold.code,
+    };
+  }
+}