phasegate 0.16.0 → 0.31.0

package/scripts/harness/main.ts

@@ -8,10 +8,18 @@
  */
 
 import { dirname, join, resolve } from 'node:path';
+import { readFile as fsReadFile } from 'node:fs/promises';
 import { createConfigFoundationModule } from './config-foundation/composition-root.js';
+import { toPhaseConfigSection } from './config-foundation/application/mappers/phase-config-section-mapper.js';
 import { createHarnessErrorModule } from './harness-error/composition-root.js';
 import { createTraceabilityModelModule } from './traceability-model/composition-root.js';
 import { createPhaseDependencyModelModule } from './phase-dependency-model/composition-root.js';
+import { HarnessConfigPhaseConfigProvider, type PhaseConfigSection as PhaseDepConfigSection } from './phase-dependency-model/infrastructure/config/harness-config-phase-config-provider.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 { FileSystemStoryReflectionAdapter } from './phase-dependency-model/infrastructure/filesystem/file-system-story-reflection-adapter.js';
+import { StoryReflectionStatusPresenter } from './phase-dependency-model/presentation/cli/story-reflection-status-presenter.js';
+import { StoryReflectionResult } from './phase-dependency-model/domain/values/story-reflection-result.js';
 import { createAdrFoundationModule } from './adr-foundation/composition-root.js';
 import { createBiomeAstEngineModule } from './biome-ast-engine/composition-root.js';
 import { createValidatorSystemModule } from './validator-system/composition-root.js';
@@ -21,8 +29,10 @@ import { buildCiGovernance } from './ci-governance/composition-root.js';
 import { createSkillQualityHandlers } from './skill-quality/composition-root.js';
 import { buildRegressionSuite } from './regression-suite/composition-root.js';
 import { buildPhase2Extensions } from './phase2-extensions/composition-root.js';
-import { deploySkills, deployHookScripts, getDeployedVersion, getHarnessVersion, initHarnessConfig } from './setup/skill-deployer.js';
+import { deploySkills, deployHookScripts, getDeployedVersion, getHarnessVersion, initHarnessConfig, SKILL_CATEGORIES, getCategoryForSkill } from './setup/skill-deployer.js';
+import type { SkillSet } from './setup/skill-deployer.js';
 import type { HarnessConfigV2 } from './config-foundation/domain/harness-config.js';
+import { ConfigValidationError } from './config-foundation/domain/errors/config-validation-error.js';
 
 /**
  * main.ts (scripts/harness/main.ts) から2階層上がパッケージルート。
@@ -42,7 +52,7 @@ Usage: phasegate <command> [options]
 
 Setup:
   init                         Initialize project: deploy skills + create phasegate.config.json
-                               (--name <project-name>)
+                               (--name <project-name>, --preset <full|standard|minimal|custom>)
   update-skills                Re-deploy skills from current harness version
 
 Commands:
@@ -199,11 +209,14 @@ function parseCoverageThreshold(raw: string | undefined): number {
   return n;
 }
 
-type PhasePreset = 'default' | 'custom';
+type InitPhasePreset = 'full' | 'standard' | 'minimal' | 'custom';
 
-function toPhasePreset(value: string): PhasePreset {
-  if (value === 'default' || value === 'custom') return value;
-  return 'default';
+function parseInitPhasePreset(value: string | undefined): InitPhasePreset | undefined {
+  if (value === undefined) return undefined;
+  if (value === 'full' || value === 'standard' || value === 'minimal' || value === 'custom') {
+    return value;
+  }
+  return undefined;
 }
 
 type RuleSeverity = 'error' | 'warning' | 'off';
@@ -224,32 +237,82 @@ function toRuleSeverityMap(
 }
 
 /**
- * HarnessConfigV2 (resolved) から phase-dependency-model が期待する PhaseConfigSection を抽出する。
+ * HarnessConfigV2 (resolved) から biome-ast-engine が期待する L1 Config を抽出する。
  */
-function toPhaseConfigSection(resolvedConfig: HarnessConfigV2) {
+function toL1Config(resolvedConfig: HarnessConfigV2) {
   return {
-    planningMode: resolvedConfig.planningMode,
-    customization: {
-      preset: toPhasePreset(resolvedConfig.phaseDependencies.preset),
-      overrideEnabled: resolvedConfig.phaseDependencies.override,
-      rules: resolvedConfig.phaseDependencies.customRules.map((r) => ({
-        targetPhase: r.phase,
-        condition: 'requires',
-        action: r.requires,
-      })),
-    },
-    reportingOutputDir: resolvedConfig.reporting.outputDir,
+    enabled: resolvedConfig.layers.L1.enabled,
+    rules: toRuleSeverityMap(resolvedConfig.layers.L1.rules),
   };
 }
 
 /**
- * HarnessConfigV2 (resolved) から biome-ast-engine が期待する L1 Config を抽出する。
+ * phasegate.config.json を直接読み、storyReflection 設定解決用の provider を返す。
+ * config-foundation の HarnessConfigV2 は storyReflection 未サポートのため raw JSON 経由。
  */
-function toL1Config(resolvedConfig: HarnessConfigV2) {
-  return {
-    enabled: resolvedConfig.layers.L1.enabled,
-    rules: toRuleSeverityMap(resolvedConfig.layers.L1.rules),
+async function loadStoryReflectionProvider(
+  rootDir: string,
+): Promise<HarnessConfigPhaseConfigProvider | null> {
+  const configPath = join(rootDir, 'phasegate.config.json');
+  let raw: {
+    phaseDependencies?: {
+      preset?: 'default' | 'full' | 'standard' | 'minimal' | 'custom';
+      override?: boolean;
+      storyReflection?: {
+        enabled?: boolean;
+        mappings?: ReadonlyArray<{ inception: string; product: string; required: boolean }>;
+      };
+    };
+    reporting?: { outputDir?: string };
+  };
+  try {
+    const content = await fsReadFile(configPath, 'utf8');
+    raw = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  const section: PhaseDepConfigSection = {
+    customization: {
+      preset: raw.phaseDependencies?.preset,
+      overrideEnabled: raw.phaseDependencies?.override ?? false,
+    },
+    storyReflection: raw.phaseDependencies?.storyReflection,
+    reportingOutputDir: raw.reporting?.outputDir,
   };
+  return new HarnessConfigPhaseConfigProvider({
+    config: section,
+    defaultOutputDir: raw.reporting?.outputDir ?? '.harness/reports',
+  });
+}
+
+async function printStoryReflectionValidationSummary(
+  rootDir: string,
+  unit: string | undefined,
+): Promise<void> {
+  const provider = await loadStoryReflectionProvider(rootDir);
+  if (provider === null) return;
+  const config = await provider.getStoryReflectionConfig();
+  const policy = await provider.getCustomizationPolicy();
+  const presenter = new StoryReflectionStatusPresenter();
+  let result = StoryReflectionResult.pass();
+  if (config.enabled && unit) {
+    const fsAdapter = new FileSystemStoryReflectionAdapter({ rootDir });
+    const checker = new StoryReflectionChecker(fsAdapter);
+    const useCase = new CheckStoryReflectionUseCase({ checker });
+    result = await useCase.execute({ unitId: unit, config });
+  }
+  console.log(
+    presenter.formatValidationSummary({ config, preset: policy.preset, result }),
+  );
+}
+
+async function printStoryReflectionStatusLine(rootDir: string): Promise<void> {
+  const provider = await loadStoryReflectionProvider(rootDir);
+  if (provider === null) return;
+  const config = await provider.getStoryReflectionConfig();
+  const policy = await provider.getCustomizationPolicy();
+  const presenter = new StoryReflectionStatusPresenter();
+  console.log(presenter.formatStatusLine({ config, preset: policy.preset }));
 }
 
 async function loadResolvedConfig(): Promise<HarnessConfigV2 | undefined> {
@@ -257,7 +320,12 @@ async function loadResolvedConfig(): Promise<HarnessConfigV2 | undefined> {
     const configModule = createConfigFoundationModule();
     const result = await configModule.usecases.loadResolvedConfigUseCase.execute();
     return result.config;
-  } catch {
+  } catch (error) {
+    if (error instanceof ConfigValidationError) {
+      process.stderr.write(`Invalid phasegate.config.json: ${error.message}\n`);
+      process.exit(2);
+    }
+
     return undefined;
   }
 }
@@ -290,10 +358,28 @@ async function main(): Promise<void> {
       // ── harness setup ──
       case 'init': {
         const projectName = parseFlag(args, '--name') ?? 'my-project';
-        const result = await deploySkills(harnessRoot, rootDir);
-        const configResult = await initHarnessConfig(rootDir, projectName);
+        const rawPhasePreset = parseFlag(args, '--preset');
+        if (
+          rawPhasePreset !== undefined
+          && rawPhasePreset !== 'full'
+          && rawPhasePreset !== 'standard'
+          && rawPhasePreset !== 'minimal'
+          && rawPhasePreset !== 'custom'
+        ) {
+          console.error(`Invalid --preset value: "${rawPhasePreset}". Use "full", "standard", "minimal", or "custom".`);
+          process.exit(2);
+        }
+        const phasePreset = parseInitPhasePreset(rawPhasePreset);
+        const skillSetRaw = parseFlag(args, '--skills') ?? 'all';
+        if (skillSetRaw !== 'core' && skillSetRaw !== 'all') {
+          console.error(`Invalid --skills value: "${skillSetRaw}". Use "core" or "all".`);
+          process.exit(2);
+        }
+        const skillSet: SkillSet = skillSetRaw;
+        const result = await deploySkills(harnessRoot, rootDir, skillSet);
+        const configResult = await initHarnessConfig(rootDir, projectName, phasePreset);
         const hooksResult = await deployHookScripts(harnessRoot, rootDir);
-        console.log(`✓ Skills deployed to ${result.targetDir} (${result.deployedSkills.length} skills)`);
+        console.log(`✓ Skills deployed to ${result.targetDir} (${result.deployedSkills.length} skills, set: ${skillSet})`);
         if (configResult.created) {
           console.log(`✓ phasegate.config.json created`);
         } else {
@@ -310,7 +396,11 @@ async function main(): Promise<void> {
         console.log(`✓ Harness v${result.version} initialized`);
         console.log('');
         console.log('Next steps:');
-        console.log('  1. Run the product-architect skill to start AIDLC');
+        if (skillSet === 'core') {
+          console.log('  1. Core skills only — quality defense tools are ready');
+        } else {
+          console.log('  1. Run the product-architect skill to start AIDLC');
+        }
         console.log('  2. Customize phasegate.config.json if needed');
         console.log('  3. Edit .claude/scripts/hook-config.json to set target directories');
         process.exit(0);
@@ -320,14 +410,19 @@ async function main(): Promise<void> {
       case 'update-skills': {
         const deployed = await getDeployedVersion(rootDir);
         const current = await getHarnessVersion(harnessRoot);
+        const previousSkillSet: SkillSet = deployed?.skillSet ?? 'all';
+        const overrideSkillSet = parseFlag(args, '--skills');
+        const updateSkillSet: SkillSet = overrideSkillSet === 'core' || overrideSkillSet === 'all'
+          ? overrideSkillSet
+          : previousSkillSet;
         if (deployed) {
-          console.log(`Previously deployed: v${deployed.version} (${deployed.deployedAt})`);
+          console.log(`Previously deployed: v${deployed.version} (${deployed.deployedAt}, set: ${previousSkillSet})`);
         } else {
           console.log('No previously deployed skills found');
         }
         console.log(`Current harness version: v${current}`);
-        const result = await deploySkills(harnessRoot, rootDir);
-        console.log(`✓ Skills updated (${result.deployedSkills.length} skills redeployed)`);
+        const result = await deploySkills(harnessRoot, rootDir, updateSkillSet);
+        console.log(`✓ Skills updated (${result.deployedSkills.length} skills redeployed, set: ${updateSkillSet})`);
         process.exit(0);
         break;
       }
@@ -443,11 +538,13 @@ async function main(): Promise<void> {
         const level = Number(parseFlag(args, '--level') ?? '1');
         const unitId = parseFlag(args, '--unit');
         const storyId = parseFlag(args, '--story');
+        const targetFilePath = parseFlag(args, '--target-file');
         const result =
           await mod.checkPhaseGateCommandHandler.execute({
             targetLevel: level,
             unitId,
             storyId,
+            targetFilePath,
             json,
           });
         console.log(result.text);
@@ -523,6 +620,9 @@ async function main(): Promise<void> {
           targetPaths,
         });
         console.log(result.output);
+        if (layer === 'L2' || layer === 'all') {
+          await printStoryReflectionValidationSummary(rootDir, unit);
+        }
         process.exit(result.exitCode);
         break;
       }
@@ -585,6 +685,7 @@ async function main(): Promise<void> {
         const flags: Record<string, boolean | string> = {};
         if (json) flags.json = true;
         await mod.handlers.status.handle({}, flags);
+        await printStoryReflectionStatusLine(rootDir);
         break;
       }
 
@@ -833,9 +934,28 @@ async function main(): Promise<void> {
             }
           }
           skills.sort();
-          console.log(`Available skills (${skills.length}):\n`);
+
+          const grouped: Record<string, string[]> = { core: [], aidlc: [], utility: [], unknown: [] };
           for (const name of skills) {
-            console.log(`  /${name}`);
+            const cat = getCategoryForSkill(name) ?? 'unknown';
+            grouped[cat].push(name);
+          }
+
+          console.log(`Available skills (${skills.length}):\n`);
+
+          const labels: Record<string, string> = {
+            core: 'Core — Quality Defense',
+            aidlc: 'AIDLC — Development Workflow',
+            utility: 'Utility',
+          };
+          for (const cat of ['core', 'aidlc', 'utility', 'unknown'] as const) {
+            if (grouped[cat].length === 0) continue;
+            const label = labels[cat] ?? 'Other';
+            console.log(`  [${label}] (${grouped[cat].length})`);
+            for (const name of grouped[cat]) {
+              console.log(`    /${name}`);
+            }
+            console.log('');
           }
           process.exit(0);
         }

package/scripts/harness/phase-dependency-model/application/dto/resolve-gate-result-dto.ts

@@ -0,0 +1,14 @@
+// @unit phase-dependency-model
+// @layer application
+
+export interface ResolveGateFindingDto {
+  readonly gateName: string;
+  readonly path: string;
+  readonly reason: string;
+}
+
+export interface ResolveGateResultDto {
+  readonly matchedGates: readonly string[];
+  readonly blockers: readonly ResolveGateFindingDto[];
+  readonly warnings: readonly ResolveGateFindingDto[];
+}

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

@@ -4,6 +4,7 @@
  */
 
 import type { PhaseGateResultDto } from '../dto/phase-gate-result-dto.js';
+import type { ResolveGateResultDto } from '../dto/resolve-gate-result-dto.js';
 import type { PhaseGateResult } from '../../domain/values/phase-gate-result.js';
 
 export class PhaseGateResultMapper {
@@ -22,4 +23,23 @@ export class PhaseGateResultMapper {
       auditRecorded: context.auditRecorded,
     });
   }
+
+  mapFromResolve(
+    result: ResolveGateResultDto,
+    context: {
+      readonly targetLevel: 1 | 2 | 3;
+    },
+  ): PhaseGateResultDto {
+    return Object.freeze({
+      passed: result.blockers.length === 0,
+      targetLevel: context.targetLevel,
+      blockers: Object.freeze(
+        result.blockers.map((blocker) => `${blocker.gateName}: ${blocker.reason} (${blocker.path})`),
+      ),
+      warnings: Object.freeze(
+        result.warnings.map((warning) => `${warning.gateName}: ${warning.reason} (${warning.path})`),
+      ),
+      auditRecorded: false,
+    });
+  }
 }

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

@@ -0,0 +1,42 @@
+/**
+ * @layer application
+ * @unit phase-dependency-model
+ *
+ * CheckStoryReflectionUseCase
+ * StoryReflectionChecker をオーケストレーションし、inception → product への
+ * storyId 反映状況を検証するユースケース。
+ *
+ * 入力: unitId, StoryReflectionConfig
+ * 出力: StoryReflectionResult（pass/fail + violations/warnings）
+ *
+ * enabled=false の場合は即座に pass を返す。
+ */
+
+import type { StoryReflectionChecker } from '../../domain/services/story-reflection-checker.js';
+import type { StoryReflectionConfig } from '../../domain/values/story-reflection-config.js';
+import { StoryReflectionResult } from '../../domain/values/story-reflection-result.js';
+
+export interface CheckStoryReflectionInput {
+  readonly unitId: string;
+  readonly config: StoryReflectionConfig;
+}
+
+export interface CheckStoryReflectionUseCaseDeps {
+  readonly checker: StoryReflectionChecker;
+}
+
+export class CheckStoryReflectionUseCase {
+  private readonly checker: StoryReflectionChecker;
+
+  constructor(deps: CheckStoryReflectionUseCaseDeps) {
+    this.checker = deps.checker;
+  }
+
+  async execute(input: CheckStoryReflectionInput): Promise<StoryReflectionResult> {
+    if (!input.config.enabled) {
+      return StoryReflectionResult.pass();
+    }
+
+    return this.checker.check(input.unitId, input.config);
+  }
+}

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

@@ -0,0 +1,161 @@
+// @unit phase-dependency-model
+// @layer application
+
+import type { ResolveGateResultDto, ResolveGateFindingDto } from '../dto/resolve-gate-result-dto.js';
+import { GateGraph } from '../../domain/services/gate-graph.js';
+import type { ArtifactExistenceCheckerPort } from '../../domain/ports/artifact-existence-checker-port.js';
+import type { GlobMatcherPort } from '../../domain/ports/glob-matcher-port.js';
+import type { StoryAnnotationVerifierPort } from '../../domain/ports/story-annotation-verifier-port.js';
+import { Artifact } from '../../domain/values/artifact.js';
+import type { GateDefinition, GateRequirement } from '../../domain/values/gate-definition.js';
+
+export interface ResolveGateInput {
+  readonly targetFilePath: string;
+  readonly gates: readonly GateDefinition[];
+  readonly scope?: {
+    readonly unitId?: string;
+    readonly storyId?: string;
+  };
+}
+
+export interface ResolveGateUseCaseDeps {
+  readonly globMatcher: GlobMatcherPort;
+  readonly artifactExistenceChecker: ArtifactExistenceCheckerPort;
+  readonly storyAnnotationVerifier?: StoryAnnotationVerifierPort;
+}
+
+interface RequirementEvaluation {
+  readonly gateName: string;
+  readonly requirement: GateRequirement;
+  readonly resolvedPath: string;
+}
+
+export class ResolveGateUseCase {
+  private readonly globMatcher: GlobMatcherPort;
+  private readonly artifactExistenceChecker: ArtifactExistenceCheckerPort;
+  private readonly storyAnnotationVerifier?: StoryAnnotationVerifierPort;
+
+  constructor(deps: ResolveGateUseCaseDeps) {
+    this.globMatcher = deps.globMatcher;
+    this.artifactExistenceChecker = deps.artifactExistenceChecker;
+    this.storyAnnotationVerifier = deps.storyAnnotationVerifier;
+  }
+
+  async execute(input: ResolveGateInput): Promise<ResolveGateResultDto> {
+    const graph = GateGraph.build([...input.gates]);
+    const matchedGates = input.gates.filter((gate) =>
+      gate.blocks.some((pattern) => this.globMatcher.match(pattern, input.targetFilePath)),
+    );
+
+    if (matchedGates.length === 0) {
+      return Object.freeze({
+        matchedGates: Object.freeze([]),
+        blockers: Object.freeze([]),
+        warnings: Object.freeze([]),
+      });
+    }
+
+    const evaluationOrder = new Map<string, GateDefinition>();
+    for (const gate of matchedGates) {
+      for (const ancestorName of graph.resolveAncestors(gate.name)) {
+        const ancestor = graph.gates.get(ancestorName.value);
+        if (ancestor && !evaluationOrder.has(ancestor.name.value)) {
+          evaluationOrder.set(ancestor.name.value, ancestor);
+        }
+      }
+
+      if (!evaluationOrder.has(gate.name.value)) {
+        evaluationOrder.set(gate.name.value, gate);
+      }
+    }
+
+    const evaluations = [...evaluationOrder.values()].flatMap((gate) =>
+      gate.requires.map((requirement) => ({
+        gateName: gate.name.value,
+        requirement,
+        resolvedPath: this.expandPlaceholders(requirement.path, input.scope),
+      })),
+    );
+    const artifacts = evaluations.map((evaluation, index) =>
+      Artifact.create({
+        name: `${evaluation.gateName}-${index + 1}`,
+        path: evaluation.resolvedPath,
+        required: evaluation.requirement.required,
+      }),
+    );
+    const statuses = await this.artifactExistenceChecker.checkAll(artifacts, input.scope ?? {});
+
+    const blockers: ResolveGateFindingDto[] = [];
+    const warnings: ResolveGateFindingDto[] = [];
+
+    for (const evaluation of evaluations) {
+      if (statuses.get(evaluation.resolvedPath) === true) {
+        continue;
+      }
+
+      const finding = Object.freeze({
+        gateName: evaluation.gateName,
+        path: evaluation.resolvedPath,
+        reason: evaluation.requirement.required
+          ? '必須アーティファクトが不足しています'
+          : '推奨アーティファクトが不足しています',
+      });
+
+      if (evaluation.requirement.required) {
+        blockers.push(finding);
+      } else {
+        warnings.push(finding);
+      }
+    }
+
+    if (this.storyAnnotationVerifier) {
+      for (const gate of matchedGates) {
+        if (!gate.storyAnnotation) {
+          continue;
+        }
+
+        const verification = await this.storyAnnotationVerifier.verify(
+          input.targetFilePath,
+          gate.storyAnnotation.tag,
+        );
+
+        if (verification.hasAnnotation) {
+          continue;
+        }
+
+        const finding = Object.freeze({
+          gateName: gate.name.value,
+          path: input.targetFilePath,
+          reason: gate.storyAnnotation.required
+            ? `${gate.storyAnnotation.tag} 注釈が必要です`
+            : `${gate.storyAnnotation.tag} 注釈を推奨します`,
+        });
+
+        if (gate.storyAnnotation.required) {
+          blockers.push(finding);
+          continue;
+        }
+
+        warnings.push(finding);
+      }
+    }
+
+    return Object.freeze({
+      matchedGates: Object.freeze(matchedGates.map((gate) => gate.name.value)),
+      blockers: Object.freeze(blockers),
+      warnings: Object.freeze(warnings),
+    });
+  }
+
+  private expandPlaceholders(
+    path: string,
+    scope?: {
+      readonly unitId?: string;
+      readonly storyId?: string;
+    },
+  ): string {
+    return path
+      .replaceAll('{unit}', scope?.unitId ?? '{unit}')
+      .replaceAll('{storyId}', scope?.storyId ?? '{storyId}');
+  }
+}

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

@@ -7,13 +7,19 @@
  */
 import { FileSystemArtifactExistenceChecker } from './infrastructure/filesystem/file-system-artifact-existence-checker.js';
 import { MarkdownPlanDocumentReader } from './infrastructure/filesystem/markdown-plan-document-reader.js';
+import { PicomatchGlobMatcher } from './infrastructure/adapters/picomatch-glob-matcher.js';
+import { StoryAnnotationVerifierAdapter } from './infrastructure/adapters/story-annotation-verifier-adapter.js';
+import { CustomGatesConfigParser } from './infrastructure/config/custom-gates-config-parser.js';
+import { MarkdownDesignDocumentGateway } from '../traceability-model/infrastructure/gateways/markdown-design-document-gateway.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 { PhaseGateResultMapper } from './application/services/phase-gate-result-mapper.js';
 import { CheckPhaseGateUseCase } from './application/usecases/check-phase-gate-usecase.js';
+import { ResolveGateUseCase } from './application/usecases/resolve-gate-usecase.js';
 import { CheckPhaseGateCommandHandler } from './presentation/cli/check-phase-gate-command-handler.js';
 
 const DEFAULT_REPORT_OUTPUT_DIR = '.harness/reports';
@@ -35,6 +41,16 @@ export function createPhaseDependencyModelModule(
 ) {
   const phaseConfig = (config.phaseConfig as PhaseConfigSection | undefined) ?? defaultPhaseConfig;
   const reportOutputDir = config.reportOutputDir ?? DEFAULT_REPORT_OUTPUT_DIR;
+  const rawCustomGates =
+    ((config.phaseConfig as {
+      readonly gates?: readonly unknown[];
+      readonly customization?: { readonly gates?: readonly unknown[]; readonly preset?: string };
+    } | undefined)?.gates) ??
+    ((config.phaseConfig as {
+      readonly customization?: { readonly gates?: readonly unknown[]; readonly preset?: string };
+    } | undefined)?.customization?.gates) ??
+    [];
+  const isCustomPreset = phaseConfig.customization?.preset === 'custom';
 
   // Infrastructure
   const artifactExistenceChecker = new FileSystemArtifactExistenceChecker({
@@ -47,9 +63,17 @@ export function createPhaseDependencyModelModule(
     config: phaseConfig,
     defaultOutputDir: reportOutputDir,
   });
+  const designDocumentGateway = new MarkdownDesignDocumentGateway({
+    rootDir: config.rootDir,
+  });
   const auditLogger = new PhaseOverrideAuditLogger({
     outputDir: reportOutputDir,
   });
+  const globMatcher = new PicomatchGlobMatcher();
+  const storyAnnotationVerifier = new StoryAnnotationVerifierAdapter({
+    designDocumentGateway,
+  });
+  const customGatesConfigParser = new CustomGatesConfigParser();
 
   // Application services
   const evidenceBundleAssembler = new EvidenceBundleAssembler({
@@ -57,6 +81,7 @@ export function createPhaseDependencyModelModule(
     planDocumentReader,
     phaseConfigProvider,
   });
+  const phaseGateResultMapper = new PhaseGateResultMapper();
 
   // Usecases
   const checkPhaseGateUseCase = new CheckPhaseGateUseCase({
@@ -64,10 +89,41 @@ export function createPhaseDependencyModelModule(
     evidenceBundleAssembler,
     auditLogger,
   });
+  const resolveGateUseCase = new ResolveGateUseCase({
+    globMatcher,
+    artifactExistenceChecker,
+    storyAnnotationVerifier,
+  });
+  const checkPhaseGateFacade = {
+    execute: async (input: {
+      readonly targetLevel: 1 | 2 | 3;
+      readonly unitId?: string;
+      readonly storyId?: string;
+      readonly targetFilePath?: string;
+    }) => {
+      if (isCustomPreset && input.targetFilePath) {
+        const { gates } = customGatesConfigParser.parse(rawCustomGates);
+        const resolved = await resolveGateUseCase.execute({
+          targetFilePath: input.targetFilePath,
+          gates,
+          scope: { unitId: input.unitId, storyId: input.storyId },
+        });
+        return phaseGateResultMapper.mapFromResolve(resolved, {
+          targetLevel: input.targetLevel,
+        });
+      }
+
+      return checkPhaseGateUseCase.execute({
+        targetLevel: input.targetLevel,
+        unitId: input.unitId,
+        storyId: input.storyId,
+      });
+    },
+  };
 
   // Presentation handlers
   const checkPhaseGateCommandHandler = new CheckPhaseGateCommandHandler({
-    checkPhaseGateUseCase,
+    checkPhaseGateUseCase: checkPhaseGateFacade,
   });
 
   return {

package/scripts/harness/phase-dependency-model/domain/definitions/{default-phase-dependencies.ts → full-phase-dependencies.ts}

@@ -3,12 +3,12 @@
  * @unit phase-dependency-model
  */
 
-import { DEFAULT_PHASE_NODES } from './default-phase-nodes.js';
+import { FULL_PHASE_NODES } from './full-phase-nodes.js';
 import { PhaseDependency } from '../values/phase-dependency.js';
 import { PhaseNode } from '../values/phase-node.js';
 
 const nodeIndex = new Map<string, PhaseNode>(
-  DEFAULT_PHASE_NODES.map((node) => [node.nodeKey(), node]),
+  FULL_PHASE_NODES.map((node) => [node.nodeKey(), node]),
 );
 
 const getNode = (nodeKey: string): PhaseNode => {
@@ -27,7 +27,7 @@ const createDependency = (
   type: 'requires' | 'recommends' = 'requires',
 ): PhaseDependency => PhaseDependency.create({ from: getNode(from), to: getNode(to), type });
 
-export const DEFAULT_PHASE_DEPENDENCIES: readonly PhaseDependency[] = Object.freeze([
+export const FULL_PHASE_DEPENDENCIES: readonly PhaseDependency[] = Object.freeze([
   createDependency('1:product-architect', '1:story-writer'),
   createDependency('1:story-writer', '1:story-mapper'),
   createDependency('1:story-mapper', '1:unit-designer'),