phasegate 0.15.0

package/scripts/harness/validator-system/domain/value-objects/drift-report.ts

@@ -0,0 +1,61 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * DriftReport 値オブジェクト
+ * 設計文書とコード実装の双方向乖離検出結果VO（L4-001専用）
+ */
+import type { HarnessErrorLike } from './validation-result.js';
+
+export type DriftDirection = 'design→code' | 'code→design';
+
+export interface DriftReportProps {
+  readonly direction: DriftDirection;
+  readonly unitName: string;
+  readonly element: string;
+  readonly description?: string;
+  readonly recommendation?: string;
+  readonly location?: { designDoc?: string; sourceFile?: string };
+}
+
+export class DriftReport {
+  readonly direction: DriftDirection;
+  readonly unitName: string;
+  readonly element: string;
+  readonly recommendation: string;
+  readonly location: { readonly designDoc?: string; readonly sourceFile?: string };
+
+  private constructor(props: DriftReportProps) {
+    this.direction = props.direction;
+    this.unitName = props.unitName;
+    this.element = props.element;
+    this.recommendation = props.recommendation ?? (props.description ?? '');
+    this.location = Object.freeze(props.location ?? {});
+    Object.freeze(this);
+  }
+
+  static create(props: DriftReportProps): DriftReport {
+    if (props.direction !== 'design→code' && props.direction !== 'code→design') {
+      throw new Error(`Invalid DriftReport direction: "${props.direction}". Must be "design→code" or "code→design" (INV-10)`);
+    }
+    return new DriftReport(props);
+  }
+
+  toHarnessError(): HarnessErrorLike {
+    return {
+      code: { value: 'L4-001', toString: () => 'L4-001' },
+      severity: { value: 'error', toString: () => 'error' },
+      message: `乖離検出 [${this.direction}] Unit: ${this.unitName}, Element: ${this.element}`,
+      suggestion: this.recommendation,
+    };
+  }
+
+  equals(other: DriftReport): boolean {
+    return (
+      this.direction === other.direction &&
+      this.unitName === other.unitName &&
+      this.element === other.element &&
+      this.recommendation === other.recommendation
+    );
+  }
+}

package/scripts/harness/validator-system/domain/value-objects/it-test-mock-violation-report.ts

@@ -0,0 +1,43 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * ItTestMockViolationReport 値オブジェクト
+ * ITテストファイル内での vi.mock による内部モジュールモック違反を表す不変値オブジェクト
+ */
+
+export interface ItTestMockViolationEntry {
+  readonly filePath: string;
+  readonly mockedModules: readonly string[];
+}
+
+export class ItTestMockViolationReport {
+  readonly violations: readonly ItTestMockViolationEntry[];
+
+  private constructor(violations: readonly ItTestMockViolationEntry[]) {
+    this.violations = Object.freeze([...violations]);
+    Object.freeze(this);
+  }
+
+  static create(violations: readonly ItTestMockViolationEntry[]): ItTestMockViolationReport {
+    return new ItTestMockViolationReport(violations);
+  }
+
+  static empty(): ItTestMockViolationReport {
+    return new ItTestMockViolationReport([]);
+  }
+
+  hasViolations(): boolean {
+    return this.violations.length > 0;
+  }
+
+  toMessages(): readonly string[] {
+    return this.violations.flatMap((v) =>
+      v.mockedModules.map(
+        (mod) => `IT test "${v.filePath}" mocks internal module "${mod}" — use real implementations in IT tests`
+      )
+    );
+  }
+}
+
+// @story-id H08-07

package/scripts/harness/validator-system/domain/value-objects/layer-config.ts

@@ -0,0 +1,61 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * LayerConfig 値オブジェクト
+ * HarnessConfigV2から注入されるL2/L3/L4の実行設定VO
+ */
+import { ValidatorId } from './validator-id.js';
+
+export interface LayerConfigProps {
+  readonly layer: 'L0' | 'L2' | 'L3' | 'L4';
+  readonly enabled: boolean;
+  readonly validatorIds: readonly string[];
+  readonly thresholds: Record<string, number>;
+  readonly strictOnly: boolean;
+  readonly preset: 'minimal' | 'standard' | 'strict';
+}
+
+export class LayerConfig {
+  readonly layer: 'L0' | 'L2' | 'L3' | 'L4';
+  readonly enabled: boolean;
+  readonly validatorIds: readonly string[];
+  readonly thresholds: Readonly<Record<string, number>>;
+  readonly strictOnly: boolean;
+  readonly preset: 'minimal' | 'standard' | 'strict';
+
+  private constructor(props: LayerConfigProps) {
+    this.layer = props.layer;
+    this.enabled = props.enabled;
+    this.validatorIds = Object.freeze([...props.validatorIds]);
+    this.thresholds = Object.freeze({ ...props.thresholds });
+    this.strictOnly = props.strictOnly;
+    this.preset = props.preset;
+    Object.freeze(this);
+  }
+
+  static create(props: LayerConfigProps): LayerConfig {
+    return new LayerConfig(props);
+  }
+
+  isValidatorEnabled(validatorId: ValidatorId): boolean {
+    if (!this.enabled) return false;
+    return this.validatorIds.includes(validatorId.value);
+  }
+
+  getThreshold(key: string): number | null {
+    const val = this.thresholds[key];
+    return val !== undefined ? val : null;
+  }
+
+  equals(other: LayerConfig): boolean {
+    return (
+      this.layer === other.layer &&
+      this.enabled === other.enabled &&
+      this.strictOnly === other.strictOnly &&
+      this.preset === other.preset &&
+      JSON.stringify(this.validatorIds) === JSON.stringify(other.validatorIds) &&
+      JSON.stringify(this.thresholds) === JSON.stringify(other.thresholds)
+    );
+  }
+}

package/scripts/harness/validator-system/domain/value-objects/stub-comment-report.ts

@@ -0,0 +1,42 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * StubCommentReport 値オブジェクト
+ * ソースファイル内のスタブコメント残存を表す不変値オブジェクト
+ */
+
+export interface StubCommentEntry {
+  readonly filePath: string;
+  readonly lineNumber: number;
+  readonly lineContent: string;
+}
+
+export class StubCommentReport {
+  readonly entries: readonly StubCommentEntry[];
+
+  private constructor(entries: readonly StubCommentEntry[]) {
+    this.entries = Object.freeze([...entries]);
+    Object.freeze(this);
+  }
+
+  static create(entries: readonly StubCommentEntry[]): StubCommentReport {
+    return new StubCommentReport(entries);
+  }
+
+  static empty(): StubCommentReport {
+    return new StubCommentReport([]);
+  }
+
+  hasViolations(): boolean {
+    return this.entries.length > 0;
+  }
+
+  toMessages(): readonly string[] {
+    return this.entries.map(
+      (e) => `Stub comment found at "${e.filePath}":${e.lineNumber} — "${e.lineContent.trim()}"`
+    );
+  }
+}
+
+// @story-id H08-07

package/scripts/harness/validator-system/domain/value-objects/validation-result.ts

@@ -0,0 +1,89 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * ValidationResult 値オブジェクト
+ * バリデータ実行結果のスナップショット（不変）
+ */
+import { ValidatorId } from './validator-id.js';
+
+/** HarnessError の最小互換型（harness-error Unit の HarnessError との疎結合） */
+export interface HarnessErrorLike {
+  readonly code: { readonly value?: string; toString(): string };
+  readonly severity: { readonly value?: string; toString(): string };
+  readonly message: string;
+  readonly suggestion: string;
+  [key: string]: unknown;
+}
+
+export interface ValidationResultRawProps {
+  readonly validatorId: ValidatorId;
+  readonly passed: boolean;
+  readonly errors: readonly HarnessErrorLike[];
+  readonly durationMs: number;
+  readonly skipped: boolean;
+}
+
+export class ValidationResult {
+  readonly validatorId: ValidatorId;
+  readonly passed: boolean;
+  readonly errors: readonly HarnessErrorLike[];
+  readonly durationMs: number;
+  readonly skipped: boolean;
+
+  private constructor(props: ValidationResultRawProps) {
+    this.validatorId = props.validatorId;
+    this.passed = props.passed;
+    this.errors = Object.freeze([...props.errors]);
+    this.durationMs = props.durationMs;
+    this.skipped = props.skipped;
+    Object.freeze(this);
+  }
+
+  /** 内部生成（不変条件検証付き） */
+  static createRaw(props: ValidationResultRawProps): ValidationResult {
+    if (props.durationMs < 0) {
+      throw new Error(`ValidationResult durationMs must be >= 0 (got: ${props.durationMs})`);
+    }
+    if (props.passed && props.errors.length > 0) {
+      throw new Error('ValidationResult invariant violation: passed=true but errors is not empty (INV-5)');
+    }
+    if (props.skipped && (!props.passed || props.errors.length > 0)) {
+      throw new Error('ValidationResult invariant violation: skipped=true requires passed=true and empty errors (INV-8)');
+    }
+    return new ValidationResult(props);
+  }
+
+  static pass(validatorId: ValidatorId, durationMs: number): ValidationResult {
+    return ValidationResult.createRaw({ validatorId, passed: true, errors: [], durationMs, skipped: false });
+  }
+
+  static fail(validatorId: ValidatorId, errors: readonly HarnessErrorLike[], durationMs: number): ValidationResult {
+    return new ValidationResult({ validatorId, passed: false, errors, durationMs, skipped: false });
+  }
+
+  /** fail の別名 */
+  static failure(validatorId: ValidatorId, errors: HarnessErrorLike[], durationMs: number): ValidationResult {
+    return ValidationResult.fail(validatorId, errors, durationMs);
+  }
+
+  static skip(validatorId: ValidatorId): ValidationResult {
+    return new ValidationResult({ validatorId, passed: true, errors: [], durationMs: 0, skipped: true });
+  }
+
+  hasErrors(): boolean {
+    return this.errors.length > 0;
+  }
+
+  errorCount(): number {
+    return this.errors.length;
+  }
+
+  equals(other: ValidationResult): boolean {
+    return (
+      this.validatorId.equals(other.validatorId) &&
+      this.passed === other.passed &&
+      this.errors.length === other.errors.length
+    );
+  }
+}

package/scripts/harness/validator-system/domain/value-objects/validation-rule.ts

@@ -0,0 +1,48 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * ValidationRule 値オブジェクト
+ * バリデータが適用する個々のルールの不変定義
+ */
+
+export interface ValidationRuleErrorTemplate {
+  readonly code: string;
+  readonly severity: 'error' | 'warning';
+  readonly messageTemplate: string;
+  readonly suggestionTemplate?: string;
+}
+
+export interface ValidationRuleProps {
+  readonly ruleName: string;
+  readonly description?: string;
+  readonly errorTemplate: ValidationRuleErrorTemplate;
+  readonly fixExample: string | null;
+}
+
+export class ValidationRule {
+  readonly ruleName: string;
+  readonly description: string;
+  readonly errorTemplate: ValidationRuleErrorTemplate;
+  readonly fixExample: string | null;
+
+  private constructor(props: ValidationRuleProps) {
+    this.ruleName = props.ruleName;
+    this.description = props.description ?? '';
+    this.errorTemplate = Object.freeze({ ...props.errorTemplate });
+    this.fixExample = props.fixExample;
+    Object.freeze(this);
+  }
+
+  static create(props: ValidationRuleProps): ValidationRule {
+    return new ValidationRule(props);
+  }
+
+  buildErrorCode(): string {
+    return this.errorTemplate.code;
+  }
+
+  equals(other: ValidationRule): boolean {
+    return this.ruleName === other.ruleName;
+  }
+}

package/scripts/harness/validator-system/domain/value-objects/validator-definition.ts

@@ -0,0 +1,74 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * ValidatorDefinition 値オブジェクト
+ * 個々のバリデータの不変定義を保持する
+ */
+import { ValidatorId } from './validator-id.js';
+import { ValidationRule } from './validation-rule.js';
+
+export interface ValidatorDefinitionProps {
+  readonly validatorId: ValidatorId;
+  readonly layer: 'L0' | 'L2' | 'L3' | 'L4';
+  readonly name?: string;
+  readonly description?: string;
+  readonly rules: readonly ValidationRule[];
+  readonly enabledCondition: 'always' | 'layerEnabled' | 'strictOnly';
+  readonly externalPolicyRef: string | null;
+  readonly executionPhase?: 'fuse-hook' | 'pre-commit' | 'ci' | 'scheduled';
+}
+
+const LAYER_TO_PHASE: Record<'L0' | 'L2' | 'L3' | 'L4', 'fuse-hook' | 'fuse-hook' | 'pre-commit' | 'ci' | 'scheduled'> = {
+  L0: 'fuse-hook',
+  L2: 'pre-commit',
+  L3: 'ci',
+  L4: 'scheduled',
+};
+
+export class ValidatorDefinition {
+  readonly validatorId: ValidatorId;
+  readonly layer: 'L0' | 'L2' | 'L3' | 'L4';
+  readonly name: string;
+  readonly description: string;
+  readonly rules: readonly ValidationRule[];
+  readonly enabledCondition: 'always' | 'layerEnabled' | 'strictOnly';
+  readonly externalPolicyRef: string | null;
+  readonly executionPhase: 'fuse-hook' | 'pre-commit' | 'ci' | 'scheduled';
+
+  private constructor(props: ValidatorDefinitionProps) {
+    this.validatorId = props.validatorId;
+    this.layer = props.layer;
+    this.name = props.name ?? props.validatorId.getName();
+    this.description = props.description ?? '';
+    this.rules = Object.freeze([...props.rules]);
+    this.enabledCondition = props.enabledCondition;
+    this.externalPolicyRef = props.externalPolicyRef;
+    this.executionPhase = props.executionPhase ?? LAYER_TO_PHASE[props.layer];
+    Object.freeze(this);
+  }
+
+  static create(props: ValidatorDefinitionProps): ValidatorDefinition {
+    if (props.rules.length === 0) {
+      throw new Error(`ValidatorDefinition requires at least one rule (validatorId: ${props.validatorId.value})`);
+    }
+    if (props.validatorId.getLayer() !== props.layer) {
+      throw new Error(
+        `ValidatorDefinition layer mismatch: validatorId layer is "${props.validatorId.getLayer()}" but layer field is "${props.layer}"`
+      );
+    }
+    return new ValidatorDefinition(props);
+  }
+
+  requiresExternalPolicy(): boolean {
+    return this.externalPolicyRef !== null;
+  }
+
+  isStrictOnly(): boolean {
+    return this.enabledCondition === 'strictOnly';
+  }
+
+  equals(other: ValidatorDefinition): boolean {
+    return this.validatorId.equals(other.validatorId);
+  }
+}

package/scripts/harness/validator-system/domain/value-objects/validator-id.ts

@@ -0,0 +1,93 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ *
+ * ValidatorId 値オブジェクト
+ * L1-001〜L4-003 のバリデータを識別する不変値オブジェクト
+ * Wave 2A で L1-017, L1-018, L2-013 を追加
+ */
+
+export class InvalidValidatorIdError extends Error {
+  readonly invalidValue: string;
+  constructor(raw: string) {
+    super(`Invalid validator ID: "${raw}". Must be one of the registered valid IDs.`);
+    this.name = 'InvalidValidatorIdError';
+    this.invalidValue = raw;
+  }
+}
+
+const VALIDATOR_ID_PATTERN = /^L[0-4]-\d{3}$/;
+
+/** バリデータID -> バリデータ名のマップ */
+const VALIDATOR_NAME_MAP: Record<string, string> = {
+  'L0-001': 'fuse-hook-config',
+  'L0-002': 'fuse-mount-status',
+  'L1-017': 'it-test-mock-detection',
+  'L1-018': 'stub-comment-detection',
+  'L2-001': 'phase-gate',
+  'L2-002': 'metadata',
+  'L2-003': 'test-quality',
+  'L2-013': 'cli-e2e-test-existence',
+  'L3-001': 'security',
+  'L3-002': 'performance',
+  'L3-003': 'coverage',
+  'L3-004': 'nyquist',
+  'L4-001': 'drift-detect',
+  'L4-002': 'consistency-check',
+  'L4-003': 'dead-code',
+};
+
+/** バリデータ名 -> バリデータID の逆引きマップ */
+const NAME_TO_ID_MAP: Record<string, string> = Object.fromEntries(
+  Object.entries(VALIDATOR_NAME_MAP).map(([id, name]) => [name, id])
+);
+
+/** 有効なValidatorID集合 */
+const VALID_IDS = new Set(Object.keys(VALIDATOR_NAME_MAP));
+
+export class ValidatorId {
+  readonly value: string;
+  readonly layer: 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
+  readonly sequence: string;
+
+  private constructor(value: string) {
+    this.value = value;
+    this.layer = value.substring(0, 2) as 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
+    this.sequence = value.substring(3);
+    Object.freeze(this);
+  }
+
+  static create(raw: string): ValidatorId {
+    if (!VALIDATOR_ID_PATTERN.test(raw)) {
+      throw new InvalidValidatorIdError(raw);
+    }
+    if (!VALID_IDS.has(raw)) {
+      throw new InvalidValidatorIdError(raw);
+    }
+    return new ValidatorId(raw);
+  }
+
+  static fromName(name: string): ValidatorId {
+    const id = NAME_TO_ID_MAP[name];
+    if (!id) {
+      throw new InvalidValidatorIdError(name);
+    }
+    return new ValidatorId(id);
+  }
+
+  getLayer(): 'L0' | 'L1' | 'L2' | 'L3' | 'L4' {
+    return this.layer;
+  }
+
+  getName(): string {
+    return VALIDATOR_NAME_MAP[this.value];
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  equals(other: ValidatorId): boolean {
+    return this.value === other.value;
+  }
+}

package/scripts/harness/validator-system/index.ts

@@ -0,0 +1,51 @@
+/**
+ * @layer barrel
+ * @unit validator-system
+ *
+ * validator-system ユニットの公開バレルエクスポート
+ */
+
+// --- Composition Root ---
+export { createValidatorSystemModule } from './composition-root.js';
+export type { ValidatorSystemModule } from './composition-root.js';
+
+// --- Domain Value Objects ---
+export { ValidatorId, InvalidValidatorIdError } from './domain/value-objects/validator-id.js';
+export { ValidatorDefinition } from './domain/value-objects/validator-definition.js';
+export { ValidationRule } from './domain/value-objects/validation-rule.js';
+export { ValidationResult } from './domain/value-objects/validation-result.js';
+export { LayerConfig } from './domain/value-objects/layer-config.js';
+export { DriftReport } from './domain/value-objects/drift-report.js';
+export { ConsistencyReport } from './domain/value-objects/consistency-report.js';
+export { DeadCodeReport } from './domain/value-objects/dead-code-report.js';
+
+// --- Domain Services ---
+export { ValidatorRegistry, UnknownValidatorError } from './domain/services/validator-registry.js';
+export { ValidatorExecutionService, ValidatorExecutionError } from './domain/services/validator-execution-service.js';
+export { DriftDetectionService } from './domain/services/l4/drift-detection-service.js';
+export { ConsistencyCheckService } from './domain/services/l4/consistency-check-service.js';
+export { DeadCodeDetectionService } from './domain/services/l4/dead-code-detection-service.js';
+
+// --- Application DTOs ---
+export type { ValidationResultContract } from './application/dto/validation-result-contract.js';
+export type { ValidatorRelaxationProfile } from './application/dto/validator-relaxation-profile.js';
+export type { AggregatedValidationReport } from './application/dto/aggregated-validation-report.js';
+
+// --- Application Use Cases ---
+export { RunL2ValidatorsUseCase } from './application/use-cases/run-l2-validators-usecase.js';
+export { RunL3ValidatorsUseCase, CoverageReportNotFoundError } from './application/use-cases/run-l3-validators-usecase.js';
+export { RunL4ValidatorsUseCase, DesignDocumentReadError } from './application/use-cases/run-l4-validators-usecase.js';
+export { RunQuickModeUseCase, InvalidRelaxationProfileError } from './application/use-cases/run-quick-mode-usecase.js';
+export { AggregateValidationResultsUseCase } from './application/use-cases/aggregate-validation-results-usecase.js';
+export { RunFullValidationUseCase } from './application/use-cases/run-full-validation-usecase.js';
+
+// --- Mappers ---
+export { ValidationResultContractMapper } from './application/mappers/validation-result-contract-mapper.js';
+
+// --- Presentation ---
+export { RunValidatorsHandler } from './presentation/handlers/run-validators-handler.js';
+export { RunQuickModeHandler } from './presentation/handlers/run-quick-mode-handler.js';
+export { ReportValidationResultsHandler, isValidationResultContract } from './presentation/handlers/report-validation-results-handler.js';
+export { HumanValidationResultFormatter } from './presentation/formatters/human-validation-result-formatter.js';
+export { AgentValidationResultFormatter } from './presentation/formatters/agent-validation-result-formatter.js';
+export { CiValidationResultFormatter } from './presentation/formatters/ci-validation-result-formatter.js';

package/scripts/harness/validator-system/infrastructure/adapters/adr-foundation-reference-adapter.ts

@@ -0,0 +1,57 @@
+/**
+ * @layer infrastructure
+ * @unit validator-system
+ *
+ * AdrFoundationReferenceAdapter — AdrReferencePort実装
+ */
+import type { AdrReferencePort, AdrMetadata } from '../../domain/ports/adr-reference-port.js';
+
+export class AdrFoundationReferenceAdapter implements AdrReferencePort {
+  async exists(adrRef: string): Promise<boolean> {
+    try {
+      const adr = await this.findAdr(adrRef);
+      return adr !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  async getMetadata(adrRef: string): Promise<AdrMetadata | null> {
+    try {
+      const adr = await this.findAdr(adrRef);
+      if (!adr) {
+        return null;
+      }
+
+      const frontmatter = adr.getFrontmatter();
+      return {
+        adrId: adr.toAdrRef(),
+        title: frontmatter.title,
+        status: frontmatter.status.value,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  private async findAdr(adrRef: string): Promise<{
+    readonly getFrontmatter: () => { readonly title: string; readonly status: { readonly value: AdrMetadata['status'] } };
+    readonly toAdrRef: () => string;
+  } | null> {
+    const { createAdrFoundationModule } = await import('../../../adr-foundation/composition-root.js');
+    const { AdrId } = await import('../../../adr-foundation/domain/value-objects/adr-id.js');
+    const mod = createAdrFoundationModule(process.cwd());
+    const repository = mod.adrRepository;
+
+    if ('findById' in repository && typeof repository.findById === 'function') {
+      return repository.findById(AdrId.create(adrRef));
+    }
+
+    if ('findAll' in repository && typeof repository.findAll === 'function') {
+      const adrs = await repository.findAll();
+      return adrs.find((adr) => adr.toAdrRef() === adrRef) ?? null;
+    }
+
+    return null;
+  }
+}