phasegate 0.16.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.16.0",
+  "version": "0.31.0",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "Apache-2.0",
@@ -49,14 +49,16 @@
     "phasegate:disable": "npx tsx scripts/harness/main.ts disable-feature",
     "phasegate:check-phase": "npx tsx scripts/harness/main.ts harness:check-phase",
     "phasegate:check-ready": "npx tsx scripts/harness/main.ts harness:check-ready",
-    "test": "vitest run --config scripts/harness/__tests__/vitest.config.ts"
+    "test": "vitest run --config scripts/harness/__tests__/vitest.config.forks.ts && vitest run --config scripts/harness/__tests__/vitest.config.ts"
   },
   "dependencies": {
     "ajv": "^8.18.0",
+    "picomatch": "^4.0.4",
     "tsx": "^4.0.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.7",
+    "@types/picomatch": "^4.0.0",
     "@types/node": "^25.3.5",
     "typescript": "^5.0.0",
     "vitest": "^3.0.0"

package/scripts/harness/adr-foundation/domain/ports/adr-document-parser-port.ts

@@ -1,3 +1,4 @@
+// @layer domain
 import type { ADR } from '../aggregates/adr.js';
 import type { AdrBody } from '../value-objects/adr-body.js';
 import type { AdrFrontmatter } from '../value-objects/adr-frontmatter.js';

package/scripts/harness/adr-foundation/domain/ports/adr-frontmatter-parser-port.ts

@@ -1,3 +1,4 @@
+// @layer domain
 import type { AdrFrontmatter } from '../value-objects/adr-frontmatter.js';
 
 export interface AdrFrontmatterParserPort {

package/scripts/harness/adr-foundation/domain/ports/adr-repository-port.ts

@@ -1,3 +1,4 @@
+// @layer domain
 import type { ADR } from '../aggregates/adr.js';
 import type { AdrId } from '../value-objects/adr-id.js';
 import type { AdrStatus } from '../value-objects/adr-status.js';

package/scripts/harness/adr-foundation/domain/value-objects/adr-status.ts

@@ -5,11 +5,11 @@
 const ALLOWED_STATUSES = ['Proposed', 'Accepted', 'Deprecated', 'Superseded'] as const;
 type AdrStatusValue = (typeof ALLOWED_STATUSES)[number];
 
-const TRANSITIONS: Readonly<Record<AdrStatusValue, readonly AdrStatusValue[]>> = Object.freeze({
-  Proposed: Object.freeze(['Accepted', 'Deprecated']),
-  Accepted: Object.freeze(['Deprecated', 'Superseded']),
-  Deprecated: Object.freeze(['Proposed']),
-  Superseded: Object.freeze([]),
+const TRANSITIONS = Object.freeze({
+  Proposed: Object.freeze(['Accepted', 'Deprecated'] as const),
+  Accepted: Object.freeze(['Deprecated', 'Superseded'] as const),
+  Deprecated: Object.freeze(['Proposed'] as const),
+  Superseded: Object.freeze([] as const),
 });
 
 export class InvalidAdrStatusError extends Error {
@@ -52,7 +52,7 @@ export class AdrStatus {
   }
 
   canTransitionTo(target: AdrStatus): boolean {
-    return TRANSITIONS[this.value].includes(target.value);
+    return (TRANSITIONS[this.value] as readonly string[]).includes(target.value);
   }
 
   equals(other: AdrStatus): boolean {

package/scripts/harness/agent-integration/application/dto/handle-pre-tool-use-dto.ts

@@ -11,8 +11,10 @@ export interface HandlePreToolUseInput {
 export interface HandlePreToolUseOutput {
   shouldBlock: boolean;
   blockedFilePath?: string;
-  blockReason?: 'PROTECTED_FILE' | 'PHASE_GATE';
+  blockReason?: 'PROTECTED_FILE' | 'PHASE_GATE' | 'STORY_REFLECTION';
   error?: { message: string };
   phaseGateBlockers?: string[];
+  storyReflectionBlockers?: string[];
+  storyReflectionWarnings?: string[];
   nextAction?: string;
 }

package/scripts/harness/agent-integration/application/usecases/handle-pre-tool-use-usecase.ts

@@ -9,15 +9,17 @@
 
 import { AsyncHookToCliTranslator } from '../../domain/services/hook-to-cli-translator.js';
 import { HookEvent } from '../../domain/value-objects/hook-event.js';
-import { ProtectedFileList } from '../../domain/value-objects/protected-file-list.js';
 import type { BlockMetadata } from '../../domain/value-objects/hook-translation-result.js';
 import type { ConfigQueryPort } from '../../domain/ports/config-query-port.js';
 import type { PhaseGateQueryPort } from '../../domain/ports/phase-gate-query-port.js';
+import type { StoryReflectionQueryPort } from '../../domain/ports/story-reflection-query-port.js';
+import { WriteTargetScope } from '../../domain/value-objects/write-target-scope.js';
 import type { HandlePreToolUseInput, HandlePreToolUseOutput } from '../dto/handle-pre-tool-use-dto.js';
 
 export interface HandlePreToolUseUseCasePorts {
   configQueryPort: ConfigQueryPort;
   phaseGateQueryPort: PhaseGateQueryPort;
+  storyReflectionQueryPort?: StoryReflectionQueryPort;
 }
 
 export class HandlePreToolUseInputValidationError extends Error {
@@ -29,11 +31,17 @@ export class HandlePreToolUseInputValidationError extends Error {
 }
 
 export class HandlePreToolUseUseCase {
+  private static readonly WRITE_TOOLS: ReadonlySet<string> = new Set([
+    'Write', 'Edit', 'NotebookEdit', 'str_replace_editor',
+  ]);
+
   private readonly translator: AsyncHookToCliTranslator;
   private readonly configQueryPort: ConfigQueryPort;
+  private readonly storyReflectionQueryPort?: StoryReflectionQueryPort;
 
   constructor(ports: HandlePreToolUseUseCasePorts) {
     this.configQueryPort = ports.configQueryPort;
+    this.storyReflectionQueryPort = ports.storyReflectionQueryPort;
     this.translator = new AsyncHookToCliTranslator({
       configQueryPort: ports.configQueryPort,
       reentryGuard: { isActive: () => false } as never,
@@ -71,7 +79,39 @@ export class HandlePreToolUseUseCase {
       };
     }
 
-    return { shouldBlock: false };
+    const scope = this.resolveStoryReflectionScope(input);
+    if (scope === null || this.storyReflectionQueryPort === undefined) {
+      return { shouldBlock: false };
+    }
+
+    const reflectionResult = await this.storyReflectionQueryPort.checkReflection(scope.unitId!);
+
+    if (reflectionResult.skipped || reflectionResult.passed) {
+      return { shouldBlock: false };
+    }
+
+    return HandlePreToolUseUseCase.buildStoryReflectionBlockOutput(
+      input.targetFilePaths[0],
+      reflectionResult.blockers,
+      reflectionResult.warnings,
+    );
+  }
+
+  private resolveStoryReflectionScope(input: HandlePreToolUseInput): WriteTargetScope | null {
+    if (!HandlePreToolUseUseCase.WRITE_TOOLS.has(input.toolName)) {
+      return null;
+    }
+
+    const projectPaths = this.configQueryPort.getProjectPaths();
+
+    for (const targetFilePath of input.targetFilePaths) {
+      const scope = WriteTargetScope.fromPath(targetFilePath, projectPaths);
+      if (scope?.level === 3 && scope.unitId !== undefined) {
+        return scope;
+      }
+    }
+
+    return null;
   }
 
   private static readonly LEVEL_LABELS: Record<number, string> = {
@@ -161,4 +201,70 @@ export class HandlePreToolUseUseCase {
       error: { message },
     };
   }
+
+  private static buildStoryReflectionBlockOutput(
+    blockedFilePath: string | undefined,
+    blockers: readonly string[],
+    warnings: readonly string[],
+  ): HandlePreToolUseOutput {
+    return {
+      shouldBlock: true,
+      blockedFilePath,
+      blockReason: 'STORY_REFLECTION',
+      error: {
+        message: HandlePreToolUseUseCase.buildStoryReflectionErrorMessage(blockers),
+      },
+      storyReflectionBlockers: [...blockers],
+      storyReflectionWarnings: [...warnings],
+    };
+  }
+
+  private static buildStoryReflectionErrorMessage(blockers: readonly string[]): string {
+    const firstBlocker = blockers[0];
+    const details = firstBlocker === undefined
+      ? null
+      : HandlePreToolUseUseCase.extractStoryReflectionDetails(firstBlocker);
+    const lines: string[] = [];
+
+    if (details !== null) {
+      lines.push(`[L2-STORY-REFLECTION] ${details.productPath} に`);
+      lines.push(`@story-id ${details.storyId} が反映されていません。`);
+      lines.push('');
+    } else {
+      lines.push('[L2-STORY-REFLECTION] product 文書に @story-id が反映されていません。');
+      lines.push('');
+    }
+
+    for (const blocker of blockers) {
+      lines.push(`- ${blocker}`);
+    }
+
+    lines.push('');
+    lines.push('修正方法:');
+    lines.push('  1. cascade-updater を実行して product 文書を更新');
+    lines.push(
+      `  2. または手動で該当 product 文書に @story-id ${details?.storyId ?? '<STORY-ID>'} を追加`,
+    );
+    lines.push('');
+    lines.push('参照: ADR-XXX');
+
+    return lines.join('\n');
+  }
+
+  private static extractStoryReflectionDetails(
+    blocker: string,
+  ): { productPath: string; storyId: string } | null {
+    const productPathMatch = blocker.match(/docs\/product\/construction\/[^\s]+\.md/);
+    const storyIdMatch = blocker.match(/@story-id\s+([A-Z][\w-]*-\d+)|\b([A-Z][\w-]*-\d+)\b/);
+    const storyId = storyIdMatch?.[1] ?? storyIdMatch?.[2];
+
+    if (productPathMatch === null || storyId === undefined) {
+      return null;
+    }
+
+    return {
+      productPath: productPathMatch[0],
+      storyId,
+    };
+  }
 }

package/scripts/harness/agent-integration/domain/ports/config-query-port.ts

@@ -8,5 +8,7 @@ export type HookType = 'pre-tool-use' | 'post-tool-use' | 'stop';
 export interface ConfigQueryPort {
   isHookEnabled(hookType: HookType): Promise<boolean>;
   getProtectedFilePatterns(): Promise<string[]>;
+  getProtectedFileExclusions(): Promise<string[]>;
+  getRelaxedGates(): Promise<readonly string[]>;
   getProjectPaths(): ProjectPaths;
 }

package/scripts/harness/agent-integration/domain/ports/phase-gate-query-port.ts

@@ -5,5 +5,5 @@ import type { WriteTargetScope } from '../value-objects/write-target-scope.js';
 import type { PhaseGateQueryResult } from '../value-objects/phase-gate-query-result.js';
 
 export interface PhaseGateQueryPort {
-  checkGate(scope: WriteTargetScope): Promise<PhaseGateQueryResult>;
+  checkGate(scope: WriteTargetScope, targetFilePath?: string): Promise<PhaseGateQueryResult>;
 }

package/scripts/harness/agent-integration/domain/ports/story-reflection-query-port.ts

@@ -0,0 +1,8 @@
+// @unit agent-integration
+// @layer domain
+
+import type { StoryReflectionQueryResult } from '../value-objects/story-reflection-query-result.js';
+
+export interface StoryReflectionQueryPort {
+  checkReflection(unitId: string): Promise<StoryReflectionQueryResult>;
+}

package/scripts/harness/agent-integration/domain/services/bash-write-target-extractor.ts

@@ -0,0 +1,258 @@
+/**
+ * @layer domain
+ * @unit agent-integration
+ *
+ * BashWriteTargetExtractor ドメインサービス
+ *
+ * Bash コマンド文字列を静的解析し、書き込み対象となるファイルパスを抽出する。
+ * Phase Gate フックが Bash 経由のファイル書き込みを検知して保護するための基盤。
+ *
+ * 副作用なし・純粋関数相当。対応パターンは以下:
+ *   - リダイレクト `>` / `>>`
+ *   - heredoc (`<<EOF > path`)
+ *   - `tee` / `tee -a`
+ *   - `sed -i` / `sed -i ''` (BSD)
+ *   - `cp` / `mv` (宛先のみ)
+ *   - `touch`
+ *   - 複合コマンド (`&&`, `;`, `||`) とパイプ (`|`) 分割
+ *   - ダブル/シングルクォート対応
+ */
+
+/** 引数トークン (値とクォート種別) */
+type Token = {
+  readonly value: string;
+  readonly quoted: 'none' | 'single' | 'double';
+};
+
+/** シェル風の簡易トークナイザ。クォート境界を尊重する。 */
+function tokenize(input: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+  const len = input.length;
+
+  while (i < len) {
+    const ch = input[i];
+
+    // 空白スキップ
+    if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+      i += 1;
+      continue;
+    }
+
+    // 演算子をそのままトークン化
+    if (ch === '>' || ch === '<' || ch === '|' || ch === ';' || ch === '&') {
+      let op = ch;
+      if (i + 1 < len && input[i + 1] === ch && (ch === '>' || ch === '<' || ch === '|' || ch === '&')) {
+        op = ch + ch;
+        i += 2;
+      } else {
+        i += 1;
+      }
+      tokens.push({ value: op, quoted: 'none' });
+      continue;
+    }
+
+    // ダブルクォート
+    if (ch === '"') {
+      let buf = '';
+      i += 1;
+      while (i < len && input[i] !== '"') {
+        if (input[i] === '\\' && i + 1 < len) {
+          buf += input[i + 1];
+          i += 2;
+        } else {
+          buf += input[i];
+          i += 1;
+        }
+      }
+      i += 1; // closing quote
+      tokens.push({ value: buf, quoted: 'double' });
+      continue;
+    }
+
+    // シングルクォート
+    if (ch === "'") {
+      let buf = '';
+      i += 1;
+      while (i < len && input[i] !== "'") {
+        buf += input[i];
+        i += 1;
+      }
+      i += 1; // closing quote
+      tokens.push({ value: buf, quoted: 'single' });
+      continue;
+    }
+
+    // 通常トークン
+    let buf = '';
+    while (i < len) {
+      const c = input[i];
+      if (c === ' ' || c === '\t' || c === '\n' || c === '\r') break;
+      if (c === '>' || c === '<' || c === '|' || c === ';' || c === '&') break;
+      if (c === '"' || c === "'") break;
+      buf += c;
+      i += 1;
+    }
+    if (buf.length > 0) {
+      tokens.push({ value: buf, quoted: 'none' });
+    }
+  }
+
+  return tokens;
+}
+
+const OPERATOR_SEPARATORS = new Set(['&&', '||', ';', '|']);
+
+/** トークン列を複合・パイプ境界で分割 */
+function splitByOperators(tokens: Token[]): Token[][] {
+  const groups: Token[][] = [];
+  let current: Token[] = [];
+  for (const t of tokens) {
+    if (t.quoted === 'none' && OPERATOR_SEPARATORS.has(t.value)) {
+      if (current.length > 0) {
+        groups.push(current);
+        current = [];
+      }
+      continue;
+    }
+    current.push(t);
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+
+/** コマンドグループ先頭の環境変数代入 (`FOO=bar`) をスキップして実コマンドを返す */
+function getCommandName(tokens: Token[]): string | undefined {
+  for (const t of tokens) {
+    if (t.quoted === 'none' && /^[A-Za-z_][A-Za-z0-9_]*=/.test(t.value)) continue;
+    return t.value;
+  }
+  return undefined;
+}
+
+/**
+ * 1 コマンド分のトークン列から書き込み先を抽出する。
+ * リダイレクト先はコマンド種別によらず検出する (全コマンド共通)。
+ */
+function extractFromSingleCommand(tokens: Token[]): string[] {
+  const results: string[] = [];
+
+  // 1) リダイレクト `>` / `>>` の右辺 (heredoc の `>` もこのパスで拾える)
+  for (let i = 0; i < tokens.length; i += 1) {
+    const t = tokens[i];
+    if (t.quoted === 'none' && (t.value === '>' || t.value === '>>')) {
+      const next = tokens[i + 1];
+      if (next !== undefined) {
+        results.push(next.value);
+      }
+    }
+  }
+
+  const cmd = getCommandName(tokens);
+  if (cmd === undefined) return results;
+
+  // コマンド別の特殊処理
+  const baseName = cmd.split('/').pop() ?? cmd;
+
+  if (baseName === 'tee') {
+    // `tee [-a] FILE...`
+    for (let i = 1; i < tokens.length; i += 1) {
+      const t = tokens[i];
+      if (t.quoted === 'none' && t.value.startsWith('-')) continue;
+      if (t.quoted === 'none' && (t.value === '>' || t.value === '>>' || t.value === '|' || t.value === '<')) break;
+      results.push(t.value);
+    }
+  } else if (baseName === 'sed') {
+    // `sed -i [''] SCRIPT FILE` — `-i` の直後の空文字列 (BSD) はバックアップ拡張子
+    const argTokens = tokens.slice(1);
+    let inPlace = false;
+    let skipBackupExt = false;
+    const positionals: Token[] = [];
+    for (let i = 0; i < argTokens.length; i += 1) {
+      const t = argTokens[i];
+      if (t.quoted === 'none' && t.value === '-i') {
+        inPlace = true;
+        skipBackupExt = true;
+        continue;
+      }
+      if (t.quoted === 'none' && t.value.startsWith('-i')) {
+        // -iBAK
+        inPlace = true;
+        continue;
+      }
+      if (t.quoted === 'none' && t.value.startsWith('-')) continue;
+      if (skipBackupExt && t.quoted !== 'none' && t.value === '') {
+        // BSD `sed -i ''` — 空文字はバックアップ拡張子扱いで無視
+        skipBackupExt = false;
+        continue;
+      }
+      skipBackupExt = false;
+      positionals.push(t);
+    }
+    if (inPlace && positionals.length >= 2) {
+      // 先頭はスクリプト、残りはファイル
+      for (let i = 1; i < positionals.length; i += 1) {
+        results.push(positionals[i].value);
+      }
+    }
+  } else if (baseName === 'cp' || baseName === 'mv') {
+    // 宛先は最後の非オプション引数
+    const positionals: Token[] = [];
+    for (let i = 1; i < tokens.length; i += 1) {
+      const t = tokens[i];
+      if (t.quoted === 'none' && t.value.startsWith('-')) continue;
+      if (t.quoted === 'none' && (t.value === '>' || t.value === '>>' || t.value === '|' || t.value === '<')) break;
+      positionals.push(t);
+    }
+    if (positionals.length >= 2) {
+      results.push(positionals[positionals.length - 1].value);
+    }
+  } else if (baseName === 'touch') {
+    for (let i = 1; i < tokens.length; i += 1) {
+      const t = tokens[i];
+      if (t.quoted === 'none' && t.value.startsWith('-')) continue;
+      if (t.quoted === 'none' && (t.value === '>' || t.value === '>>' || t.value === '|' || t.value === '<')) break;
+      results.push(t.value);
+    }
+  }
+
+  return results;
+}
+
+export class BashWriteTargetExtractor {
+  /**
+   * Bash コマンド文字列から書き込み先ファイルパスを抽出する。
+   * 副作用なし、純粋関数相当。
+   *
+   * @param command Bash コマンド文字列
+   * @returns 書き込み先ファイルパスの配列 (重複除去済み・入力順)
+   */
+  extract(command: string): readonly string[] {
+    if (typeof command !== 'string' || command.length === 0) {
+      return Object.freeze([]);
+    }
+
+    const tokens = tokenize(command);
+    const groups = splitByOperators(tokens);
+
+    const collected: string[] = [];
+    for (const group of groups) {
+      const found = extractFromSingleCommand(group);
+      for (const path of found) {
+        collected.push(path);
+      }
+    }
+
+    // 重複除去 (挿入順保持)
+    const seen = new Set<string>();
+    const unique: string[] = [];
+    for (const p of collected) {
+      if (p.length === 0) continue;
+      if (seen.has(p)) continue;
+      seen.add(p);
+      unique.push(p);
+    }
+
+    return Object.freeze(unique);
+  }
+}

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

@@ -169,7 +169,7 @@ export class AsyncHookToCliTranslator {
     hasCommand(commandName: string): Promise<boolean>;
   };
   private readonly phaseGateQueryPort: {
-    checkGate(scope: WriteTargetScope): Promise<{
+    checkGate(scope: WriteTargetScope, targetFilePath?: string): Promise<{
       hasPassed(): boolean;
       getBlockers(): readonly string[];
       getWarnings(): readonly string[];
@@ -181,7 +181,7 @@ export class AsyncHookToCliTranslator {
     reentryGuard: ReentryGuard;
     cliCommandRegistryPort: { hasCommand(commandName: string): Promise<boolean> };
     phaseGateQueryPort?: {
-      checkGate(scope: WriteTargetScope): Promise<{
+      checkGate(scope: WriteTargetScope, targetFilePath?: string): Promise<{
         hasPassed(): boolean;
         getBlockers(): readonly string[];
         getWarnings(): readonly string[];
@@ -222,7 +222,11 @@ export class AsyncHookToCliTranslator {
   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 exclusions = await this.configQueryPort.getProtectedFileExclusions();
+    const protectedFileList = ProtectedFileList.createWithAdditionalAndExclusions(
+      additionalPatterns,
+      exclusions,
+    );
 
     const blockedPath = event.targetFilePaths.find((fp) => protectedFileList.matches(fp));
     if (blockedPath !== undefined) {
@@ -256,7 +260,20 @@ export class AsyncHookToCliTranslator {
       });
     }
 
-    const phaseGateResult = await this.phaseGateQueryPort.checkGate(detectedScope);
+    // Step 3: Check if phase gate is relaxed via quickMode.relaxedGates
+    const relaxedGates = await this.configQueryPort.getRelaxedGates();
+    if (relaxedGates.includes('phase-gate')) {
+      return HookTranslationResult.create({
+        shouldBlock: false,
+        cliArgs: [],
+        expectedExitCode: 0,
+      });
+    }
+
+    const phaseGateResult = await this.phaseGateQueryPort.checkGate(
+      detectedScope,
+      event.targetFilePaths[0],
+    );
     if (!phaseGateResult.hasPassed()) {
       return HookTranslationResult.block({
         reason: 'PHASE_GATE',

package/scripts/harness/agent-integration/domain/value-objects/protected-file-list.ts

@@ -69,6 +69,26 @@ export class ProtectedFileList {
     return new ProtectedFileList(allPatterns);
   }
 
+  static createWithExclusions(exclusions: string[]): ProtectedFileList {
+    const filtered = DEFAULT_PATTERNS.filter((p) => !exclusions.includes(p));
+    if (filtered.length === 0) {
+      return new ProtectedFileList([...DEFAULT_PATTERNS]);
+    }
+    return new ProtectedFileList(filtered);
+  }
+
+  static createWithAdditionalAndExclusions(
+    additionalPatterns: string[],
+    exclusions: string[],
+  ): ProtectedFileList {
+    const base = DEFAULT_PATTERNS.filter((p) => !exclusions.includes(p));
+    const allPatterns = [...base, ...additionalPatterns];
+    if (allPatterns.length === 0) {
+      return new ProtectedFileList([...DEFAULT_PATTERNS]);
+    }
+    return new ProtectedFileList(allPatterns);
+  }
+
   matches(filePath: string): boolean {
     if (filePath === '') return false;
     return this.patterns.some((pattern) => {

package/scripts/harness/agent-integration/domain/value-objects/story-reflection-query-result.ts

@@ -0,0 +1,63 @@
+// @unit agent-integration
+// @layer domain
+
+export class StoryReflectionQueryResultInvariantError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'StoryReflectionQueryResultInvariantError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class StoryReflectionQueryResult {
+  readonly passed: boolean;
+  readonly blockers: readonly string[];
+  readonly warnings: readonly string[];
+  readonly skipped: boolean;
+
+  private constructor(
+    passed: boolean,
+    blockers: readonly string[],
+    warnings: readonly string[],
+    skipped: boolean,
+  ) {
+    this.passed = passed;
+    this.blockers = Object.freeze([...blockers]);
+    this.warnings = Object.freeze([...warnings]);
+    this.skipped = skipped;
+  }
+
+  static pass(): StoryReflectionQueryResult {
+    return new StoryReflectionQueryResult(true, [], [], false);
+  }
+
+  static skipped(warnings: string[] = []): StoryReflectionQueryResult {
+    return new StoryReflectionQueryResult(true, [], warnings, true);
+  }
+
+  static block(blockers: string[], warnings: string[]): StoryReflectionQueryResult {
+    if (blockers.length === 0) {
+      throw new StoryReflectionQueryResultInvariantError(
+        'passed=falseの場合、blockersは1件以上必要です',
+      );
+    }
+
+    return new StoryReflectionQueryResult(false, blockers, warnings, false);
+  }
+
+  hasPassed(): boolean {
+    return this.passed;
+  }
+
+  getBlockers(): readonly string[] {
+    return this.blockers;
+  }
+
+  getWarnings(): readonly string[] {
+    return this.warnings;
+  }
+
+  isSkipped(): boolean {
+    return this.skipped;
+  }
+}