phasegate 0.15.0

package/scripts/harness/agent-integration/domain/services/hook-to-cli-translator.ts

@@ -0,0 +1,300 @@
+/**
+ * @layer domain
+ * @unit agent-integration
+ *
+ * HookToCliTranslator ドメインサービス
+ * HookEvent を HookTranslationResult に変換する変換ルールをカプセル化する
+ */
+
+import type { HookEvent, PreToolUseEvent, PostToolUseEvent, StopEvent } from '../value-objects/hook-event.js';
+import { HookTranslationResult } from '../value-objects/hook-translation-result.js';
+import { ProtectedFileList } from '../value-objects/protected-file-list.js';
+import { WriteTargetScope } from '../value-objects/write-target-scope.js';
+import type { ReentryGuard } from '../entities/reentry-guard.js';
+import type { CliCommandRegistryPort } from '../ports/cli-command-registry-port.js';
+import type { ConfigQueryPort } from '../ports/config-query-port.js';
+
+export class UnsupportedHookTypeError extends Error {
+  constructor(hookType: string) {
+    super(`未サポートのhookTypeです: ${hookType}`);
+    this.name = 'UnsupportedHookTypeError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class CommandNotRegisteredError extends Error {
+  constructor(commandName: string) {
+    super(`CLIコマンドが未登録です: ${commandName}`);
+    this.name = 'CommandNotRegisteredError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export interface HookToCliTranslatorPorts {
+  configQueryPort: {
+    isEnabled?: (hookType: string) => boolean | Promise<boolean>;
+    getProtectedFileList?: () => ProtectedFileList | Promise<ProtectedFileList>;
+    isHookEnabled?: (hookType: string) => boolean | Promise<boolean>;
+    getProtectedFilePatterns?: () => string[] | Promise<string[]>;
+  };
+  reentryGuardStatePort: {
+    isActive: () => boolean | Promise<boolean>;
+  };
+  cliCommandRegistryPort: {
+    has?: (command: string) => boolean | Promise<boolean>;
+    hasCommand?: (command: string) => boolean | Promise<boolean>;
+    get?: (command: string) => string | undefined;
+  };
+}
+
+export class HookToCliTranslator {
+  private readonly configQueryPort: HookToCliTranslatorPorts['configQueryPort'];
+  private readonly reentryGuardStatePort: HookToCliTranslatorPorts['reentryGuardStatePort'];
+  private readonly cliCommandRegistryPort: HookToCliTranslatorPorts['cliCommandRegistryPort'];
+
+  constructor(ports: HookToCliTranslatorPorts) {
+    this.configQueryPort = ports.configQueryPort;
+    this.reentryGuardStatePort = ports.reentryGuardStatePort;
+    this.cliCommandRegistryPort = ports.cliCommandRegistryPort;
+  }
+
+  translate(hookEvent: HookEvent): HookTranslationResult {
+    if (hookEvent.isPreToolUse()) {
+      return this.translatePreToolUse(hookEvent as PreToolUseEvent);
+    }
+    if (hookEvent.isPostToolUse()) {
+      return this.translatePostToolUse(hookEvent as PostToolUseEvent);
+    }
+    if (hookEvent.isStop()) {
+      return this.translateStop(hookEvent as StopEvent);
+    }
+    throw new UnsupportedHookTypeError((hookEvent as HookEvent).hookType);
+  }
+
+  private translatePreToolUse(event: PreToolUseEvent): HookTranslationResult {
+    // Get protected file list from port
+    let protectedFileList: ProtectedFileList;
+
+    if (this.configQueryPort.getProtectedFileList) {
+      const result = this.configQueryPort.getProtectedFileList();
+      if (result instanceof Promise) {
+        throw new Error('Async not supported in sync translate. Use translateAsync.');
+      }
+      protectedFileList = result;
+    } else {
+      protectedFileList = ProtectedFileList.createDefault();
+    }
+
+    const blockedPath = event.targetFilePaths.find((fp) => protectedFileList.matches(fp));
+    if (blockedPath !== undefined) {
+      return HookTranslationResult.block({
+        reason: 'PROTECTED_FILE',
+        blockedFilePath: blockedPath,
+      });
+    }
+    return HookTranslationResult.create({
+      shouldBlock: false,
+      cliArgs: [],
+      expectedExitCode: 0,
+    });
+  }
+
+  private translatePostToolUse(event: PostToolUseEvent): HookTranslationResult {
+    const isEnabled = (() => {
+      const port = this.configQueryPort;
+      if (port.isEnabled) {
+        const r = port.isEnabled('post-tool-use');
+        if (r instanceof Promise) throw new Error('Async not supported in sync translate.');
+        return r;
+      }
+      if (port.isHookEnabled) {
+        const r = port.isHookEnabled('post-tool-use');
+        if (r instanceof Promise) throw new Error('Async not supported in sync translate.');
+        return r;
+      }
+      return true;
+    })();
+
+    if (!isEnabled) {
+      return HookTranslationResult.skip('HOOK_DISABLED');
+    }
+
+    // Check command registry
+    const commandName = 'harness:lint';
+    const hasCommand = (() => {
+      const reg = this.cliCommandRegistryPort;
+      if (reg.has) {
+        const r = reg.has(commandName);
+        if (r instanceof Promise) throw new Error('Async not supported in sync translate.');
+        return r;
+      }
+      if (reg.hasCommand) {
+        const r = reg.hasCommand(commandName);
+        if (r instanceof Promise) throw new Error('Async not supported in sync translate.');
+        return r;
+      }
+      return false;
+    })();
+
+    if (!hasCommand) {
+      throw new CommandNotRegisteredError(commandName);
+    }
+
+    return HookTranslationResult.execute(commandName, ['--fast'], 0, 500);
+  }
+
+  private translateStop(_event: StopEvent): HookTranslationResult {
+    const isActive = (() => {
+      const r = this.reentryGuardStatePort.isActive();
+      if (r instanceof Promise) throw new Error('Async not supported in sync translate.');
+      return r;
+    })();
+
+    if (isActive) {
+      return HookTranslationResult.skip('REENTRY_DETECTED');
+    }
+
+    return HookTranslationResult.execute('harness:complete-check', [], 0);
+  }
+}
+
+/**
+ * 非同期版 HookToCliTranslator
+ * UseCase と Infrastructure で使用する本番実装
+ */
+export class AsyncHookToCliTranslator {
+  private readonly configQueryPort: ConfigQueryPort;
+  private readonly reentryGuard: ReentryGuard;
+  private readonly cliCommandRegistryPort: {
+    hasCommand(commandName: string): Promise<boolean>;
+  };
+  private readonly phaseGateQueryPort: {
+    checkGate(scope: WriteTargetScope): Promise<{
+      hasPassed(): boolean;
+      getBlockers(): readonly string[];
+      getWarnings(): readonly string[];
+    }>;
+  };
+
+  constructor(deps: {
+    configQueryPort: ConfigQueryPort;
+    reentryGuard: ReentryGuard;
+    cliCommandRegistryPort: { hasCommand(commandName: string): Promise<boolean> };
+    phaseGateQueryPort?: {
+      checkGate(scope: WriteTargetScope): Promise<{
+        hasPassed(): boolean;
+        getBlockers(): readonly string[];
+        getWarnings(): readonly string[];
+      }>;
+    };
+  }) {
+    this.configQueryPort = deps.configQueryPort;
+    this.reentryGuard = deps.reentryGuard;
+    this.cliCommandRegistryPort = deps.cliCommandRegistryPort;
+    this.phaseGateQueryPort = deps.phaseGateQueryPort ?? {
+      async checkGate() {
+        return {
+          hasPassed: () => true,
+          getBlockers: () => [],
+          getWarnings: () => [],
+        };
+      },
+    };
+  }
+
+  async translate(hookEvent: HookEvent): Promise<HookTranslationResult> {
+    if (hookEvent.isPreToolUse()) {
+      return this.translatePreToolUse(hookEvent as PreToolUseEvent);
+    }
+    if (hookEvent.isPostToolUse()) {
+      return this.translatePostToolUse(hookEvent as PostToolUseEvent);
+    }
+    if (hookEvent.isStop()) {
+      return this.translateStop(hookEvent as StopEvent);
+    }
+    throw new UnsupportedHookTypeError((hookEvent as HookEvent).hookType);
+  }
+
+  private static readonly WRITE_TOOLS: ReadonlySet<string> = new Set([
+    'Write', 'Edit', 'NotebookEdit', 'str_replace_editor',
+  ]);
+
+  private async translatePreToolUse(event: PreToolUseEvent): Promise<HookTranslationResult> {
+    // Step 1: Protected file check (applies to all tools)
+    const additionalPatterns = await this.configQueryPort.getProtectedFilePatterns();
+    const protectedFileList = ProtectedFileList.createWithAdditional(additionalPatterns);
+
+    const blockedPath = event.targetFilePaths.find((fp) => protectedFileList.matches(fp));
+    if (blockedPath !== undefined) {
+      return HookTranslationResult.block({
+        reason: 'PROTECTED_FILE',
+        blockedFilePath: blockedPath,
+      });
+    }
+
+    // Step 2: Phase gate check (applies only to write tools)
+    if (!AsyncHookToCliTranslator.WRITE_TOOLS.has(event.toolName)) {
+      return HookTranslationResult.create({
+        shouldBlock: false,
+        cliArgs: [],
+        expectedExitCode: 0,
+      });
+    }
+
+    const projectPaths = await (this.configQueryPort as ConfigQueryPort & {
+      getProjectPaths(): unknown;
+    }).getProjectPaths();
+    const detectedScope = event.targetFilePaths
+      .map((filePath) => WriteTargetScope.fromPath(filePath, projectPaths as Parameters<typeof WriteTargetScope.fromPath>[1]))
+      .find((scope): scope is WriteTargetScope => scope !== null);
+
+    if (detectedScope === undefined) {
+      return HookTranslationResult.create({
+        shouldBlock: false,
+        cliArgs: [],
+        expectedExitCode: 0,
+      });
+    }
+
+    const phaseGateResult = await this.phaseGateQueryPort.checkGate(detectedScope);
+    if (!phaseGateResult.hasPassed()) {
+      return HookTranslationResult.block({
+        reason: 'PHASE_GATE',
+        phaseGateBlockers: [...phaseGateResult.getBlockers()],
+        phaseGateWarnings: [...phaseGateResult.getWarnings()],
+        scopeLevel: detectedScope.level,
+        unitId: detectedScope.unitId,
+        storyId: detectedScope.storyId,
+      });
+    }
+
+    return HookTranslationResult.create({
+      shouldBlock: false,
+      cliArgs: [],
+      expectedExitCode: 0,
+    });
+  }
+
+  private async translatePostToolUse(_event: PostToolUseEvent): Promise<HookTranslationResult> {
+    const isEnabled = await this.configQueryPort.isHookEnabled('post-tool-use');
+    if (!isEnabled) {
+      return HookTranslationResult.skip('HOOK_DISABLED');
+    }
+
+    const commandName = 'harness:lint';
+    const hasCommand = await this.cliCommandRegistryPort.hasCommand(commandName);
+    if (!hasCommand) {
+      throw new CommandNotRegisteredError(commandName);
+    }
+
+    return HookTranslationResult.execute(commandName, ['--fast'], 0, 500);
+  }
+
+  private async translateStop(_event: StopEvent): Promise<HookTranslationResult> {
+    const isActive = this.reentryGuard.isActive();
+    if (isActive) {
+      return HookTranslationResult.skip('REENTRY_DETECTED');
+    }
+    return HookTranslationResult.execute('harness:complete-check', [], 0);
+  }
+}

package/scripts/harness/agent-integration/domain/types/phase-gate-level.ts

@@ -0,0 +1,4 @@
+// @unit agent-integration
+// @layer domain
+
+export type PhaseGateLevel = 1 | 2 | 3;

package/scripts/harness/agent-integration/domain/value-objects/fallback-capability-spec.ts

@@ -0,0 +1,53 @@
+/**
+ * @layer domain
+ * @unit agent-integration
+ *
+ * FallbackCapabilitySpec 値オブジェクト
+ * CLI/FSフォールバック能力の宣言と検証仕様
+ */
+
+export class FallbackCapabilityViolationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FallbackCapabilityViolationError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export interface FallbackCapabilitySpecInput {
+  supportedCommands: string[];
+  noAgentApiImports: boolean;
+}
+
+export class FallbackCapabilitySpec {
+  readonly supportedCommands: readonly string[];
+  readonly noAgentApiImports: boolean;
+
+  private constructor(supportedCommands: string[], noAgentApiImports: boolean) {
+    this.supportedCommands = Object.freeze([...supportedCommands]);
+    this.noAgentApiImports = noAgentApiImports;
+  }
+
+  static create(input: FallbackCapabilitySpecInput): FallbackCapabilitySpec {
+    if (input.supportedCommands.length === 0) {
+      throw new FallbackCapabilityViolationError(
+        'supportedCommandsは1件以上必要です（INV-5違反）'
+      );
+    }
+    return new FallbackCapabilitySpec(input.supportedCommands, input.noAgentApiImports);
+  }
+
+  includesCommand(command: string): boolean {
+    return this.supportedCommands.includes(command);
+  }
+
+  requiresNoAgentApiImports(): boolean {
+    return this.noAgentApiImports;
+  }
+
+  equals(other: FallbackCapabilitySpec): boolean {
+    if (this.noAgentApiImports !== other.noAgentApiImports) return false;
+    if (this.supportedCommands.length !== other.supportedCommands.length) return false;
+    return this.supportedCommands.every((c, i) => c === other.supportedCommands[i]);
+  }
+}

package/scripts/harness/agent-integration/domain/value-objects/hook-event.ts

@@ -0,0 +1,134 @@
+/**
+ * @layer domain
+ * @unit agent-integration
+ *
+ * HookEvent Union型値オブジェクト
+ */
+
+export class UnsupportedHookTypeError extends Error {
+  constructor(hookType: string) {
+    super(`未サポートのhookTypeです: ${hookType}`);
+    this.name = 'UnsupportedHookTypeError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+type HookEventInput =
+  | { hookType: 'pre-tool-use'; toolName: string; targetFilePaths: string[] }
+  | { hookType: 'post-tool-use'; toolName: string; affectedFilePaths: string[] }
+  | { hookType: 'stop'; sessionId: string };
+
+export abstract class HookEvent {
+  abstract readonly hookType: string;
+
+  abstract equals(other: HookEvent): boolean;
+
+  isPreToolUse(): this is PreToolUseEvent {
+    return this.hookType === 'pre-tool-use';
+  }
+
+  isPostToolUse(): this is PostToolUseEvent {
+    return this.hookType === 'post-tool-use';
+  }
+
+  isStop(): this is StopEvent {
+    return this.hookType === 'stop';
+  }
+
+  static create(input: HookEventInput | Record<string, unknown>): HookEvent {
+    const hookType = (input as Record<string, unknown>).hookType;
+    if (hookType === 'pre-tool-use') {
+      const i = input as { hookType: 'pre-tool-use'; toolName: string; targetFilePaths: string[] };
+      return PreToolUseEvent.create(i);
+    }
+    if (hookType === 'post-tool-use') {
+      const i = input as { hookType: 'post-tool-use'; toolName: string; affectedFilePaths: string[] };
+      return PostToolUseEvent.create(i);
+    }
+    if (hookType === 'stop') {
+      const i = input as { hookType: 'stop'; sessionId: string };
+      return StopEvent.create(i);
+    }
+    throw new UnsupportedHookTypeError(String(hookType));
+  }
+
+  static createPreToolUse(toolName: string, targetFilePaths: string[]): HookEvent {
+    return PreToolUseEvent.create({ hookType: 'pre-tool-use', toolName, targetFilePaths });
+  }
+
+  static createPostToolUse(toolName: string, affectedFilePaths: string[]): HookEvent {
+    return PostToolUseEvent.create({ hookType: 'post-tool-use', toolName, affectedFilePaths });
+  }
+
+  static createStop(sessionId: string): HookEvent {
+    return StopEvent.create({ hookType: 'stop', sessionId });
+  }
+}
+
+export class PreToolUseEvent extends HookEvent {
+  readonly hookType = 'pre-tool-use' as const;
+  readonly toolName: string;
+  readonly targetFilePaths: readonly string[];
+
+  private constructor(toolName: string, targetFilePaths: string[]) {
+    super();
+    this.toolName = toolName;
+    this.targetFilePaths = Object.freeze([...targetFilePaths]);
+  }
+
+  static create(input: { hookType: 'pre-tool-use'; toolName: string; targetFilePaths: string[] }): PreToolUseEvent {
+    return new PreToolUseEvent(input.toolName, input.targetFilePaths);
+  }
+
+  equals(other: HookEvent): boolean {
+    if (!(other instanceof PreToolUseEvent)) return false;
+    if (this.toolName !== other.toolName) return false;
+    if (this.targetFilePaths.length !== other.targetFilePaths.length) return false;
+    return this.targetFilePaths.every((p, i) => p === other.targetFilePaths[i]);
+  }
+}
+
+export class PostToolUseEvent extends HookEvent {
+  readonly hookType = 'post-tool-use' as const;
+  readonly toolName: string;
+  readonly affectedFilePaths: readonly string[];
+
+  private constructor(toolName: string, affectedFilePaths: string[]) {
+    super();
+    this.toolName = toolName;
+    this.affectedFilePaths = Object.freeze([...affectedFilePaths]);
+  }
+
+  static create(input: { hookType: 'post-tool-use'; toolName: string; affectedFilePaths: string[] }): PostToolUseEvent {
+    return new PostToolUseEvent(input.toolName, input.affectedFilePaths);
+  }
+
+  equals(other: HookEvent): boolean {
+    if (!(other instanceof PostToolUseEvent)) return false;
+    if (this.toolName !== other.toolName) return false;
+    if (this.affectedFilePaths.length !== other.affectedFilePaths.length) return false;
+    return this.affectedFilePaths.every((p, i) => p === other.affectedFilePaths[i]);
+  }
+}
+
+export class StopEvent extends HookEvent {
+  readonly hookType = 'stop' as const;
+  readonly sessionId: string;
+
+  private constructor(sessionId: string) {
+    super();
+    if (!sessionId) {
+      throw new Error('sessionIdは空文字不可');
+    }
+    this.sessionId = sessionId;
+  }
+
+  static create(input: { hookType: 'stop'; sessionId: string }): StopEvent {
+    return new StopEvent(input.sessionId);
+  }
+
+  equals(other: HookEvent): boolean {
+    if (!(other instanceof StopEvent)) return false;
+    return this.sessionId === other.sessionId;
+  }
+}

package/scripts/harness/agent-integration/domain/value-objects/hook-translation-result.ts

@@ -0,0 +1,128 @@
+/**
+ * @layer domain
+ * @unit agent-integration
+ *
+ * HookTranslationResult 値オブジェクト
+ * HookEvent → CLI実行指示への変換結果
+ */
+
+export type SkipReason = 'REENTRY_DETECTED' | 'HOOK_DISABLED' | 'TIMEOUT_EXCEEDED';
+
+export type BlockReason = 'PROTECTED_FILE' | 'PHASE_GATE';
+
+export interface BlockMetadata {
+  readonly reason: BlockReason;
+  readonly blockedFilePath?: string;
+  readonly phaseGateBlockers?: readonly string[];
+  readonly phaseGateWarnings?: readonly string[];
+  readonly scopeLevel?: 1 | 2 | 3;
+  readonly unitId?: string;
+  readonly storyId?: string;
+}
+
+export class HookTranslationResultInvariantError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'HookTranslationResultInvariantError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export interface HookTranslationResultProps {
+  shouldBlock: boolean;
+  cliCommand?: string;
+  cliArgs: string[];
+  expectedExitCode: number;
+  skipReason?: SkipReason;
+  timeoutMs?: number;
+  blockMetadata?: BlockMetadata;
+}
+
+export class HookTranslationResult {
+  readonly shouldBlock: boolean;
+  readonly cliCommand: string | undefined;
+  readonly cliArgs: readonly string[];
+  readonly expectedExitCode: number;
+  readonly skipReason: SkipReason | undefined;
+  readonly timeoutMs: number | undefined;
+  readonly blockMetadata: BlockMetadata | undefined;
+
+  private constructor(props: HookTranslationResultProps) {
+    this.shouldBlock = props.shouldBlock;
+    this.cliCommand = props.cliCommand;
+    this.cliArgs = Object.freeze([...props.cliArgs]);
+    this.expectedExitCode = props.expectedExitCode;
+    this.skipReason = props.skipReason;
+    this.timeoutMs = props.timeoutMs;
+    this.blockMetadata = props.blockMetadata;
+  }
+
+  static create(props: HookTranslationResultProps): HookTranslationResult {
+    // INV-2: shouldBlock=trueのときcliCommandは設定不可
+    if (props.shouldBlock && props.cliCommand !== undefined) {
+      throw new HookTranslationResultInvariantError(
+        'shouldBlock=trueのときcliCommandは設定不可です（INV-2違反）'
+      );
+    }
+    // INV-3: skipReasonがあるときcliCommandは設定不可
+    if (props.skipReason !== undefined && props.cliCommand !== undefined) {
+      throw new HookTranslationResultInvariantError(
+        'skipReasonがある場合cliCommandは設定不可です（INV-3違反）'
+      );
+    }
+    return new HookTranslationResult(props);
+  }
+
+  static block(metadata?: BlockMetadata): HookTranslationResult {
+    return new HookTranslationResult({
+      shouldBlock: true,
+      cliArgs: [],
+      expectedExitCode: 2,
+      blockMetadata: metadata,
+    });
+  }
+
+  static skip(reason: SkipReason): HookTranslationResult {
+    return new HookTranslationResult({
+      shouldBlock: false,
+      skipReason: reason,
+      cliArgs: [],
+      expectedExitCode: 0,
+    });
+  }
+
+  static execute(
+    cliCommand: string,
+    cliArgs: string[],
+    expectedExitCode: number,
+    timeoutMs?: number
+  ): HookTranslationResult {
+    return new HookTranslationResult({
+      shouldBlock: false,
+      cliCommand,
+      cliArgs,
+      expectedExitCode,
+      timeoutMs,
+    });
+  }
+
+  hasCliCommand(): boolean {
+    return this.cliCommand !== undefined;
+  }
+
+  shouldSkip(): boolean {
+    return this.skipReason !== undefined;
+  }
+
+  equals(other: HookTranslationResult): boolean {
+    if (this.shouldBlock !== other.shouldBlock) return false;
+    if (this.cliCommand !== other.cliCommand) return false;
+    if (this.cliArgs.length !== other.cliArgs.length) return false;
+    if (!this.cliArgs.every((a, i) => a === other.cliArgs[i])) return false;
+    if (this.expectedExitCode !== other.expectedExitCode) return false;
+    if (this.skipReason !== other.skipReason) return false;
+    if (this.timeoutMs !== other.timeoutMs) return false;
+    if (this.blockMetadata?.reason !== other.blockMetadata?.reason) return false;
+    return true;
+  }
+}

package/scripts/harness/agent-integration/domain/value-objects/phase-gate-query-result.ts

@@ -0,0 +1,67 @@
+// @unit agent-integration
+// @layer domain
+
+export class PhaseGateQueryResultInvariantError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PhaseGateQueryResultInvariantError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class PhaseGateQueryResult {
+  readonly passed: boolean;
+  readonly blockers: readonly string[];
+  readonly warnings: readonly string[];
+
+  private constructor(passed: boolean, blockers: readonly string[], warnings: readonly string[]) {
+    this.passed = passed;
+    this.blockers = Object.freeze([...blockers]);
+    this.warnings = Object.freeze([...warnings]);
+  }
+
+  static create(
+    passed: boolean,
+    blockers: string[],
+    warnings: string[]
+  ): PhaseGateQueryResult {
+    if (!passed && blockers.length === 0) {
+      throw new PhaseGateQueryResultInvariantError(
+        'passed=falseの場合、blockersは1件以上必要です'
+      );
+    }
+
+    return new PhaseGateQueryResult(passed, blockers, warnings);
+  }
+
+  hasPassed(): boolean {
+    return this.passed;
+  }
+
+  getBlockers(): readonly string[] {
+    return this.blockers;
+  }
+
+  getWarnings(): readonly string[] {
+    return this.warnings;
+  }
+
+  equals(other: PhaseGateQueryResult): boolean {
+    if (this.passed !== other.passed) {
+      return false;
+    }
+
+    if (this.blockers.length !== other.blockers.length) {
+      return false;
+    }
+
+    if (this.warnings.length !== other.warnings.length) {
+      return false;
+    }
+
+    return (
+      this.blockers.every((blocker, index) => blocker === other.blockers[index]) &&
+      this.warnings.every((warning, index) => warning === other.warnings[index])
+    );
+  }
+}