phasegate 0.16.0 → 0.32.0

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'),

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

@@ -22,7 +22,7 @@ const createNode = (
     artifacts: artifacts.map((artifact) => Artifact.create(artifact)),
   });
 
-export const DEFAULT_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
+export const FULL_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
   createNode(1, 'product-architect', [
     {
       name: 'product-overview-plan',

package/scripts/harness/phase-dependency-model/domain/definitions/full-story-reflection-defaults.ts

@@ -0,0 +1,28 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { StoryReflectionConfig } from '../values/story-reflection-config.js';
+import { StoryReflectionMapping } from '../values/story-reflection-mapping.js';
+
+export const FULL_STORY_REFLECTION_DEFAULTS: StoryReflectionConfig = StoryReflectionConfig.create({
+  enabled: true,
+  mappings: [
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/logical_design.md',
+      product: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    }),
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/domain_model.md',
+      product: 'docs/product/construction/{unit}/domain_model.md',
+      required: true,
+    }),
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/uiux_design.md',
+      product: 'docs/product/construction/{unit}/uiux_design.md',
+      required: false,
+    }),
+  ],
+});

package/scripts/harness/phase-dependency-model/domain/definitions/minimal-phase-dependencies.ts

@@ -0,0 +1,32 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { MINIMAL_PHASE_NODES } from './minimal-phase-nodes.js';
+import { PhaseDependency } from '../values/phase-dependency.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const nodeIndex = new Map<string, PhaseNode>(
+  MINIMAL_PHASE_NODES.map((node) => [node.nodeKey(), node]),
+);
+
+const getNode = (nodeKey: string): PhaseNode => {
+  const actual = nodeIndex.get(nodeKey);
+
+  if (!actual) {
+    throw new Error(`ノードが見つかりません: ${nodeKey}`);
+  }
+
+  return actual;
+};
+
+const createDependency = (
+  from: string,
+  to: string,
+  type: 'requires' | 'recommends' = 'requires',
+): PhaseDependency => PhaseDependency.create({ from: getNode(from), to: getNode(to), type });
+
+export const MINIMAL_PHASE_DEPENDENCIES: readonly PhaseDependency[] = Object.freeze([
+  createDependency('1:product-architect', '2:logical-designer'),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/minimal-phase-nodes.ts

@@ -0,0 +1,50 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { Artifact } from '../values/artifact.js';
+import { PhaseLevel } from '../values/phase-level.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const createNode = (
+  level: 1 | 2 | 3,
+  skillName: string,
+  artifacts: readonly {
+    readonly name: string;
+    readonly path: string;
+    readonly required: boolean;
+  }[],
+): PhaseNode =>
+  PhaseNode.create({
+    skillName,
+    level: PhaseLevel.create(level),
+    artifacts: artifacts.map((artifact) => Artifact.create(artifact)),
+  });
+
+export const MINIMAL_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
+  createNode(1, 'product-architect', [
+    {
+      name: 'product-overview-plan',
+      path: 'docs/inception/_shared/product_overview_plan.md',
+      required: true,
+    },
+    {
+      name: 'product-overview',
+      path: 'docs/product/product_overview.md',
+      required: true,
+    },
+  ]),
+  createNode(2, 'logical-designer', [
+    {
+      name: 'logical-design-plan',
+      path: 'docs/inception/{unit}/logical_design_plan.md',
+      required: true,
+    },
+    {
+      name: 'logical-design',
+      path: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    },
+  ]),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/minimal-story-reflection-defaults.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { StoryReflectionConfig } from '../values/story-reflection-config.js';
+
+export const MINIMAL_STORY_REFLECTION_DEFAULTS: StoryReflectionConfig = StoryReflectionConfig.disabled();

package/scripts/harness/phase-dependency-model/domain/definitions/standard-phase-dependencies.ts

@@ -0,0 +1,39 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { STANDARD_PHASE_NODES } from './standard-phase-nodes.js';
+import { PhaseDependency } from '../values/phase-dependency.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const nodeIndex = new Map<string, PhaseNode>(
+  STANDARD_PHASE_NODES.map((node) => [node.nodeKey(), node]),
+);
+
+const getNode = (nodeKey: string): PhaseNode => {
+  const actual = nodeIndex.get(nodeKey);
+
+  if (!actual) {
+    throw new Error(`ノードが見つかりません: ${nodeKey}`);
+  }
+
+  return actual;
+};
+
+const createDependency = (
+  from: string,
+  to: string,
+  type: 'requires' | 'recommends' = 'requires',
+): PhaseDependency => PhaseDependency.create({ from: getNode(from), to: getNode(to), type });
+
+export const STANDARD_PHASE_DEPENDENCIES: readonly PhaseDependency[] = Object.freeze([
+  createDependency('1:product-architect', '1:story-writer'),
+  createDependency('1:story-writer', '2:domain-designer'),
+  createDependency('2:domain-designer', '2:logical-designer'),
+  createDependency('2:logical-designer', '3:logical-designer'),
+  createDependency('3:logical-designer', '3:scenario-test-designer'),
+  createDependency('3:scenario-test-designer', '3:scenario-test-logic-designer'),
+  createDependency('3:scenario-test-logic-designer', '3:implementation-readiness-checker'),
+  createDependency('3:implementation-readiness-checker', '3:story-implementor'),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/standard-phase-nodes.ts

@@ -0,0 +1,118 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { Artifact } from '../values/artifact.js';
+import { PhaseLevel } from '../values/phase-level.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const createNode = (
+  level: 1 | 2 | 3,
+  skillName: string,
+  artifacts: readonly {
+    readonly name: string;
+    readonly path: string;
+    readonly required: boolean;
+  }[],
+): PhaseNode =>
+  PhaseNode.create({
+    skillName,
+    level: PhaseLevel.create(level),
+    artifacts: artifacts.map((artifact) => Artifact.create(artifact)),
+  });
+
+export const STANDARD_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
+  createNode(1, 'product-architect', [
+    {
+      name: 'product-overview-plan',
+      path: 'docs/inception/_shared/product_overview_plan.md',
+      required: true,
+    },
+    {
+      name: 'product-overview',
+      path: 'docs/product/product_overview.md',
+      required: true,
+    },
+  ]),
+  createNode(1, 'story-writer', [
+    {
+      name: 'story-writer-plan',
+      path: 'docs/inception/_shared/story_writer_plan.md',
+      required: true,
+    },
+    {
+      name: 'user-stories',
+      path: 'docs/product/user_stories.md',
+      required: true,
+    },
+  ]),
+  createNode(2, 'domain-designer', [
+    {
+      name: 'domain-model-plan',
+      path: 'docs/inception/{unit}/domain_model_plan.md',
+      required: true,
+    },
+    {
+      name: 'domain-model',
+      path: 'docs/product/construction/{unit}/domain_model.md',
+      required: true,
+    },
+  ]),
+  createNode(2, 'logical-designer', [
+    {
+      name: 'logical-design-plan',
+      path: 'docs/inception/{unit}/logical_design_plan.md',
+      required: true,
+    },
+    {
+      name: 'logical-design',
+      path: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    },
+  ]),
+  createNode(3, 'logical-designer', [
+    {
+      name: 'story-logical-design-plan',
+      path: 'docs/inception/{unit}/{storyId}/logical_design_plan.md',
+      required: false,
+    },
+    {
+      name: 'story-logical-design',
+      path: 'docs/inception/{unit}/{storyId}/logical_design.md',
+      required: false,
+    },
+  ]),
+  createNode(3, 'scenario-test-designer', [
+    {
+      name: 'scenario-test-plan',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_plan.md',
+      required: false,
+    },
+    {
+      name: 'scenario-test-design',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_design.md',
+      required: false,
+    },
+  ]),
+  createNode(3, 'scenario-test-logic-designer', [
+    {
+      name: 'scenario-test-logic-plan',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_logic_plan.md',
+      required: false,
+    },
+    {
+      name: 'scenario-test-logic',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_logic.md',
+      required: false,
+    },
+  ]),
+  createNode(3, 'implementation-readiness-checker', []),
+  createNode(3, 'story-implementor', [
+    {
+      name: 'tdd-implementation-plan',
+      path: 'docs/inception/{unit}/{storyId}/tdd_implementation_plan.md',
+      required: false,
+    },
+  ]),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/standard-story-reflection-defaults.ts

@@ -0,0 +1,23 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { StoryReflectionConfig } from '../values/story-reflection-config.js';
+import { StoryReflectionMapping } from '../values/story-reflection-mapping.js';
+
+export const STANDARD_STORY_REFLECTION_DEFAULTS: StoryReflectionConfig = StoryReflectionConfig.create({
+  enabled: true,
+  mappings: [
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/logical_design.md',
+      product: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    }),
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/domain_model.md',
+      product: 'docs/product/construction/{unit}/domain_model.md',
+      required: false,
+    }),
+  ],
+});