phasegate 0.15.0

package/scripts/harness/phase-dependency-model/application/services/evidence-bundle-assembler.ts

@@ -0,0 +1,71 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { ArtifactExistenceCheckerPort } from '../../domain/ports/artifact-existence-checker-port.js';
+import type { PhaseConfigProviderPort } from '../../domain/ports/phase-config-provider-port.js';
+import type { PlanDocumentReaderPort } from '../../domain/ports/plan-document-reader-port.js';
+import { PhaseLevel } from '../../domain/values/phase-level.js';
+import type { PhaseNode } from '../../domain/values/phase-node.js';
+import type { PlanEvidence } from '../../domain/values/plan-evidence.js';
+import type { PlanningMode } from '../../domain/values/planning-mode.js';
+
+export interface EvidenceBundleAssemblerDeps {
+  readonly artifactExistenceChecker: ArtifactExistenceCheckerPort;
+  readonly planDocumentReader: PlanDocumentReaderPort;
+  readonly phaseConfigProvider: PhaseConfigProviderPort;
+}
+
+export interface EvidenceBundle {
+  readonly artifactStatuses: ReadonlyMap<string, boolean>;
+  readonly planEvidences: ReadonlyMap<string, PlanEvidence>;
+  readonly planningMode: PlanningMode;
+}
+
+export class EvidenceBundleAssembler {
+  private readonly artifactExistenceChecker: ArtifactExistenceCheckerPort;
+  private readonly planDocumentReader: PlanDocumentReaderPort;
+  private readonly phaseConfigProvider: PhaseConfigProviderPort;
+
+  constructor(deps: EvidenceBundleAssemblerDeps) {
+    this.artifactExistenceChecker = deps.artifactExistenceChecker;
+    this.planDocumentReader = deps.planDocumentReader;
+    this.phaseConfigProvider = deps.phaseConfigProvider;
+  }
+
+  async assembleForLevel(
+    _level: PhaseLevel,
+    nodes: readonly PhaseNode[],
+    scope: { unitId?: string; storyId?: string },
+  ): Promise<EvidenceBundle> {
+    const planningMode = await this.phaseConfigProvider.getPlanningMode(scope);
+    const artifacts = nodes.flatMap((node) => node.artifacts);
+    const resolvedStatuses = await this.artifactExistenceChecker.checkAll(artifacts, scope);
+    const artifactStatuses = new Map<string, boolean>();
+
+    for (const artifact of artifacts) {
+      try {
+        artifactStatuses.set(artifact.path, resolvedStatuses.get(artifact.resolve(scope)) ?? false);
+      } catch {
+        artifactStatuses.set(artifact.path, false);
+      }
+    }
+
+    const planEvidences = new Map<string, PlanEvidence>();
+    for (const node of nodes) {
+      if (node.planArtifacts().length === 0) {
+        continue;
+      }
+
+      const actual = await this.planDocumentReader.readEvidence(node, scope, planningMode);
+      planEvidences.set(node.nodeKey(), actual);
+    }
+
+    return {
+      artifactStatuses,
+      planEvidences,
+      planningMode,
+    };
+  }
+}

package/scripts/harness/phase-dependency-model/application/services/phase-gate-result-mapper.ts

@@ -0,0 +1,25 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseGateResultDto } from '../dto/phase-gate-result-dto.js';
+import type { PhaseGateResult } from '../../domain/values/phase-gate-result.js';
+
+export class PhaseGateResultMapper {
+  map(
+    result: PhaseGateResult,
+    context: {
+      readonly targetLevel: 1 | 2 | 3;
+      readonly auditRecorded: boolean;
+    },
+  ): PhaseGateResultDto {
+    return Object.freeze({
+      passed: result.passed,
+      targetLevel: context.targetLevel,
+      blockers: Object.freeze([...result.blockers]),
+      warnings: Object.freeze([...result.warnings]),
+      auditRecorded: context.auditRecorded,
+    });
+  }
+}

package/scripts/harness/phase-dependency-model/application/services/phase-info-resolver.ts

@@ -0,0 +1,156 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseInfoDto } from '../dto/phase-info-dto.js';
+import type { PhaseDependency } from '../../domain/values/phase-dependency.js';
+import type { PhaseNode } from '../../domain/values/phase-node.js';
+import type { PlanEvidence } from '../../domain/values/plan-evidence.js';
+
+export interface ResolvedPhaseInfo
+  extends Omit<PhaseInfoDto, 'unitId' | 'storyId'> {}
+
+const unique = (values: readonly string[]): readonly string[] =>
+  Object.freeze([...new Set(values)]);
+
+const collectIncomingDependencies = (
+  dependencies: readonly PhaseDependency[],
+): ReadonlyMap<string, readonly PhaseDependency[]> => {
+  const actual = new Map<string, PhaseDependency[]>();
+
+  for (const dependency of dependencies) {
+    const existing = actual.get(dependency.to.nodeKey()) ?? [];
+    existing.push(dependency);
+    actual.set(dependency.to.nodeKey(), existing);
+  }
+
+  return new Map(
+    [...actual.entries()].map(([nodeKey, nodeDependencies]) => [
+      nodeKey,
+      Object.freeze([...nodeDependencies]),
+    ]),
+  );
+};
+
+export class PhaseInfoResolver {
+  resolve(
+    graph: {
+      readonly nodes: readonly PhaseNode[];
+      readonly dependencies: readonly PhaseDependency[];
+    },
+    artifactStatuses: ReadonlyMap<string, boolean>,
+    planEvidences: ReadonlyMap<string, PlanEvidence>,
+  ): ResolvedPhaseInfo {
+    const incomingDependencies = collectIncomingDependencies(graph.dependencies);
+    const completedNodeKeys = new Set<string>();
+    let progressed = true;
+
+    while (progressed) {
+      progressed = false;
+
+      for (const node of graph.nodes) {
+        if (completedNodeKeys.has(node.nodeKey())) {
+          continue;
+        }
+
+        const requiresDependencies = (incomingDependencies.get(node.nodeKey()) ?? []).filter(
+          (dependency) => dependency.type === 'requires',
+        );
+        const dependenciesSatisfied = requiresDependencies.every((dependency) =>
+          completedNodeKeys.has(dependency.from.nodeKey()),
+        );
+
+        if (!dependenciesSatisfied) {
+          continue;
+        }
+
+        const artifactsSatisfied = node
+          .requiredArtifacts()
+          .every((artifact) => artifactStatuses.get(artifact.path) === true);
+        const planSatisfied =
+          node.planArtifacts().length === 0 ||
+          (() => {
+            const actual = planEvidences.get(node.nodeKey());
+            return actual?.exists === true && actual.qaComplete && actual.planningModeMatch;
+          })();
+
+        if (artifactsSatisfied && planSatisfied) {
+          completedNodeKeys.add(node.nodeKey());
+          progressed = true;
+        }
+      }
+    }
+
+    const completedNodes = graph.nodes
+      .map((node) => node.nodeKey())
+      .filter((nodeKey) => completedNodeKeys.has(nodeKey));
+    const nextNodes = graph.nodes
+      .filter((node) => !completedNodeKeys.has(node.nodeKey()))
+      .filter((node) =>
+        (incomingDependencies.get(node.nodeKey()) ?? [])
+          .filter((dependency) => dependency.type === 'requires')
+          .every((dependency) => completedNodeKeys.has(dependency.from.nodeKey())),
+      )
+      .map((node) => node.nodeKey());
+    const blockers: string[] = [];
+
+    for (const node of graph.nodes) {
+      if (completedNodeKeys.has(node.nodeKey())) {
+        continue;
+      }
+
+      for (const dependency of (incomingDependencies.get(node.nodeKey()) ?? []).filter(
+        (entry) => entry.type === 'requires' && !completedNodeKeys.has(entry.from.nodeKey()),
+      )) {
+        blockers.push(`依存未充足です: ${dependency.from.nodeKey()} -> ${dependency.to.nodeKey()}`);
+      }
+
+      for (const artifact of node.requiredArtifacts()) {
+        if (artifactStatuses.get(artifact.path) !== true) {
+          blockers.push(`成果物が不足しています: ${artifact.path}`);
+        }
+      }
+
+      if (node.planArtifacts().length > 0) {
+        const actual = planEvidences.get(node.nodeKey());
+
+        if (!actual?.exists) {
+          blockers.push(`plan文書が不足しています: ${node.nodeKey()}`);
+          continue;
+        }
+        if (!actual.qaComplete) {
+          blockers.push(`QAが未完了です: ${node.nodeKey()}`);
+        }
+        if (!actual.planningModeMatch) {
+          blockers.push(`Planning Mode要件を満たしていません: ${node.nodeKey()}`);
+        }
+      }
+    }
+
+    const currentLevel = (() => {
+      if (nextNodes.length > 0) {
+        return graph.nodes
+          .filter((node) => nextNodes.includes(node.nodeKey()))
+          .reduce<1 | 2 | 3>((min, node) => (node.level.value < min ? node.level.value : min), 3);
+      }
+
+      const incompleteNodes = graph.nodes.filter((node) => !completedNodeKeys.has(node.nodeKey()));
+      if (incompleteNodes.length === 0) {
+        return 3;
+      }
+
+      return incompleteNodes.reduce<1 | 2 | 3>(
+        (min, node) => (node.level.value < min ? node.level.value : min),
+        3,
+      );
+    })();
+
+    return Object.freeze({
+      currentLevel,
+      completedNodes: Object.freeze([...completedNodes]),
+      nextNodes: unique(nextNodes),
+      blockers: unique(blockers),
+    });
+  }
+}

package/scripts/harness/phase-dependency-model/application/usecases/build-phase-dependency-graph-usecase.ts

@@ -0,0 +1,55 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseDependencyGraphDto } from '../dto/phase-dependency-graph-dto.js';
+import type { PhaseConfigProviderPort } from '../../domain/ports/phase-config-provider-port.js';
+import { PhaseStructure } from '../../domain/models/phase-structure.js';
+
+export interface BuildPhaseDependencyGraphInput {
+  readonly includeArtifacts?: boolean;
+}
+
+export interface BuildPhaseDependencyGraphUseCaseDeps {
+  readonly phaseConfigProvider: PhaseConfigProviderPort;
+}
+
+export class BuildPhaseDependencyGraphUseCase {
+  private readonly phaseConfigProvider: PhaseConfigProviderPort;
+
+  constructor(deps: BuildPhaseDependencyGraphUseCaseDeps) {
+    this.phaseConfigProvider = deps.phaseConfigProvider;
+  }
+
+  async execute(input: BuildPhaseDependencyGraphInput): Promise<PhaseDependencyGraphDto> {
+    const policy = await this.phaseConfigProvider.getCustomizationPolicy();
+    const graph = PhaseStructure.createDefault(policy).buildDependencyGraph();
+
+    return Object.freeze({
+      nodes: Object.freeze(
+        graph.nodes.map((node) =>
+          Object.freeze({
+            key: node.nodeKey(),
+            level: node.level.value,
+            skillName: node.skillName,
+            ...(input.includeArtifacts
+              ? {
+                  artifacts: Object.freeze(node.artifacts.map((artifact) => artifact.path)),
+                }
+              : {}),
+          }),
+        ),
+      ),
+      edges: Object.freeze(
+        graph.dependencies.map((dependency) =>
+          Object.freeze({
+            from: dependency.from.nodeKey(),
+            to: dependency.to.nodeKey(),
+            type: dependency.type,
+          }),
+        ),
+      ),
+    });
+  }
+}

package/scripts/harness/phase-dependency-model/application/usecases/check-phase-gate-usecase.ts

@@ -0,0 +1,80 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseGateResultDto } from '../dto/phase-gate-result-dto.js';
+import { EvidenceBundleAssembler } from '../services/evidence-bundle-assembler.js';
+import { PhaseGateResultMapper } from '../services/phase-gate-result-mapper.js';
+import { PhaseStructure } from '../../domain/models/phase-structure.js';
+import type { PhaseAuditLoggerPort } from '../../domain/ports/phase-audit-logger-port.js';
+import type { PhaseConfigProviderPort } from '../../domain/ports/phase-config-provider-port.js';
+import { PhaseLevel } from '../../domain/values/phase-level.js';
+
+export interface CheckPhaseGateInput {
+  readonly targetLevel: 1 | 2 | 3;
+  readonly unitId?: string;
+  readonly storyId?: string;
+}
+
+export interface CheckPhaseGateUseCaseDeps {
+  readonly phaseConfigProvider: PhaseConfigProviderPort;
+  readonly evidenceBundleAssembler: EvidenceBundleAssembler;
+  readonly auditLogger: PhaseAuditLoggerPort;
+}
+
+export class CheckPhaseGateUseCase {
+  private readonly phaseConfigProvider: PhaseConfigProviderPort;
+  private readonly evidenceBundleAssembler: EvidenceBundleAssembler;
+  private readonly auditLogger: PhaseAuditLoggerPort;
+  private readonly phaseGateResultMapper: PhaseGateResultMapper;
+
+  constructor(deps: CheckPhaseGateUseCaseDeps) {
+    this.phaseConfigProvider = deps.phaseConfigProvider;
+    this.evidenceBundleAssembler = deps.evidenceBundleAssembler;
+    this.auditLogger = deps.auditLogger;
+    this.phaseGateResultMapper = new PhaseGateResultMapper();
+  }
+
+  async execute(input: CheckPhaseGateInput): Promise<PhaseGateResultDto> {
+    const policy = await this.phaseConfigProvider.getCustomizationPolicy();
+    const phaseStructure = PhaseStructure.createDefault(policy);
+    const targetLevel = PhaseLevel.create(input.targetLevel);
+
+    phaseStructure.getPhaseNodes(targetLevel);
+
+    const scope = { unitId: input.unitId, storyId: input.storyId };
+    const evidenceNodes = [1, 2, 3]
+      .filter((value) => value < input.targetLevel)
+      .flatMap((value) => phaseStructure.getPhaseNodes(PhaseLevel.create(value)));
+
+    // ISSUE-001: storyId提供時はLevel 3ノードもevidence収集対象に含める
+    if (input.storyId) {
+      const level3Nodes = phaseStructure.getPhaseNodes(PhaseLevel.create(3));
+      evidenceNodes.push(...level3Nodes);
+    }
+
+    const evidenceBundle = await this.evidenceBundleAssembler.assembleForLevel(targetLevel, evidenceNodes, scope);
+    const result = phaseStructure.checkPhaseGate(targetLevel, evidenceBundle, scope);
+    let auditRecorded = false;
+
+    if (result.auditPayload) {
+      await this.auditLogger.record({
+        scope: {
+          unitId: input.unitId,
+          storyId: input.storyId,
+        },
+        targetLevel: input.targetLevel,
+        appliedRules: Object.freeze([...(result.auditPayload.appliedRules as readonly string[])]),
+        generatedAt: String(result.auditPayload.generatedAt),
+        requestedOverride: Boolean(result.auditPayload.requestedOverride),
+      });
+      auditRecorded = true;
+    }
+
+    return this.phaseGateResultMapper.map(result, {
+      targetLevel: input.targetLevel,
+      auditRecorded,
+    });
+  }
+}

package/scripts/harness/phase-dependency-model/application/usecases/get-phase-info-usecase.ts

@@ -0,0 +1,62 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseInfoDto } from '../dto/phase-info-dto.js';
+import { EvidenceBundleAssembler } from '../services/evidence-bundle-assembler.js';
+import type { PhaseInfoResolver } from '../services/phase-info-resolver.js';
+import { PhaseStructure } from '../../domain/models/phase-structure.js';
+import type { PhaseConfigProviderPort } from '../../domain/ports/phase-config-provider-port.js';
+import { PhaseLevel } from '../../domain/values/phase-level.js';
+
+export interface GetPhaseInfoInput {
+  readonly unitId: string;
+  readonly storyId?: string;
+}
+
+export interface GetPhaseInfoUseCaseDeps {
+  readonly phaseConfigProvider: PhaseConfigProviderPort;
+  readonly evidenceBundleAssembler: EvidenceBundleAssembler;
+  readonly phaseInfoResolver: PhaseInfoResolver;
+}
+
+export class GetPhaseInfoUseCase {
+  private readonly phaseConfigProvider: PhaseConfigProviderPort;
+  private readonly evidenceBundleAssembler: EvidenceBundleAssembler;
+  private readonly phaseInfoResolver: PhaseInfoResolver;
+
+  constructor(deps: GetPhaseInfoUseCaseDeps) {
+    this.phaseConfigProvider = deps.phaseConfigProvider;
+    this.evidenceBundleAssembler = deps.evidenceBundleAssembler;
+    this.phaseInfoResolver = deps.phaseInfoResolver;
+  }
+
+  async execute(input: GetPhaseInfoInput): Promise<PhaseInfoDto> {
+    const policy = await this.phaseConfigProvider.getCustomizationPolicy();
+    const phaseStructure = PhaseStructure.createDefault(policy);
+    const graph = phaseStructure.buildDependencyGraph();
+    const evidenceBundle = await this.evidenceBundleAssembler.assembleForLevel(
+      PhaseLevel.create(3),
+      graph.nodes,
+      {
+        unitId: input.unitId,
+        storyId: input.storyId,
+      },
+    );
+    const resolved = this.phaseInfoResolver.resolve(
+      graph,
+      evidenceBundle.artifactStatuses,
+      evidenceBundle.planEvidences,
+    );
+
+    return Object.freeze({
+      unitId: input.unitId,
+      ...(input.storyId !== undefined ? { storyId: input.storyId } : {}),
+      currentLevel: resolved.currentLevel,
+      completedNodes: Object.freeze([...resolved.completedNodes]),
+      nextNodes: Object.freeze([...resolved.nextNodes]),
+      blockers: Object.freeze([...resolved.blockers]),
+    });
+  }
+}

package/scripts/harness/phase-dependency-model/application/usecases/record-phase-override-audit-usecase.ts

@@ -0,0 +1,53 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseAuditLoggerPort } from '../../domain/ports/phase-audit-logger-port.js';
+
+export class AuditLogWriteError extends Error {
+  readonly cause: unknown;
+
+  constructor(message: string, cause: unknown) {
+    super(message);
+    this.name = 'AuditLogWriteError';
+    this.cause = cause;
+  }
+}
+
+export interface RecordPhaseOverrideAuditInput {
+  readonly scope: { unitId?: string; storyId?: string };
+  readonly targetLevel: 1 | 2 | 3;
+  readonly appliedRules: readonly string[];
+  readonly requestedOverride: boolean;
+}
+
+export interface RecordPhaseOverrideAuditUseCaseDeps {
+  readonly auditLogger: PhaseAuditLoggerPort;
+}
+
+export class RecordPhaseOverrideAuditUseCase {
+  private readonly auditLogger: PhaseAuditLoggerPort;
+
+  constructor(deps: RecordPhaseOverrideAuditUseCaseDeps) {
+    this.auditLogger = deps.auditLogger;
+  }
+
+  async execute(input: RecordPhaseOverrideAuditInput): Promise<void> {
+    if (!input.requestedOverride || input.appliedRules.length === 0) {
+      return;
+    }
+
+    try {
+      await this.auditLogger.record({
+        scope: input.scope,
+        targetLevel: input.targetLevel,
+        appliedRules: Object.freeze([...input.appliedRules]),
+        generatedAt: new Date().toISOString(),
+        requestedOverride: input.requestedOverride,
+      });
+    } catch (error) {
+      throw new AuditLogWriteError('監査ログの書き込みに失敗しました', error);
+    }
+  }
+}

package/scripts/harness/phase-dependency-model/application/usecases/validate-customization-policy-usecase.ts

@@ -0,0 +1,62 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ */
+
+import type { CustomizationValidationResultDto } from '../dto/customization-validation-result-dto.js';
+import {
+  CyclicPhaseDependencyError,
+  NonRelaxableDependencyOverrideError,
+  PhaseStructure,
+} from '../../domain/models/phase-structure.js';
+import type { PhaseConfigProviderPort } from '../../domain/ports/phase-config-provider-port.js';
+import { InvalidCustomRuleError } from '../../domain/values/custom-rule.js';
+import type { CustomRule } from '../../domain/values/custom-rule.js';
+
+export interface ValidateCustomizationPolicyInput {}
+
+export interface ValidateCustomizationPolicyUseCaseDeps {
+  readonly phaseConfigProvider: PhaseConfigProviderPort;
+}
+
+const mapRule = (rule: CustomRule): readonly string[] =>
+  Object.freeze(rule.action.map((entry) => `${entry}->${rule.targetPhase}`));
+
+export class ValidateCustomizationPolicyUseCase {
+  private readonly phaseConfigProvider: PhaseConfigProviderPort;
+
+  constructor(deps: ValidateCustomizationPolicyUseCaseDeps) {
+    this.phaseConfigProvider = deps.phaseConfigProvider;
+  }
+
+  async execute(_input: ValidateCustomizationPolicyInput): Promise<CustomizationValidationResultDto> {
+    const policy = await this.phaseConfigProvider.getCustomizationPolicy();
+    const warnings = policy.requestsOverride() ? ['overrideが要求されています'] : [];
+
+    try {
+      PhaseStructure.createDefault(policy);
+
+      return Object.freeze({
+        valid: true,
+        errors: Object.freeze([]),
+        warnings: Object.freeze([...warnings]),
+        effectiveRules: Object.freeze(policy.rules.flatMap((rule) => mapRule(rule))),
+      });
+    } catch (error) {
+      if (
+        error instanceof InvalidCustomRuleError ||
+        error instanceof NonRelaxableDependencyOverrideError ||
+        error instanceof CyclicPhaseDependencyError
+      ) {
+        return Object.freeze({
+          valid: false,
+          errors: Object.freeze([error.message]),
+          warnings: Object.freeze([...warnings]),
+          effectiveRules: Object.freeze([]),
+        });
+      }
+
+      throw error;
+    }
+  }
+}

package/scripts/harness/phase-dependency-model/composition-root.ts

@@ -0,0 +1,76 @@
+/**
+ * @layer composition
+ * @unit phase-dependency-model
+ *
+ * phase-dependency-model ユニットの Composition Root。
+ * 全コンポーネントを生成・配線し、外部に公開するハンドラー群を返す。
+ */
+import { FileSystemArtifactExistenceChecker } from './infrastructure/filesystem/file-system-artifact-existence-checker.js';
+import { MarkdownPlanDocumentReader } from './infrastructure/filesystem/markdown-plan-document-reader.js';
+import {
+  HarnessConfigPhaseConfigProvider,
+  type PhaseConfigSection,
+} from './infrastructure/config/harness-config-phase-config-provider.js';
+import { PhaseOverrideAuditLogger } from './infrastructure/logging/phase-override-audit-logger.js';
+import { EvidenceBundleAssembler } from './application/services/evidence-bundle-assembler.js';
+import { CheckPhaseGateUseCase } from './application/usecases/check-phase-gate-usecase.js';
+import { CheckPhaseGateCommandHandler } from './presentation/cli/check-phase-gate-command-handler.js';
+
+const DEFAULT_REPORT_OUTPUT_DIR = '.harness/reports';
+
+const defaultPhaseConfig: PhaseConfigSection = {
+  planningMode: 'interactive' as const,
+  customization: { preset: 'default' as const },
+  reportingOutputDir: DEFAULT_REPORT_OUTPUT_DIR,
+};
+
+export interface PhaseDependencyModelConfig {
+  readonly rootDir: string;
+  readonly phaseConfig?: unknown; // PhaseConfigSection from resolved config
+  readonly reportOutputDir?: string;
+}
+
+export function createPhaseDependencyModelModule(
+  config: PhaseDependencyModelConfig,
+) {
+  const phaseConfig = (config.phaseConfig as PhaseConfigSection | undefined) ?? defaultPhaseConfig;
+  const reportOutputDir = config.reportOutputDir ?? DEFAULT_REPORT_OUTPUT_DIR;
+
+  // Infrastructure
+  const artifactExistenceChecker = new FileSystemArtifactExistenceChecker({
+    rootDir: config.rootDir,
+  });
+  const planDocumentReader = new MarkdownPlanDocumentReader({
+    rootDir: config.rootDir,
+  });
+  const phaseConfigProvider = new HarnessConfigPhaseConfigProvider({
+    config: phaseConfig,
+    defaultOutputDir: reportOutputDir,
+  });
+  const auditLogger = new PhaseOverrideAuditLogger({
+    outputDir: reportOutputDir,
+  });
+
+  // Application services
+  const evidenceBundleAssembler = new EvidenceBundleAssembler({
+    artifactExistenceChecker,
+    planDocumentReader,
+    phaseConfigProvider,
+  });
+
+  // Usecases
+  const checkPhaseGateUseCase = new CheckPhaseGateUseCase({
+    phaseConfigProvider,
+    evidenceBundleAssembler,
+    auditLogger,
+  });
+
+  // Presentation handlers
+  const checkPhaseGateCommandHandler = new CheckPhaseGateCommandHandler({
+    checkPhaseGateUseCase,
+  });
+
+  return {
+    checkPhaseGateCommandHandler,
+  } as const;
+}