phasegate 0.15.0

package/scripts/harness/quick-mode/domain/value-objects/changed-file.ts

@@ -0,0 +1,56 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * 変更ファイル1件を表す値オブジェクト
+ */
+
+import { type ChangeKind, isChangeKind } from '../types/change-kind.js';
+
+export class ChangedFile {
+  readonly filePath: string;
+  readonly changeKind: ChangeKind;
+
+  private constructor(filePath: string, changeKind: ChangeKind) {
+    this.filePath = filePath;
+    this.changeKind = changeKind;
+  }
+
+  static create(params: { filePath: string; changeKind: string }): ChangedFile {
+    const { filePath, changeKind } = params;
+
+    if (!filePath) {
+      throw new Error('filePath must not be empty');
+    }
+    if (filePath.endsWith('/')) {
+      throw new Error('filePath must not end with a slash');
+    }
+    if (!isChangeKind(changeKind)) {
+      throw new Error(`changeKind must be one of 'CREATE', 'MODIFY', 'DELETE'. Got: "${changeKind}"`);
+    }
+
+    return new ChangedFile(filePath, changeKind);
+  }
+
+  isUnder(directoryPrefix: string): boolean {
+    return this.filePath.startsWith(directoryPrefix);
+  }
+
+  hasExtension(ext: string): boolean {
+    return this.filePath.endsWith(ext);
+  }
+
+  matchesPattern(pattern: string): boolean {
+    // Glob/suffix パターンマッチング
+    // '*' はワイルドカードとして扱う
+    if (pattern.startsWith('*')) {
+      const suffix = pattern.slice(1);
+      return this.filePath.endsWith(suffix);
+    }
+    return this.filePath === pattern;
+  }
+
+  equals(other: ChangedFile): boolean {
+    return this.filePath === other.filePath && this.changeKind === other.changeKind;
+  }
+}

package/scripts/harness/quick-mode/domain/value-objects/quick-mode-config.ts

@@ -0,0 +1,69 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * Quick Mode設定を表す値オブジェクト
+ */
+
+export class QuickModeConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'QuickModeConfigError';
+  }
+}
+
+
+export class QuickModeConfig {
+  readonly allowedCategories: readonly string[];
+  readonly maintainedLayers: readonly string[];
+  readonly relaxedGates: readonly string[];
+
+  private constructor(
+    allowedCategories: readonly string[],
+    maintainedLayers: readonly string[],
+    relaxedGates: readonly string[]
+  ) {
+    this.allowedCategories = allowedCategories;
+    this.maintainedLayers = maintainedLayers;
+    this.relaxedGates = relaxedGates;
+    Object.freeze(this);
+  }
+
+  static create(raw: {
+    allowedCategories: string[];
+    maintainedLayers: string[];
+    relaxedGates: string[];
+  }): QuickModeConfig {
+    const { allowedCategories, maintainedLayers, relaxedGates } = raw;
+
+    if (allowedCategories.length === 0) {
+      throw new QuickModeConfigError('allowedCategories must not be empty');
+    }
+
+    return new QuickModeConfig(
+      Object.freeze([...allowedCategories]),
+      Object.freeze([...maintainedLayers]),
+      Object.freeze([...relaxedGates])
+    );
+  }
+
+  isAllowed(category: string): boolean {
+    return this.allowedCategories.includes(category);
+  }
+
+  isMaintained(validatorId: string): boolean {
+    return this.maintainedLayers.includes(validatorId);
+  }
+
+  isRelaxed(validatorId: string): boolean {
+    return this.relaxedGates.includes(validatorId);
+  }
+
+  equals(other: QuickModeConfig): boolean {
+    return (
+      JSON.stringify(this.allowedCategories) === JSON.stringify(other.allowedCategories) &&
+      JSON.stringify(this.maintainedLayers) === JSON.stringify(other.maintainedLayers) &&
+      JSON.stringify(this.relaxedGates) === JSON.stringify(other.relaxedGates)
+    );
+  }
+}

package/scripts/harness/quick-mode/domain/value-objects/quick-mode-decision.ts

@@ -0,0 +1,47 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * Quick Mode最終判定の複合値オブジェクト
+ */
+
+import type { QuickModeEligibility } from './quick-mode-eligibility.js';
+import type { ValidatorRelaxationProfile } from './validator-relaxation-profile.js';
+
+export class QuickModeDecision {
+  readonly eligibility: QuickModeEligibility;
+  readonly relaxationProfile: ValidatorRelaxationProfile | undefined;
+
+  private constructor(
+    eligibility: QuickModeEligibility,
+    relaxationProfile: ValidatorRelaxationProfile | undefined
+  ) {
+    this.eligibility = eligibility;
+    this.relaxationProfile = relaxationProfile;
+  }
+
+  static approved(
+    eligibility: QuickModeEligibility,
+    profile: ValidatorRelaxationProfile
+  ): QuickModeDecision {
+    if (!eligibility.isEligible()) {
+      throw new Error('Cannot create approved QuickModeDecision with ineligible eligibility (INV-D2)');
+    }
+    return new QuickModeDecision(eligibility, profile);
+  }
+
+  static rejected(eligibility: QuickModeEligibility): QuickModeDecision {
+    return new QuickModeDecision(eligibility, undefined);
+  }
+
+  isApproved(): boolean {
+    return this.eligibility.isEligible();
+  }
+
+  equals(other: QuickModeDecision): boolean {
+    if (!this.eligibility.equals(other.eligibility)) return false;
+    if (this.relaxationProfile === undefined && other.relaxationProfile === undefined) return true;
+    if (this.relaxationProfile === undefined || other.relaxationProfile === undefined) return false;
+    return this.relaxationProfile.equals(other.relaxationProfile);
+  }
+}

package/scripts/harness/quick-mode/domain/value-objects/quick-mode-eligibility.ts

@@ -0,0 +1,62 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * Quick Mode適用可否の判定結果を表す値オブジェクト
+ */
+
+import type { RejectionRule } from '../types/rejection-rule.js';
+import type { ChangedFile } from './changed-file.js';
+
+export class QuickModeEligibility {
+  readonly eligible: boolean;
+  readonly reason: string;
+  readonly rejectionRule: RejectionRule | undefined;
+  readonly rejectedFiles: readonly ChangedFile[] | undefined;
+
+  private constructor(
+    eligible: boolean,
+    reason: string,
+    rejectionRule: RejectionRule | undefined,
+    rejectedFiles: readonly ChangedFile[] | undefined
+  ) {
+    this.eligible = eligible;
+    this.reason = reason;
+    this.rejectionRule = rejectionRule;
+    this.rejectedFiles = rejectedFiles;
+    Object.freeze(this);
+  }
+
+  static eligible(reason: string): QuickModeEligibility {
+    if (!reason) {
+      throw new Error('reason must not be empty (INV-E3)');
+    }
+    return new QuickModeEligibility(true, reason, undefined, undefined);
+  }
+
+  static rejected(
+    rule: RejectionRule,
+    rejectedFiles: readonly ChangedFile[],
+    reason: string
+  ): QuickModeEligibility {
+    if (rejectedFiles.length === 0) {
+      throw new Error('rejectedFiles must not be empty when eligible=false (INV-E2)');
+    }
+    if (!reason) {
+      throw new Error('reason must not be empty (INV-E3)');
+    }
+    return new QuickModeEligibility(false, reason, rule, Object.freeze([...rejectedFiles]));
+  }
+
+  isEligible(): boolean {
+    return this.eligible;
+  }
+
+  equals(other: QuickModeEligibility): boolean {
+    return (
+      this.eligible === other.eligible &&
+      this.reason === other.reason &&
+      this.rejectionRule === other.rejectionRule
+    );
+  }
+}

package/scripts/harness/quick-mode/domain/value-objects/validator-relaxation-profile.ts

@@ -0,0 +1,116 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * Quick Mode時のバリデータ実行構成を表す値オブジェクト
+ */
+
+const L2_IDS = ['L2-001', 'L2-002', 'L2-003'] as const;
+const L3_IDS = ['L3-001', 'L3-002', 'L3-003', 'L3-004'] as const;
+
+type L2Id = (typeof L2_IDS)[number];
+type L3Id = (typeof L3_IDS)[number];
+
+export interface ValidatorRelaxationProfileParams {
+  levelDependencyRelaxed: false;
+  l1: { all: true };
+  l2: { maintained: string[]; skipped: string[] };
+  l3: { maintained: string[]; skipped: string[] };
+  l4: { all: false };
+  phaseExecution: { twoPhaseRequired: false };
+}
+
+export class ValidatorRelaxationProfile {
+  readonly levelDependencyRelaxed: false;
+  readonly l1: { readonly all: true };
+  readonly l2: { readonly maintained: readonly string[]; readonly skipped: readonly string[] };
+  readonly l3: { readonly maintained: readonly string[]; readonly skipped: readonly string[] };
+  readonly l4: { readonly all: false };
+  readonly phaseExecution: { readonly twoPhaseRequired: false };
+
+  private constructor(params: ValidatorRelaxationProfileParams) {
+    this.levelDependencyRelaxed = false;
+    this.l1 = Object.freeze({ all: true as const });
+    this.l2 = Object.freeze({
+      maintained: Object.freeze([...params.l2.maintained]),
+      skipped: Object.freeze([...params.l2.skipped]),
+    });
+    this.l3 = Object.freeze({
+      maintained: Object.freeze([...params.l3.maintained]),
+      skipped: Object.freeze([...params.l3.skipped]),
+    });
+    this.l4 = Object.freeze({ all: false as const });
+    this.phaseExecution = Object.freeze({ twoPhaseRequired: false as const });
+    Object.freeze(this);
+  }
+
+  static createDefault(): ValidatorRelaxationProfile {
+    return new ValidatorRelaxationProfile({
+      levelDependencyRelaxed: false,
+      l1: { all: true },
+      l2: { maintained: ['L2-002', 'L2-003'], skipped: ['L2-001'] },
+      l3: { maintained: ['L3-001'], skipped: ['L3-002', 'L3-003', 'L3-004'] },
+      l4: { all: false },
+      phaseExecution: { twoPhaseRequired: false },
+    });
+  }
+
+  static create(params: {
+    levelDependencyRelaxed?: false;
+    l1?: { all: true };
+    l2: { maintained: string[]; skipped: string[] };
+    l3: { maintained: string[]; skipped: string[] };
+    l4?: { all: false };
+    phaseExecution?: { twoPhaseRequired: false };
+  }): ValidatorRelaxationProfile {
+    const { l2, l3 } = params;
+
+    // INV-P5: l2.maintained ∪ l2.skipped = {L2-001, L2-002, L2-003}
+    const l2Union = [...l2.maintained, ...l2.skipped].sort();
+    const l2Expected = [...L2_IDS].sort();
+    if (JSON.stringify(l2Union) !== JSON.stringify(l2Expected)) {
+      throw new Error(
+        `INV-P5 violated: l2.maintained ∪ l2.skipped must equal {${L2_IDS.join(', ')}}. Got: {${l2Union.join(', ')}}`
+      );
+    }
+
+    // INV-P6: l3.maintained ∪ l3.skipped = {L3-001, L3-002, L3-003, L3-004}
+    const l3Union = [...l3.maintained, ...l3.skipped].sort();
+    const l3Expected = [...L3_IDS].sort();
+    if (JSON.stringify(l3Union) !== JSON.stringify(l3Expected)) {
+      throw new Error(
+        `INV-P6 violated: l3.maintained ∪ l3.skipped must equal {${L3_IDS.join(', ')}}. Got: {${l3Union.join(', ')}}`
+      );
+    }
+
+    return new ValidatorRelaxationProfile({
+      levelDependencyRelaxed: false,
+      l1: { all: true },
+      l2,
+      l3,
+      l4: { all: false },
+      phaseExecution: { twoPhaseRequired: false },
+    });
+  }
+
+  isMaintained(validatorId: string): boolean {
+    return (
+      this.l2.maintained.includes(validatorId) || this.l3.maintained.includes(validatorId)
+    );
+  }
+
+  isSkipped(validatorId: string): boolean {
+    return (
+      this.l2.skipped.includes(validatorId) || this.l3.skipped.includes(validatorId)
+    );
+  }
+
+  equals(other: ValidatorRelaxationProfile): boolean {
+    return (
+      JSON.stringify(this.l2.maintained) === JSON.stringify(other.l2.maintained) &&
+      JSON.stringify(this.l2.skipped) === JSON.stringify(other.l2.skipped) &&
+      JSON.stringify(this.l3.maintained) === JSON.stringify(other.l3.maintained) &&
+      JSON.stringify(this.l3.skipped) === JSON.stringify(other.l3.skipped)
+    );
+  }
+}

package/scripts/harness/quick-mode/index.ts

@@ -0,0 +1,43 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * quick-mode ユニットの公開エントリポイント
+ */
+
+// Domain Value Objects
+export { ChangeCategory, UnknownChangeCategoryError } from './domain/value-objects/change-category.js';
+export { ChangedFile } from './domain/value-objects/changed-file.js';
+export { ChangeClassification } from './domain/value-objects/change-classification.js';
+export { QuickModeConfig, QuickModeConfigError } from './domain/value-objects/quick-mode-config.js';
+export { QuickModeDecision } from './domain/value-objects/quick-mode-decision.js';
+export { QuickModeEligibility } from './domain/value-objects/quick-mode-eligibility.js';
+export { ValidatorRelaxationProfile } from './domain/value-objects/validator-relaxation-profile.js';
+
+// Domain Services
+export { QuickModeJudgmentEngine } from './domain/services/quick-mode-judgment-engine.js';
+export { ValidatorRelaxationService } from './domain/services/validator-relaxation-service.js';
+
+// Application DTOs
+export type { QuickModeDecisionContract } from './application/dto/quick-mode-decision-contract.js';
+export type { QuickModeEligibilityContract } from './application/dto/quick-mode-eligibility-contract.js';
+export type { ValidatorRelaxationProfileContract } from './application/dto/validator-relaxation-profile-contract.js';
+
+// Application UseCases
+export { JudgeQuickModeEligibilityUseCase } from './application/usecases/judge-quick-mode-eligibility-usecase.js';
+export { BuildRelaxationProfileUseCase, QuickModeNotEligibleError } from './application/usecases/build-relaxation-profile-usecase.js';
+export { ExecuteQuickCiCheckUseCase } from './application/usecases/execute-quick-ci-check-usecase.js';
+
+// Application Mappers
+export { QuickModeDecisionContractMapper } from './application/mappers/quick-mode-decision-contract-mapper.js';
+
+// Infrastructure Adapters
+export { GitDiffChangedFilesAdapter, GitNotAvailableError, GitCommandError } from './infrastructure/adapters/git-diff-changed-files-adapter.js';
+export { HarnessConfigQuickModeConfigAdapter, HarnessConfigNotFoundError, HarnessConfigParseError } from './infrastructure/adapters/harness-config-quick-mode-config-adapter.js';
+export { ValidatorSystemValidatorIdRegistryAdapter } from './infrastructure/adapters/validator-system-validator-id-registry-adapter.js';
+
+// Presentation
+export { CiCheckQuickModeHandler } from './presentation/handlers/ci-check-quick-mode-handler.js';
+export { HumanQuickModeFormatter } from './presentation/formatters/human-quick-mode-formatter.js';
+export { AgentQuickModeFormatter } from './presentation/formatters/agent-quick-mode-formatter.js';
+export { JsonQuickModeFormatter } from './presentation/formatters/json-quick-mode-formatter.js';

package/scripts/harness/quick-mode/infrastructure/adapters/git-diff-changed-files-adapter.ts

@@ -0,0 +1,92 @@
+/**
+ * @layer infrastructure
+ * @unit quick-mode
+ *
+ * git diff から ChangedFile[] を取得する Adapter
+ */
+
+import * as childProcess from 'node:child_process';
+import * as path from 'node:path';
+import { ChangedFile } from '../../domain/value-objects/changed-file.js';
+import type { ChangeKind } from '../../domain/types/change-kind.js';
+
+export class GitNotAvailableError extends Error {
+  constructor(message: string) {
+    super(`Git is not available: ${message}`);
+    this.name = 'GitNotAvailableError';
+  }
+}
+
+export class GitCommandError extends Error {
+  constructor(message: string) {
+    super(`Git command failed: ${message}`);
+    this.name = 'GitCommandError';
+  }
+}
+
+function mapGitStatus(status: string): ChangeKind {
+  if (status === 'A') return 'CREATE';
+  if (status === 'D') return 'DELETE';
+  if (status.startsWith('R')) return 'MODIFY';
+  return 'MODIFY'; // M and others
+}
+
+function normalizePath(filePath: string): string {
+  // path.normalize で ./ や ../ を解決し、先頭の ./ を除去
+  const normalized = path.normalize(filePath);
+  // Windows対応のため / に統一
+  return normalized.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+export class GitDiffChangedFilesAdapter {
+  getChangedFiles(): readonly ChangedFile[] {
+    let output: string;
+
+    try {
+      output = childProcess.execSync('git diff --name-status --cached HEAD', {
+        encoding: 'utf8',
+      }) as string;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (
+        message.includes('git: command not found') ||
+        message.includes('not a git repository') ||
+        message.includes('not found')
+      ) {
+        throw new GitNotAvailableError(message);
+      }
+      throw new GitCommandError(message);
+    }
+
+    if (!output || !output.trim()) {
+      return [];
+    }
+
+    const lines = output.trim().split('\n');
+    const files: ChangedFile[] = [];
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      const parts = line.split('\t');
+      const status = parts[0];
+
+      let filePath: string;
+      if (status.startsWith('R') && parts.length >= 3) {
+        // Rename: R100\told.ts\tnew.ts → 移動先を使用
+        filePath = parts[2];
+      } else {
+        filePath = parts[1];
+      }
+
+      if (!filePath) continue;
+
+      const changeKind = mapGitStatus(status);
+      const normalizedPath = normalizePath(filePath);
+
+      files.push(ChangedFile.create({ filePath: normalizedPath, changeKind }));
+    }
+
+    return Object.freeze(files);
+  }
+}

package/scripts/harness/quick-mode/infrastructure/adapters/harness-config-quick-mode-config-adapter.ts

@@ -0,0 +1,75 @@
+/**
+ * @layer infrastructure
+ * @unit quick-mode
+ *
+ * phasegate.config.json から QuickModeConfig を取得する Adapter
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { QuickModeConfig } from '../../domain/value-objects/quick-mode-config.js';
+
+export class HarnessConfigNotFoundError extends Error {
+  constructor(filePath: string) {
+    super(`phasegate.config.json not found: ${filePath}`);
+    this.name = 'HarnessConfigNotFoundError';
+  }
+}
+
+export class HarnessConfigParseError extends Error {
+  constructor(message: string) {
+    super(`Failed to parse phasegate.config.json: ${message}`);
+    this.name = 'HarnessConfigParseError';
+  }
+}
+
+const DEFAULT_QUICK_MODE_CONFIG = {
+  allowedCategories: ['bugfix', 'docs', 'test', 'config'],
+  maintainedLayers: ['L1', 'L2-002', 'L2-003', 'L3-001'],
+  relaxedGates: ['L2-001', 'L3-002', 'L3-003', 'L3-004', 'L4'],
+};
+
+export class HarnessConfigQuickModeConfigAdapter {
+  private readonly configPath: string;
+
+  constructor(configPath?: string) {
+    this.configPath = configPath ?? path.resolve(process.cwd(), 'phasegate.config.json');
+  }
+
+  async getQuickModeConfig(): Promise<QuickModeConfig> {
+    let content: string;
+
+    try {
+      content = await fs.readFile(this.configPath, 'utf8') as string;
+    } catch (err) {
+      const error = err as NodeJS.ErrnoException;
+      if (error.code === 'ENOENT') {
+        throw new HarnessConfigNotFoundError(this.configPath);
+      }
+      throw err;
+    }
+
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(content) as Record<string, unknown>;
+    } catch (err) {
+      throw new HarnessConfigParseError(err instanceof Error ? err.message : String(err));
+    }
+
+    const quickMode = parsed['quickMode'] as {
+      allowedCategories?: string[];
+      maintainedLayers?: string[];
+      relaxedGates?: string[];
+    } | undefined;
+
+    if (!quickMode) {
+      return QuickModeConfig.create(DEFAULT_QUICK_MODE_CONFIG);
+    }
+
+    return QuickModeConfig.create({
+      allowedCategories: quickMode.allowedCategories ?? DEFAULT_QUICK_MODE_CONFIG.allowedCategories,
+      maintainedLayers: quickMode.maintainedLayers ?? DEFAULT_QUICK_MODE_CONFIG.maintainedLayers,
+      relaxedGates: quickMode.relaxedGates ?? DEFAULT_QUICK_MODE_CONFIG.relaxedGates,
+    });
+  }
+}

package/scripts/harness/quick-mode/infrastructure/adapters/validator-system-validator-id-registry-adapter.ts

@@ -0,0 +1,23 @@
+/**
+ * @layer infrastructure
+ * @unit quick-mode
+ *
+ * integration_contract.md §9 の確定ID一覧を静的定義で保持する ValidatorIdRegistry Adapter
+ */
+
+const STATIC_VALIDATOR_IDS: readonly string[] = Object.freeze([
+  'L1-001', 'L1-002', 'L1-003', 'L1-004', 'L1-005', 'L1-006', 'L1-007', 'L1-008',
+  'L2-001', 'L2-002', 'L2-003',
+  'L3-001', 'L3-002', 'L3-003', 'L3-004',
+  'L4-001', 'L4-002', 'L4-003',
+]);
+
+export class ValidatorSystemValidatorIdRegistryAdapter {
+  getAllValidatorIds(): readonly string[] {
+    return STATIC_VALIDATOR_IDS;
+  }
+
+  async getAllIds(): Promise<readonly string[]> {
+    return STATIC_VALIDATOR_IDS;
+  }
+}

package/scripts/harness/quick-mode/presentation/dto/quick-mode-render-options.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ *
+ * Quick Mode表示オプション DTO
+ */
+
+export interface QuickModeRenderOptions {
+  readonly quick: boolean;
+  readonly files?: string;
+  readonly dryRun?: boolean;
+  readonly format?: 'human' | 'agent' | 'json';
+  readonly failOnReject?: boolean;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ *
+ * AIエージェント向け詳細テキストフォーマッター
+ */
+
+import type { QuickModeDecisionContract } from '../../application/dto/quick-mode-decision-contract.js';
+
+export class AgentQuickModeFormatter {
+  format(decision: QuickModeDecisionContract): string {
+    const { eligibility, relaxationProfile } = decision;
+    const lines: string[] = [];
+
+    lines.push(`## Quick Mode Decision`);
+    lines.push(`eligible: ${eligibility.eligible}`);
+    lines.push(`reason: ${eligibility.reason}`);
+
+    if (!eligibility.eligible) {
+      lines.push(`rejectionRule: ${eligibility.rejectionRule ?? ''}`);
+
+      if (eligibility.rejectedFiles && eligibility.rejectedFiles.length > 0) {
+        lines.push('');
+        lines.push('### Rejected Files');
+        for (const file of eligibility.rejectedFiles) {
+          lines.push(`- ${file.filePath} [${file.changeKind}]`);
+        }
+      }
+    } else if (relaxationProfile) {
+      lines.push('');
+      lines.push('### Relaxation Profile');
+      lines.push(`levelDependencyRelaxed: ${relaxationProfile.levelDependencyRelaxed}`);
+      lines.push(`L1: all=${relaxationProfile.l1.all}`);
+
+      lines.push('');
+      lines.push('#### L2 Validators');
+      lines.push(`Maintained: ${[...relaxationProfile.l2.maintained].join(', ')}`);
+      lines.push(`Skipped: ${[...relaxationProfile.l2.skipped].join(', ')}`);
+
+      lines.push('');
+      lines.push('#### L3 Validators');
+      lines.push(`Maintained: ${[...relaxationProfile.l3.maintained].join(', ')}`);
+      lines.push(`Skipped: ${[...relaxationProfile.l3.skipped].join(', ')}`);
+
+      lines.push('');
+      lines.push('#### L4 Validators');
+      lines.push(`all: ${relaxationProfile.l4.all} (all skipped)`);
+
+      lines.push('');
+      lines.push('#### Phase Execution');
+      lines.push(`twoPhaseRequired: ${relaxationProfile.phaseExecution.twoPhaseRequired}`);
+    }
+
+    return lines.join('\n') + '\n';
+  }
+}