phasegate 0.16.0 → 0.31.0

package/scripts/harness/agent-integration/infrastructure/adapters/file-system-story-reflection-query-adapter.ts

@@ -0,0 +1,122 @@
+// @unit agent-integration
+// @layer infrastructure
+/**
+ * FileSystemStoryReflectionQueryAdapter
+ *
+ * agent-integration ドメインの `StoryReflectionQueryPort` を、
+ * phase-dependency-model 側の CheckStoryReflectionUseCase +
+ * FileSystemStoryReflectionAdapter + HarnessConfigPhaseConfigProvider を
+ * オーケストレートして実装するアダプタ。
+ *
+ * 役割:
+ *   1. phasegate.config.json を読み込み、PhaseConfigSection へ正規化
+ *   2. HarnessConfigPhaseConfigProvider 経由で storyReflection 設定を解決
+ *   3. StoryReflectionChecker + FileSystemStoryReflectionAdapter 経由で
+ *      inception → product の @story-id 反映を検証
+ *   4. 結果を agent-integration の StoryReflectionQueryResult に写像
+ *
+ * 例外: 設定ファイルが存在しない/読めない場合は "skipped" を返し、
+ *       hook 全体をブロックしない（Fail-safe）。
+ */
+
+import { readFile } from 'node:fs/promises';
+
+import type { StoryReflectionQueryPort } from '../../domain/ports/story-reflection-query-port.js';
+import { StoryReflectionQueryResult } from '../../domain/value-objects/story-reflection-query-result.js';
+import { FileSystemStoryReflectionAdapter } from '../../../phase-dependency-model/infrastructure/filesystem/file-system-story-reflection-adapter.js';
+import { StoryReflectionChecker } from '../../../phase-dependency-model/domain/services/story-reflection-checker.js';
+import { CheckStoryReflectionUseCase } from '../../../phase-dependency-model/application/usecases/check-story-reflection-usecase.js';
+import {
+  HarnessConfigPhaseConfigProvider,
+  type PhaseConfigSection,
+  type PhasePresetInput,
+  type StoryReflectionSectionInput,
+} from '../../../phase-dependency-model/infrastructure/config/harness-config-phase-config-provider.js';
+import type { StoryReflectionResult } from '../../../phase-dependency-model/domain/values/story-reflection-result.js';
+
+export interface FileSystemStoryReflectionQueryAdapterDeps {
+  readonly rootDir: string;
+  readonly configPath: string;
+}
+
+interface RawPhaseDependenciesSection {
+  readonly preset?: PhasePresetInput;
+  readonly override?: boolean;
+  readonly storyReflection?: StoryReflectionSectionInput;
+}
+
+interface RawConfigDocument {
+  readonly phaseDependencies?: RawPhaseDependenciesSection;
+  readonly reporting?: { readonly outputDir?: string };
+}
+
+export class FileSystemStoryReflectionQueryAdapter
+  implements StoryReflectionQueryPort
+{
+  private readonly rootDir: string;
+  private readonly configPath: string;
+
+  constructor(deps: FileSystemStoryReflectionQueryAdapterDeps) {
+    this.rootDir = deps.rootDir;
+    this.configPath = deps.configPath;
+  }
+
+  async checkReflection(unitId: string): Promise<StoryReflectionQueryResult> {
+    let raw: RawConfigDocument;
+    try {
+      const content = await readFile(this.configPath, 'utf8');
+      raw = JSON.parse(content) as RawConfigDocument;
+    } catch {
+      // 設定が読めない場合は fail-safe で skipped 扱い
+      return StoryReflectionQueryResult.skipped();
+    }
+
+    const phaseConfigSection: PhaseConfigSection = {
+      customization: {
+        preset: raw.phaseDependencies?.preset,
+        overrideEnabled: raw.phaseDependencies?.override ?? false,
+      },
+      storyReflection: raw.phaseDependencies?.storyReflection,
+      reportingOutputDir: raw.reporting?.outputDir,
+    };
+
+    const provider = new HarnessConfigPhaseConfigProvider({
+      config: phaseConfigSection,
+      defaultOutputDir: raw.reporting?.outputDir ?? '.harness/reports',
+    });
+
+    const config = await provider.getStoryReflectionConfig();
+
+    if (!config.enabled) {
+      return StoryReflectionQueryResult.skipped();
+    }
+
+    const fsAdapter = new FileSystemStoryReflectionAdapter({ rootDir: this.rootDir });
+    const checker = new StoryReflectionChecker(fsAdapter);
+    const useCase = new CheckStoryReflectionUseCase({ checker });
+
+    const result = await useCase.execute({ unitId, config });
+
+    return FileSystemStoryReflectionQueryAdapter.mapResult(result);
+  }
+
+  private static mapResult(
+    result: StoryReflectionResult,
+  ): StoryReflectionQueryResult {
+    const warnings = result.warnings.map(
+      (w) =>
+        `${w.storyId}: ${w.productPath} に @story-id ${w.storyId} が未反映 (optional, inception: ${w.inceptionPath})`,
+    );
+
+    if (!result.isBlocked()) {
+      return StoryReflectionQueryResult.pass();
+    }
+
+    const blockers = result.violations.map(
+      (v) =>
+        `${v.productPath} に @story-id ${v.storyId} が反映されていません (inception: ${v.inceptionPath})`,
+    );
+
+    return StoryReflectionQueryResult.block(blockers, warnings);
+  }
+}

package/scripts/harness/agent-integration/infrastructure/adapters/harness-config-config-query-adapter.ts

@@ -31,9 +31,19 @@ interface HarnessesSection {
   deadCodeGC?: boolean;
 }
 
+interface ProtectedFilesSection {
+  exclude?: string[];
+}
+
+interface QuickModeSection {
+  relaxedGates?: string[];
+}
+
 interface HarnessConfigDocument {
   harnesses?: HarnessesSection;
   project?: ProjectSection;
+  protectedFiles?: ProtectedFilesSection;
+  quickMode?: QuickModeSection;
 }
 
 export class HarnessConfigConfigQueryAdapter implements ConfigQueryPort {
@@ -77,6 +87,16 @@ export class HarnessConfigConfigQueryAdapter implements ConfigQueryPort {
     return [];
   }
 
+  async getProtectedFileExclusions(): Promise<string[]> {
+    const config = this.loadConfig();
+    return config.protectedFiles?.exclude ?? [];
+  }
+
+  async getRelaxedGates(): Promise<readonly string[]> {
+    const config = this.loadConfig();
+    return config.quickMode?.relaxedGates ?? [];
+  }
+
   getProjectPaths(): ProjectPaths {
     const config = this.loadConfig();
     const paths = config.project?.paths;

package/scripts/harness/agent-integration/infrastructure/adapters/phase-gate-query-adapter.ts

@@ -4,16 +4,26 @@
 import type { PhaseGateQueryPort } from '../../domain/ports/phase-gate-query-port.js';
 import type { WriteTargetScope } from '../../domain/value-objects/write-target-scope.js';
 import { PhaseGateQueryResult } from '../../domain/value-objects/phase-gate-query-result.js';
+import { toPhaseConfigSection } from '../../../config-foundation/application/mappers/phase-config-section-mapper.js';
+import { createConfigFoundationModule } from '../../../config-foundation/composition-root.js';
+import { ConfigValidationError } from '../../../config-foundation/domain/errors/config-validation-error.js';
 
 export class PhaseGateQueryAdapter implements PhaseGateQueryPort {
-  async checkGate(scope: WriteTargetScope): Promise<PhaseGateQueryResult> {
+  async checkGate(scope: WriteTargetScope, targetFilePath?: string): Promise<PhaseGateQueryResult> {
     try {
+      const configModule = createConfigFoundationModule();
+      const resolvedConfig = await configModule.usecases.loadResolvedConfigUseCase.execute();
       const { createPhaseDependencyModelModule } = await import('../../../phase-dependency-model/composition-root.js');
-      const mod = createPhaseDependencyModelModule({ rootDir: process.cwd() });
+      const mod = createPhaseDependencyModelModule({
+        rootDir: process.cwd(),
+        phaseConfig: toPhaseConfigSection(resolvedConfig.config),
+        reportOutputDir: resolvedConfig.config.reporting.outputDir,
+      });
       const result = await mod.checkPhaseGateCommandHandler.execute({
         targetLevel: scope.level,
         unitId: scope.unitId,
         storyId: scope.storyId,
+        targetFilePath,
       });
 
       if (result.exitCode === 0) {
@@ -25,7 +35,11 @@ export class PhaseGateQueryAdapter implements PhaseGateQueryPort {
       }
 
       return PhaseGateQueryResult.create(true, [], ['phase gate check returned error']);
-    } catch {
+    } catch (error) {
+      if (error instanceof ConfigValidationError) {
+        return PhaseGateQueryResult.create(false, [error.message], []);
+      }
+
       return PhaseGateQueryResult.create(true, [], ['phase-dependency-model not available']);
     }
   }

package/scripts/harness/agent-integration/presentation/pre-tool-use-hook.ts

@@ -8,8 +8,10 @@
  */
 
 import { HandlePreToolUseUseCase } from '../application/usecases/handle-pre-tool-use-usecase.js';
+import { BashWriteTargetExtractor } from '../domain/services/bash-write-target-extractor.js';
 import { HarnessConfigConfigQueryAdapter } from '../infrastructure/adapters/harness-config-config-query-adapter.js';
 import { PhaseGateQueryAdapter } from '../infrastructure/adapters/phase-gate-query-adapter.js';
+import { FileSystemStoryReflectionQueryAdapter } from '../infrastructure/adapters/file-system-story-reflection-query-adapter.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
 
@@ -20,6 +22,7 @@ interface PreToolUseHookInput {
     path?: string;
     file_path?: string;
     paths?: string[];
+    command?: string;
     [key: string]: unknown;
   };
 }
@@ -91,13 +94,37 @@ async function main(): Promise<void> {
     targetFilePaths.push(...input.tool_input.paths.map(toRelative));
   }
 
+  // Bash 経由書き込みのフェーズゲート対応 (A-2.5)
+  // Bash command 文字列からリダイレクト・tee・sed -i・cp・mv・touch 等の
+  // 書き込み先ファイルパスを抽出し、フェーズゲートチェック対象に含める。
+  // Bash 書き込みを検出した場合、effectiveToolName を 'Write' に偽装して
+  // translator の WRITE_TOOLS チェックを通過させる（Bash のままではフェーズゲートが
+  // スキップされるため）。
+  let effectiveToolName = toolName;
+  if (toolName === 'Bash' && typeof input.tool_input?.command === 'string') {
+    const extractor = new BashWriteTargetExtractor();
+    const bashTargets = extractor.extract(input.tool_input.command);
+    if (bashTargets.length > 0) {
+      targetFilePaths.push(...bashTargets.map(toRelative));
+      effectiveToolName = 'Write';
+    }
+  }
+
   try {
     const configPath = await findConfigPath();
     const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
     const phaseGateQueryPort = new PhaseGateQueryAdapter();
-    const useCase = new HandlePreToolUseUseCase({ configQueryPort, phaseGateQueryPort });
+    const storyReflectionQueryPort = new FileSystemStoryReflectionQueryAdapter({
+      rootDir: path.dirname(configPath),
+      configPath,
+    });
+    const useCase = new HandlePreToolUseUseCase({
+      configQueryPort,
+      phaseGateQueryPort,
+      storyReflectionQueryPort,
+    });
 
-    const output = await useCase.execute({ toolName, targetFilePaths });
+    const output = await useCase.execute({ toolName: effectiveToolName, targetFilePaths });
 
     if (output.shouldBlock) {
       const msg = output.error?.message

package/scripts/harness/biome-ast-engine/domain/services/lint-runner.ts

@@ -26,6 +26,9 @@ const toStringArray = (value: unknown, fallback: readonly string[]): readonly st
     ? Object.freeze([...value])
     : fallback;
 
+const isTestFile = (snapshot: SourceModuleSnapshot): boolean =>
+  snapshot.filePath.toString().includes('__tests__/');
+
 export class LintRunner {
   private readonly ruleDefinitionRegistry: RuleDefinitionRegistry;
 
@@ -98,6 +101,10 @@ export class LintRunner {
             LayerBoundary.standardMatrix(),
             layerByFile
           )) {
+            const fromSnapshot = snapshotByPath.get(edge.from.toString());
+            if (fromSnapshot && isTestFile(fromSnapshot)) {
+              continue;
+            }
             ruleViolations.push(
               RuleViolation.create({
                 filePath: edge.from,
@@ -112,6 +119,10 @@ export class LintRunner {
 
           for (const cycle of params.importGraph.detectCycles()) {
             const firstPath = cycle.path[0];
+            const firstSnapshot = snapshotByPath.get(firstPath.toString());
+            if (firstSnapshot && isTestFile(firstSnapshot)) {
+              continue;
+            }
             ruleViolations.push(
               RuleViolation.create({
                 filePath: firstPath,
@@ -127,6 +138,9 @@ export class LintRunner {
         }
         case 'enforce-folder-structure': {
           for (const snapshot of params.snapshots) {
+            if (isTestFile(snapshot)) {
+              continue;
+            }
             if (snapshot.declaredLayer !== null && !snapshot.belongsToLayerDirectory()) {
               ruleViolations.push(
                 RuleViolation.create({
@@ -147,6 +161,9 @@ export class LintRunner {
           const maxAnyRatio = toNumber(rule.config.maxAnyRatio, 0.05);
 
           for (const snapshot of params.snapshots) {
+            if (isTestFile(snapshot)) {
+              continue;
+            }
             if (
               snapshot.anyTypeCount > maxAnyCount ||
               snapshot.anyRatio() > maxAnyRatio
@@ -223,8 +240,15 @@ export class LintRunner {
         case 'no-comment-flood': {
           const maxCommentRatio = toNumber(rule.config.maxCommentRatio, 0.35);
           const maxRepeatedBlocks = toNumber(rule.config.maxRepeatedBlocks, 1);
+          const minLogicalLines = toNumber(rule.config.minLogicalLines, 15);
 
           for (const snapshot of params.snapshots) {
+            if (isTestFile(snapshot)) {
+              continue;
+            }
+            if (snapshot.logicalLineCount < minLogicalLines) {
+              continue;
+            }
             if (
               snapshot.commentDensity() > maxCommentRatio ||
               snapshot.repeatedCommentBlocks > maxRepeatedBlocks

package/scripts/harness/biome-ast-engine/domain/services/rule-definition-registry.ts

@@ -92,7 +92,7 @@ export class RuleDefinitionRegistry {
         'no-comment-flood',
         'L1-008',
         Object.freeze([REQUIRED_INPUT.sourceModuleSnapshots]),
-        Object.freeze({ maxCommentRatio: 0.35, maxRepeatedBlocks: 1 }),
+        Object.freeze({ maxCommentRatio: 0.35, maxRepeatedBlocks: 1, minLogicalLines: 15 }),
         'コメント過多を検出する',
         '不要なコメントを整理し自己説明的なコードへ改善する'
       ),

package/scripts/harness/biome-ast-engine/domain/value-objects/source-module-snapshot.ts

@@ -59,8 +59,9 @@ export class SourceModuleSnapshot {
   readonly duplicationFingerprints: readonly string[];
   readonly exportedSymbols: readonly string[];
   readonly isEntrypointCandidate: boolean;
+  readonly hasRawLayerAnnotation: boolean;
 
-  private constructor(props: Omit<SourceModuleSnapshotProps, 'declaredLayer'> & { declaredLayer: LayerName | null }) {
+  private constructor(props: Omit<SourceModuleSnapshotProps, 'declaredLayer'> & { declaredLayer: LayerName | null; hasRawLayerAnnotation: boolean }) {
     this.filePath = props.filePath;
     this.declaredUnit = props.declaredUnit;
     this.declaredLayer = props.declaredLayer;
@@ -73,6 +74,7 @@ export class SourceModuleSnapshot {
     this.duplicationFingerprints = props.duplicationFingerprints;
     this.exportedSymbols = props.exportedSymbols;
     this.isEntrypointCandidate = props.isEntrypointCandidate;
+    this.hasRawLayerAnnotation = props.hasRawLayerAnnotation;
   }
 
   static create(props: SourceModuleSnapshotProps): SourceModuleSnapshot {
@@ -83,6 +85,7 @@ export class SourceModuleSnapshot {
         filePath: props.filePath,
         declaredUnit: props.declaredUnit,
         declaredLayer,
+        hasRawLayerAnnotation: props.declaredLayer !== null,
         imports: Object.freeze([...props.imports]),
         anyTypeCount: ensureNonNegative(props.anyTypeCount, 'anyTypeCount'),
         typedNodeCount: ensureNonNegative(props.typedNodeCount, 'typedNodeCount'),
@@ -104,7 +107,7 @@ export class SourceModuleSnapshot {
   }
 
   hasLayerComment(): boolean {
-    return this.declaredLayer !== null;
+    return this.hasRawLayerAnnotation;
   }
 
   anyRatio(): number {

package/scripts/harness/biome-ast-engine/infrastructure/adapters/node-workspace-file-adapter.ts

@@ -11,7 +11,7 @@ import { FilePath as FilePathVO } from '../../domain/value-objects/file-path.js'
 import type { WorkspaceFilePort } from '../../domain/ports/workspace-file-port.js';
 
 const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts']);
-const EXCLUDED_DIRS = new Set(['node_modules', 'dist', 'coverage', '__fixtures__']);
+const EXCLUDED_DIRS = new Set(['node_modules', 'dist', 'coverage', '__fixtures__', 'fixtures']);
 
 export interface NodeWorkspaceFileAdapterDeps {
   readonly rootDir: string;

package/scripts/harness/biome-ast-engine/infrastructure/adapters/typescript-source-module-analyzer-adapter.ts

@@ -64,7 +64,7 @@ export class TypeScriptSourceModuleAnalyzerAdapter implements SourceModuleAnalyz
       snapshots.push(
         SourceModuleSnapshot.create({
           filePath,
-          declaredUnit: unitResult.unitName,
+          declaredUnit: unitResult.unitNames[0],
           declaredLayer: layerResult.layerName,
           imports,
           anyTypeCount: anyCount,

package/scripts/harness/biome-ast-engine/infrastructure/parsers/unit-comment-parser.ts

@@ -3,24 +3,29 @@
  * @unit biome-ast-engine
  */
 
-const UNIT_COMMENT_PATTERN = /^\s*(?:\/\/|\/\*\*?\s*|\*)\s*@unit\s+(\S+)/m;
+const UNIT_COMMENT_PATTERN = /^\s*(?:\/\/|\/\*\*?\s*|\*)\s*@unit\s+(.+)/gm;
 
 export type UnitCommentResult = {
-  readonly unitName: string | null;
+  readonly unitNames: readonly string[];
 };
 
 /**
  * ソースコードから `// @unit {unit}` コメントを抽出する。
  * JSDoc (`/** @unit ... * /`) 形式にも対応する。
+ * カンマ区切りで複数ユニットを指定でき、複数行の @unit も収集する。
+ * 結果は重複除去済み。
  */
 export const parseUnitComment = (sourceCode: string): UnitCommentResult => {
-  const match = sourceCode.match(UNIT_COMMENT_PATTERN);
+  const matches = sourceCode.matchAll(UNIT_COMMENT_PATTERN);
+  const names: string[] = [];
 
-  if (!match) {
-    return { unitName: null };
+  for (const match of matches) {
+    const raw = match[1].replace(/\s*\*\/$/, '').trim();
+    const parts = raw.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+    names.push(...parts);
   }
 
-  const raw = match[1].replace(/\s*\*\/$/, '');
+  const deduplicated = [...new Set(names)];
 
-  return { unitName: raw };
+  return { unitNames: Object.freeze(deduplicated) };
 };

package/scripts/harness/ci-governance/composition-root.ts

@@ -1,4 +1,5 @@
 /**
+ * @layer infrastructure
  * @unit ci-governance
  *
  * Composition Root - 依存性の組み立て

package/scripts/harness/config-foundation/application/mappers/phase-config-section-mapper.ts

@@ -0,0 +1,44 @@
+/**
+ * @layer application
+ * @unit config-foundation
+ */
+import type { HarnessConfigV2 } from '../../domain/harness-config.js';
+
+function toPhasePreset(
+  value: string,
+): 'default' | 'full' | 'standard' | 'minimal' | 'custom' {
+  if (
+    value === 'default'
+    || value === 'full'
+    || value === 'standard'
+    || value === 'minimal'
+    || value === 'custom'
+  ) {
+    return value;
+  }
+
+  return 'default';
+}
+
+type PhaseDependenciesWithGates = HarnessConfigV2['phaseDependencies'] & {
+  readonly gates?: readonly unknown[];
+};
+
+export function toPhaseConfigSection(resolvedConfig: HarnessConfigV2) {
+  const phaseDependencies = resolvedConfig.phaseDependencies as PhaseDependenciesWithGates;
+
+  return {
+    planningMode: resolvedConfig.planningMode,
+    customization: {
+      preset: toPhasePreset(phaseDependencies.preset),
+      overrideEnabled: phaseDependencies.override,
+      rules: phaseDependencies.customRules.map((rule) => ({
+        targetPhase: rule.phase,
+        condition: 'requires' as const,
+        action: rule.requires,
+      })),
+      gates: phaseDependencies.gates ?? [],
+    },
+    reportingOutputDir: resolvedConfig.reporting.outputDir,
+  };
+}

package/scripts/harness/config-foundation/application/usecases/load-resolved-config-use-case.ts

@@ -42,7 +42,26 @@ function formatHarnessErrors(errors: readonly HarnessError[]): string {
 }
 
 function toSourceDocument(document: unknown): HarnessConfigSourceDocument {
-  return document as HarnessConfigSourceDocument;
+  const sourceDocument = document as HarnessConfigSourceDocument & {
+    readonly phaseDependencies?: HarnessConfigSourceDocument['phaseDependencies'] & {
+      readonly gates?: readonly unknown[];
+    };
+  };
+
+  if (
+    sourceDocument.phaseDependencies === undefined
+    || sourceDocument.phaseDependencies.gates === undefined
+  ) {
+    return sourceDocument;
+  }
+
+  return {
+    ...sourceDocument,
+    phaseDependencies: {
+      ...sourceDocument.phaseDependencies,
+      gates: sourceDocument.phaseDependencies.gates ?? [],
+    },
+  } as HarnessConfigSourceDocument;
 }
 
 export function validateDocumentOrThrow(

package/scripts/harness/config-foundation/domain/harness-config.ts

@@ -23,6 +23,7 @@ import type { L4Config } from './value-objects/l4-config.js';
 export type LayerId = 'L1' | 'L2' | 'L3' | 'L4';
 export type PresetId = 'minimal' | 'standard' | 'strict';
 export type PlanningModeValue = 'interactive' | 'embedded-qa';
+export type PhaseDependenciesPresetId = 'default' | 'full' | 'standard' | 'minimal' | 'custom';
 type DeepPartial<T> = {
   [K in keyof T]?: T[K] extends Array<infer TItem>
     ? Array<DeepPartial<TItem>>
@@ -76,7 +77,7 @@ export interface HarnessConfigResolvedDocument {
     relaxedGates: string[];
   };
   phaseDependencies: {
-    preset: 'default' | 'custom';
+    preset: PhaseDependenciesPresetId;
     override: boolean;
     customRules: Array<{
       phase: string;

package/scripts/harness/config-foundation/domain/value-objects/phase-dependencies-config.ts

@@ -7,17 +7,20 @@
  */
 import { CustomPhaseRule } from './custom-phase-rule.js';
 import type { CustomPhaseRuleProps } from './custom-phase-rule.js';
+import type { PhaseDependenciesPresetId } from '../harness-config.js';
 
 export interface PhaseDependenciesConfigProps {
-  readonly preset: 'default' | 'custom';
+  readonly preset: PhaseDependenciesPresetId;
   readonly override: boolean;
   readonly customRules: readonly CustomPhaseRuleProps[];
+  readonly gates?: readonly unknown[];
 }
 
 export class PhaseDependenciesConfig {
-  readonly preset: 'default' | 'custom';
+  readonly preset: PhaseDependenciesPresetId;
   readonly override: boolean;
   readonly customRules: readonly CustomPhaseRule[];
+  readonly gates: readonly unknown[];
 
   constructor(props: PhaseDependenciesConfigProps) {
     this.preset = props.preset;
@@ -25,6 +28,7 @@ export class PhaseDependenciesConfig {
     this.customRules = props.customRules.map(
       (rule) => new CustomPhaseRule(rule)
     );
+    this.gates = Object.freeze([...(props.gates ?? [])]);
   }
 
   static create(raw: PhaseDependenciesConfigProps): PhaseDependenciesConfig {
@@ -35,12 +39,22 @@ export class PhaseDependenciesConfig {
     return this.customRules.length > 0;
   }
 
+  hasCustomGates(): boolean {
+    return this.gates.length > 0;
+  }
+
   equals(other: PhaseDependenciesConfig): boolean {
     if (this.preset !== other.preset) return false;
     if (this.override !== other.override) return false;
     if (this.customRules.length !== other.customRules.length) return false;
-    return this.customRules.every((rule, idx) =>
+    if (
+      !this.customRules.every((rule, idx) =>
       rule.equals(other.customRules[idx])
-    );
+      )
+    ) {
+      return false;
+    }
+
+    return JSON.stringify(this.gates) === JSON.stringify(other.gates);
   }
 }