phasegate 0.160.21 → 0.162.0

package/scripts/harness/validator-system/application/use-cases/run-l3-validators-usecase.ts

@@ -1,6 +1,7 @@
 /**
  * @layer application
  * @unit validator-system
+ * @work-item-id WI-212
  *
  * RunL3ValidatorsUseCase — H08-02: L3バリデータ実行
  */
@@ -8,6 +9,7 @@ import { ValidatorId } from '../../domain/value-objects/validator-id.js';
 import { ValidationResult } from '../../domain/value-objects/validation-result.js';
 import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
 import { ValidatorExecutionService, ValidatorExecutionError } from '../../domain/services/validator-execution-service.js';
+import { ValidatorLanguageCapabilityService } from '../../domain/services/validator-language-capability-service.js';
 import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
 import type { ValidationResultContract } from '../dto/validation-result-contract.js';
 import type { RunL3ValidatorsInput } from '../dto/run-l3-validators-input.js';
@@ -43,6 +45,7 @@ export class RunL3ValidatorsUseCase {
   private readonly coverageReportPort?: RunL3ValidatorsUseCaseDeps['coverageReportPort'];
   private readonly securityScannerPort?: SecurityPatternScannerPort;
   private readonly performanceScannerPort?: PerformanceScannerPort;
+  private readonly languageCapabilityService = new ValidatorLanguageCapabilityService();
 
   constructor(deps: RunL3ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -77,36 +80,80 @@ export class RunL3ValidatorsUseCase {
       return [];
     }
 
-    // coverageReportPort が存在する場合、カバレッジを取得して判定
-    if (this.coverageReportPort) {
-      const coverageData = await this.coverageReportPort.getCoverage();
+    const projectLanguages = await this.getProjectLanguages();
+    const { executableDefinitions, unsupportedResults, unsupportedValidatorIds } =
+      this.languageCapabilityService.splitDefinitions(definitions, projectLanguages);
+
+    const results = this.executionService.execute(executableDefinitions, [layerConfig]);
+    const overrideMap = new Map<string, ValidationResult>(
+      [...unsupportedResults, ...results].map((result) => [result.validatorId.value, result]),
+    );
+
+    // L3-003: カバレッジ判定（カバレッジゲートはオプトイン）
+    // - coverageThreshold 未設定 → SKIP（透過的に判定をスキップ。getCoverage() は呼ばない）
+    // - coverageThreshold 設定あり → getCoverage() を try/catch で包み FAIL-CLOSED で判定する
+    //   - 閾値未満 → FAIL / 閾値以上 → PASS
+    //   - レポート不在などで getCoverage() が失敗 → FAIL（合格扱いにしない）
+    // このブロックは例外を送出せず、L3-003 の per-validator 結果のみを差し替える。
+    // これにより兄弟バリデータ（L3-001/002/004 および L2/L4 バッチ）は常に通常実行される。
+    const l3003InScope =
+      !unsupportedValidatorIds.has('L3-003') &&
+      definitions.some((d) => d.validatorId.value === 'L3-003');
+    if (this.coverageReportPort && l3003InScope) {
+      const l3003Id = ValidatorId.create('L3-003');
       const threshold = layerConfig.getThreshold('coverageThreshold');
 
-      // カバレッジ不足の場合は fail 結果を生成
-      if (threshold !== null && coverageData.overallCoverage < threshold) {
-        const deficit = threshold - coverageData.overallCoverage;
-
-        // 他のバリデータを実行
-        const otherDefs = definitions.filter((d) => d.validatorId.value !== 'L3-003');
-        const otherResults = this.executionService.execute(otherDefs, [layerConfig]);
-        const otherContracts = this.mapper.toContracts(otherResults);
-
-        return [
-          ...otherContracts.filter((r) => r.validatorId !== 'L3-003'),
-          {
-            validatorId: 'L3-003',
-            passed: false,
-            errors: [{ code: 'L3-003', severity: 'error', message: `カバレッジ不足: 現在値 ${coverageData.overallCoverage}%、不足 ${deficit}%` , suggestion: `テストカバレッジを ${threshold}% 以上に引き上げてください` }],
-            durationMs: 0,
-            skipped: false,
-          },
-        ];
+      if (threshold === null) {
+        overrideMap.set(
+          'L3-003',
+          ValidationResult.skipWithReason(
+            l3003Id,
+            'coverageThreshold が未設定のためカバレッジ判定をスキップ（カバレッジゲートはオプトイン）',
+          ),
+        );
+      } else {
+        try {
+          const coverageData = await this.coverageReportPort.getCoverage();
+          if (coverageData.overallCoverage < threshold) {
+            overrideMap.set(
+              'L3-003',
+              ValidationResult.fail(
+                l3003Id,
+                [
+                  {
+                    code: 'L3-003',
+                    severity: 'error',
+                    message: `カバレッジ不足: 現在値 ${coverageData.overallCoverage}%、不足 ${threshold - coverageData.overallCoverage}%`,
+                    suggestion: `テストカバレッジを ${threshold}% 以上に引き上げてください`,
+                  },
+                ],
+                0,
+              ),
+            );
+          } else {
+            overrideMap.set('L3-003', ValidationResult.pass(l3003Id, 0));
+          }
+        } catch {
+          // レポート不在などで取得失敗 → FAIL-CLOSED（例外は握りつぶし per-validator FAIL に変換）
+          overrideMap.set(
+            'L3-003',
+            ValidationResult.fail(
+              l3003Id,
+              [
+                {
+                  code: 'L3-003',
+                  severity: 'error',
+                  message: `coverageThreshold=${threshold}% が設定されていますがカバレッジレポートが見つかりません（テストをカバレッジ付きで実行してください）`,
+                  suggestion: 'vitest --coverage 等でカバレッジレポートを生成してから再実行してください',
+                },
+              ],
+              0,
+            ),
+          );
+        }
       }
     }
 
-    const results = this.executionService.execute(definitions, [layerConfig]);
-    const overrideMap = new Map<string, ValidationResult>(results.map((result) => [result.validatorId.value, result]));
-
     if (this.securityScannerPort) {
       const l3001Result = overrideMap.get('L3-001');
       if (l3001Result && !l3001Result.skipped) {
@@ -153,4 +200,8 @@ export class RunL3ValidatorsUseCase {
     );
     return this.mapper.toContracts(finalResults);
   }
+
+  private async getProjectLanguages(): Promise<readonly string[]> {
+    return this.configPort.getProjectLanguages ? await this.configPort.getProjectLanguages() : ['typescript'];
+  }
 }

package/scripts/harness/validator-system/application/use-cases/run-l4-validators-usecase.ts

@@ -3,6 +3,7 @@
  * @unit validator-system
  * @work-item-id WI-107 / WI-156
  * @work-item-id WI-217
+ * @work-item-id WI-212
  *
  * RunL4ValidatorsUseCase — H08-03: L4バリデータ実行
  */
@@ -11,6 +12,7 @@ import { ValidationResult } from '../../domain/value-objects/validation-result.j
 import { LayerConfig } from '../../domain/value-objects/layer-config.js';
 import { ValidatorRegistry } from '../../domain/services/validator-registry.js';
 import { ValidatorExecutionService, ValidatorExecutionError } from '../../domain/services/validator-execution-service.js';
+import { ValidatorLanguageCapabilityService } from '../../domain/services/validator-language-capability-service.js';
 import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
 import type { ValidationResultContract } from '../dto/validation-result-contract.js';
 import type { RunL4ValidatorsInput } from '../dto/run-l4-validators-input.js';
@@ -93,6 +95,7 @@ export class RunL4ValidatorsUseCase {
   private readonly pathRoots: { readonly inceptionRoot: string; readonly designRoot: string };
   private readonly checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
   private readonly validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
+  private readonly languageCapabilityService = new ValidatorLanguageCapabilityService();
 
   constructor(deps: RunL4ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -141,11 +144,17 @@ export class RunL4ValidatorsUseCase {
           thresholds: { ...layerConfig.thresholds },
           strictOnly: layerConfig.strictOnly,
           preset: layerConfig.preset,
-        })
+      })
       : layerConfig;
 
-    const results = this.executionService.execute(definitions, [effectiveLayerConfig]);
-    const overrideMap = new Map<string, ValidationResult>(results.map((result) => [result.validatorId.value, result]));
+    const projectLanguages = await this.getProjectLanguages();
+    const { executableDefinitions, unsupportedResults } =
+      this.languageCapabilityService.splitDefinitions(definitions, projectLanguages);
+
+    const results = this.executionService.execute(executableDefinitions, [effectiveLayerConfig]);
+    const overrideMap = new Map<string, ValidationResult>(
+      [...unsupportedResults, ...results].map((result) => [result.validatorId.value, result]),
+    );
 
     if (this.driftDetectionService) {
       const l4001Result = overrideMap.get('L4-001');
@@ -168,9 +177,12 @@ export class RunL4ValidatorsUseCase {
       const l4002Result = overrideMap.get('L4-002');
       if (l4002Result && !l4002Result.skipped) {
         const report = await this.consistencyCheckService.check(input.targetUnits ? [...input.targetUnits] : undefined);
-        const reflectionResult = this.usesConfiguredDocumentRoots()
-          ? await this.consistencyCheckService.checkWorkItemReflection(this.pathRoots)
-          : undefined;
+        // WI-217: 標準レイアウト (docs/inception, docs/product/construction) でも
+        // reflection を必ず実行する。以前は usesConfiguredDocumentRoots() が false を
+        // 返すため標準構成では reflection が恒久的にスキップされ、L4-002 が常に PASS
+        // していた。description が存在しない場合はアダプタ側が skipReason を返すため、
+        // 常時実行しても未整備プロジェクトを誤って失敗させることはない。
+        const reflectionResult = await this.consistencyCheckService.checkWorkItemReflection(this.pathRoots);
         const architectureSemanticErrors = this.architectureSemanticAnalysisService
           ? await this.architectureSemanticAnalysisService.analyze()
           : [];
@@ -276,8 +288,8 @@ export class RunL4ValidatorsUseCase {
     return [...executionErrors, ...freshnessFindings];
   }
 
-  private usesConfiguredDocumentRoots(): boolean {
-    return this.pathRoots.inceptionRoot !== 'docs/inception' || this.pathRoots.designRoot !== 'docs/product/construction';
+  private async getProjectLanguages(): Promise<readonly string[]> {
+    return this.configPort.getProjectLanguages ? await this.configPort.getProjectLanguages() : ['typescript'];
   }
 
   private toPointerValidationHarnessErrors(output: ValidateDocPointersOutputContract): readonly ValidationResult['errors'][number][] {

package/scripts/harness/validator-system/composition-root.ts

@@ -29,6 +29,7 @@ import { FileSystemContractTraceabilityPolicyAdapter } from './infrastructure/ad
 import { PhaseDependencyPhaseGatePolicyAdapter } from './infrastructure/adapters/phase-dependency-phase-gate-policy-adapter.js';
 import { TraceabilityMetadataPolicyAdapter } from './infrastructure/adapters/traceability-metadata-policy-adapter.js';
 import { NyquistAcCoveragePolicyAdapter } from './infrastructure/adapters/nyquist-ac-coverage-policy-adapter.js';
+import { JsonCoverageReportAdapter } from './infrastructure/adapters/json-coverage-report-adapter.js';
 import { BiomeAstTestQualityAnalyzerAdapter } from './infrastructure/adapters/biome-ast-test-quality-analyzer-adapter.js';
 import { FileSystemSecurityPatternScannerAdapter } from './infrastructure/adapters/file-system-security-pattern-scanner-adapter.js';
 import { AstPerformanceScannerAdapter } from './infrastructure/adapters/ast-performance-scanner-adapter.js';
@@ -54,7 +55,7 @@ const DEFAULT_CONFIG = {
   preset: 'standard' as const,
   layers: {
     L2: { enabled: true, validators: ['L2-001', 'L2-002', 'L2-003', 'L2-013', 'L2-014', 'L2-015'] },
-    L3: { enabled: true, validators: ['L3-001', 'L3-002', 'L3-003', 'L3-004'], coverageThreshold: 90, bundleSizeLimit: 512000 },
+    L3: { enabled: true, validators: ['L3-001', 'L3-002', 'L3-003', 'L3-004'], coverageThreshold: 90, bundleSizeLimit: 512000, requirementMatrixPath: '.harness/requirement-test-matrix.json' },
     L4: { enabled: true, validators: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005', 'L4-006'] },
   },
   paths: {
@@ -149,6 +150,11 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const phaseGatePolicyPort = new PhaseDependencyPhaseGatePolicyAdapter();
   const metadataPolicyPort = new TraceabilityMetadataPolicyAdapter();
   const acCoveragePolicyPort = new NyquistAcCoveragePolicyAdapter();
+  // L3-003: テストカバレッジレポート（vitest --coverage の json-summary 出力）を読み取る。
+  // 未配線だと L3-003 は装飾的な pass になり 90% 閾値が形骸化するため必ず配線する。
+  const coverageReportPort = new JsonCoverageReportAdapter(
+    join(process.cwd(), 'coverage', 'coverage-summary.json'),
+  );
   const testQualityAnalyzerPort = new BiomeAstTestQualityAnalyzerAdapter();
   const securityScannerPort = new FileSystemSecurityPatternScannerAdapter();
   const performanceScannerPort = new AstPerformanceScannerAdapter();
@@ -189,6 +195,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     validatorConfigPort: configPort,
     contractMapper,
     acCoveragePolicyPort,
+    coverageReportPort,
     securityScannerPort,
     performanceScannerPort,
   });

package/scripts/harness/validator-system/domain/ports/validator-config-port.ts

@@ -1,6 +1,7 @@
 /**
  * @layer domain
  * @unit validator-system
+ * @work-item-id WI-212
  *
  * ValidatorConfigPort — HarnessConfigV2からLayerConfig取得
  */
@@ -8,4 +9,5 @@ import type { LayerConfig } from '../value-objects/layer-config.js';
 
 export interface ValidatorConfigPort {
   getLayerConfig(layer: 'L2' | 'L3' | 'L4'): Promise<LayerConfig>;
+  getProjectLanguages?(): Promise<readonly string[]>;
 }

package/scripts/harness/validator-system/domain/services/validator-language-capability-service.ts

@@ -0,0 +1,64 @@
+/**
+ * @layer domain
+ * @unit validator-system
+ * @work-item-id WI-212
+ */
+import type { ValidatorId } from '../value-objects/validator-id.js';
+import { ValidationResult } from '../value-objects/validation-result.js';
+import type { ValidatorDefinition } from '../value-objects/validator-definition.js';
+
+const DEFAULT_SUPPORTED_LANGUAGES = ['typescript'] as const;
+
+const VALIDATOR_LANGUAGE_CAPABILITIES: Readonly<Record<string, readonly string[]>> = {
+  'L3-002': DEFAULT_SUPPORTED_LANGUAGES,
+  'L3-003': DEFAULT_SUPPORTED_LANGUAGES,
+  'L4-003': DEFAULT_SUPPORTED_LANGUAGES,
+};
+
+export class ValidatorLanguageCapabilityService {
+  getUnsupportedValidatorIds(
+    validatorIds: readonly ValidatorId[],
+    projectLanguages: readonly string[],
+  ): ReadonlySet<string> {
+    const normalizedProjectLanguages = new Set(projectLanguages.map((language) => language.toLowerCase()));
+    const unsupportedIds = validatorIds
+      .filter((validatorId) => {
+        const supportedLanguages = VALIDATOR_LANGUAGE_CAPABILITIES[validatorId.value];
+        if (!supportedLanguages) return false;
+        return !supportedLanguages.some((language) => normalizedProjectLanguages.has(language));
+      })
+      .map((validatorId) => validatorId.value);
+
+    return new Set(unsupportedIds);
+  }
+
+  splitDefinitions(
+    definitions: readonly ValidatorDefinition[],
+    projectLanguages: readonly string[],
+  ): {
+    readonly executableDefinitions: readonly ValidatorDefinition[];
+    readonly unsupportedResults: readonly ValidationResult[];
+    readonly unsupportedValidatorIds: ReadonlySet<string>;
+  } {
+    const unsupportedValidatorIds = this.getUnsupportedValidatorIds(
+      definitions.map((definition) => definition.validatorId),
+      projectLanguages,
+    );
+    const executableDefinitions = definitions.filter(
+      (definition) => !unsupportedValidatorIds.has(definition.validatorId.value),
+    );
+    const unsupportedResults = definitions
+      .filter((definition) => unsupportedValidatorIds.has(definition.validatorId.value))
+      .map((definition) => ValidationResult.skipWithReason(
+        definition.validatorId,
+        this.createSkipReason(definition.validatorId, projectLanguages),
+      ));
+
+    return { executableDefinitions, unsupportedResults, unsupportedValidatorIds };
+  }
+
+  private createSkipReason(validatorId: ValidatorId, projectLanguages: readonly string[]): string {
+    const supportedLanguages = VALIDATOR_LANGUAGE_CAPABILITIES[validatorId.value] ?? DEFAULT_SUPPORTED_LANGUAGES;
+    return `unsupported-language: ${validatorId.value} currently supports ${supportedLanguages.join(', ')}; project languages are ${projectLanguages.join(', ')}`;
+  }
+}

package/scripts/harness/validator-system/infrastructure/adapters/file-system-security-pattern-scanner-adapter.ts

@@ -40,12 +40,14 @@ export class FileSystemSecurityPatternScannerAdapter implements SecurityPatternS
     for (const filePath of targetPaths) {
       try {
         const content = await readFile(filePath, 'utf-8');
-        if (content.includes(ALLOWLIST_MARKER)) {
-          continue;
-        }
         const lines = content.split('\n');
         lines.forEach((line, idx) => {
-          if (isAllowlisted(line, content)) {
+          // WI-120: allowlist は行/領域スコープ。以前はファイル内のどこかに
+          // マーカーが 1 つでもあればファイル全体をスキップしていたため、同一
+          // ファイル内の本物の秘密情報も検出漏れしていた。マーカーは当該行、
+          // または直前行（次行抑止コメント）にある場合のみ有効とする。
+          const previousLine = idx > 0 ? lines[idx - 1] : undefined;
+          if (isAllowlisted(line, previousLine)) {
             return;
           }
           for (const { pattern, description, ruleId } of SECURITY_PATTERNS) {
@@ -71,9 +73,17 @@ export class FileSystemSecurityPatternScannerAdapter implements SecurityPatternS
   }
 }
 
-function isAllowlisted(line: string, content: string): boolean {
+/**
+ * 当該行が allowlist されているか判定する（行/領域スコープ）。
+ *
+ * - 当該行にマーカーがある → 許可
+ * - 直前行にマーカーがある（次行抑止コメント） → 許可
+ *
+ * ファイル全体を対象にしないことで、同一ファイル内の本物の秘密情報を検出できる。
+ */
+function isAllowlisted(line: string, previousLine: string | undefined): boolean {
   if (line.includes(ALLOWLIST_MARKER)) return true;
-  return /@example|dummy|placeholder/i.test(line) && content.includes(ALLOWLIST_MARKER);
+  return previousLine?.includes(ALLOWLIST_MARKER) ?? false;
 }
 
 function redactSecret(secretValue: string): string {

package/scripts/harness/validator-system/infrastructure/adapters/file-system-work-item-reflection-adapter.ts

@@ -18,6 +18,13 @@ function normalizePath(value: string): string {
   return value.replace(/\\/g, '/');
 }
 
+// Separator-agnostic check for whether a path points at a work-item
+// description file. Exported so the Windows (`\`) normalization is unit
+// testable without depending on the host filesystem separator.
+export function isDescriptionFilePath(value: string): boolean {
+  return normalizePath(value).endsWith(`/${DESCRIPTION_FILE}`);
+}
+
 async function listFiles(root: string): Promise<string[]> {
   try {
     const entries = await readdir(root, { withFileTypes: true });
@@ -66,7 +73,9 @@ export class FileSystemWorkItemReflectionAdapter implements WorkItemReflectionPo
     const inceptionRoot = join(this.projectRoot, input.inceptionRoot);
     const designRoot = join(this.projectRoot, input.designRoot);
     const descriptionFiles = (await listFiles(inceptionRoot))
-      .filter((path) => path.endsWith(`/${DESCRIPTION_FILE}`));
+      // Normalize separators first so Windows paths (which use `\`) still match
+      // the `/description.md` suffix.
+      .filter(isDescriptionFilePath);
 
     if (descriptionFiles.length === 0) {
       return {

package/scripts/harness/validator-system/infrastructure/adapters/harness-config-validator-config-adapter.ts

@@ -2,6 +2,7 @@
  * @layer infrastructure
  * @unit validator-system
  * @work-item-id WI-156
+ * @work-item-id WI-212
  *
  * HarnessConfigValidatorConfigAdapter — ValidatorConfigPort実装
  * HarnessConfigV2からLayerConfig VOを構築する
@@ -18,7 +19,7 @@ export interface HarnessConfigLayers {
 
 export interface HarnessConfigV2Like {
   preset?: 'minimal' | 'standard' | 'strict';
-  project?: { preset?: 'minimal' | 'standard' | 'strict' };
+  project?: { preset?: 'minimal' | 'standard' | 'strict'; languages?: readonly string[] };
   layers?: HarnessConfigLayers;
   harnesses?: {
     bundleSizeLimit?: number;
@@ -71,6 +72,11 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
     });
   }
 
+  async getProjectLanguages(): Promise<readonly string[]> {
+    const languages = this.config.project?.languages;
+    return languages && languages.length > 0 ? [...languages] : ['typescript'];
+  }
+
   private normalizeValidatorId(idOrName: string): string {
     try {
       return ValidatorId.create(idOrName).value;

package/scripts/harness/validator-system/infrastructure/adapters/import-graph-source-analysis-adapter.ts

@@ -137,9 +137,7 @@ function extractExports(content: string): string[] {
 function resolveImportTarget(fromFile: string, specifier: string, fileSet: ReadonlySet<string>): string | null {
   if (!specifier.startsWith('.')) return null;
   const base = resolve(dirname(fromFile), specifier);
-  const candidates = extname(base)
-    ? [base]
-    : [`${base}.ts`, `${base}.tsx`, join(base, 'index.ts'), join(base, 'index.tsx')];
+  const candidates = buildResolutionCandidates(base);
   for (const candidate of candidates) {
     const normalized = normalize(candidate);
     if (fileSet.has(normalized)) return normalized;
@@ -147,6 +145,40 @@ function resolveImportTarget(fromFile: string, specifier: string, fileSet: Reado
   return null;
 }
 
+/**
+ * import 指定子から実ファイル候補を生成する。
+ *
+ * このプロジェクトは ESM 規約に従い `./foo.js` と書いて実体 `foo.ts` を参照する
+ * （TypeScript の `.js` 拡張子付き import）。素朴に extname を見ると `.js` 実体を
+ * 探しに行き解決に失敗するため、`.js`/`.jsx`/`.mjs`/`.cjs` 拡張子は対応する
+ * TypeScript 拡張子（およびディレクトリの index）へマッピングした候補も加える。
+ */
+function buildResolutionCandidates(base: string): string[] {
+  const ext = extname(base);
+  const JS_TO_TS: Record<string, readonly string[]> = {
+    '.js': ['.ts', '.tsx'],
+    '.jsx': ['.tsx', '.ts'],
+    '.mjs': ['.mts', '.ts'],
+    '.cjs': ['.cts', '.ts'],
+  };
+
+  if (ext) {
+    const mapped = JS_TO_TS[ext];
+    if (mapped) {
+      const withoutExt = base.slice(0, base.length - ext.length);
+      // 例: `./foo.js` → `foo.ts` / `foo.tsx`、`./dir.js`(ディレクトリ)→ `dir/index.ts`
+      return [
+        ...mapped.map((tsExt) => `${withoutExt}${tsExt}`),
+        base,
+        ...mapped.map((tsExt) => join(withoutExt, `index${tsExt}`)),
+      ];
+    }
+    return [base];
+  }
+
+  return [`${base}.ts`, `${base}.tsx`, join(base, 'index.ts'), join(base, 'index.tsx')];
+}
+
 function classifyDeadCodeExclusion(filePath: string): string | undefined {
   const normalized = filePath.replaceAll('\\', '/');
   if (/(^|\/)__tests__\//.test(normalized) || /\.test\.ts$/.test(normalized) || /\.it\.test\.ts$/.test(normalized)) {

package/scripts/harness/validator-system/infrastructure/adapters/nyquist-ac-coverage-policy-adapter.ts

@@ -3,39 +3,111 @@
  * @unit validator-system
  *
  * NyquistAcCoveragePolicyAdapter — AcCoveragePolicyPort実装
+ *
+ * FAIL-CLOSED: nyquist-validation モジュールの実行時に例外が発生した場合は
+ * passed=false（不合格）として扱い、エラーを結果に含めて上位へ通知する。
+ * かつては catch 節で passed=true を返す fail-open だったが、AC 網羅ゲート
+ * （L3-004）を無効化する重大な品質防御の抜け穴だったため fail-closed へ是正した。
+ *
+ * REAL REGISTRY: storyId 整合性検査に必要な有効 storyId 一覧を
+ * traceability-model の StoryCatalog から取得して nyquist モジュールへ配線する。
+ * かつては `getStoryIds: async () => []`（空スタブ）だったため、正当かつ完全網羅の
+ * マトリクスでも全 storyId が「未登録」と判定され L3-004 が構造的に PASS 不能だった。
+ *
+ * MATRIX PATH: requirement-test-matrix.json のパスは config
+ * （layers.L3.requirementMatrixPath）から供給される。未指定時は既定値
+ * `.harness/requirement-test-matrix.json` を用いる。マトリクスが不在の場合は
+ * fail-closed で「設定されているが不在」という実行可能なメッセージを返す。
  */
+import { access } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
 import type { AcCoveragePolicyPort } from '../../domain/ports/ac-coverage-policy-port.js';
 import type { HarnessErrorLike } from '../../domain/value-objects/validation-result.js';
 
+const DEFAULT_MATRIX_PATH = '.harness/requirement-test-matrix.json';
+
+function toL3004Error(message: string, suggestion: string): HarnessErrorLike {
+  return {
+    code: { value: 'L3-004', toString: () => 'L3-004' },
+    severity: { value: 'error', toString: () => 'error' },
+    message,
+    suggestion,
+  };
+}
+
 export class NyquistAcCoveragePolicyAdapter implements AcCoveragePolicyPort {
   async checkCoverage(context: { matrixFilePath?: string }): Promise<{
     passed: boolean;
     errors: readonly HarnessErrorLike[];
   }> {
+    const rootDir = process.cwd();
+    const relativeOrAbsolute =
+      context.matrixFilePath && context.matrixFilePath.length > 0
+        ? context.matrixFilePath
+        : DEFAULT_MATRIX_PATH;
+    const matrixFilePath = isAbsolute(relativeOrAbsolute)
+      ? relativeOrAbsolute
+      : join(rootDir, relativeOrAbsolute);
+
+    // マトリクス不在は threshold-configured-but-absent と同様に fail-closed で
+    // 明確なメッセージを返す（ENOENT の生メッセージで落とさない）。
+    try {
+      await access(matrixFilePath);
+    } catch {
+      return {
+        passed: false,
+        errors: [
+          toL3004Error(
+            `AC網羅マトリクスが見つかりません: ${relativeOrAbsolute}（L3-004 は fail-closed）`,
+            `${relativeOrAbsolute} を生成してください（phasegate:generate-matrix）。パスは config の layers.L3.requirementMatrixPath で変更できます`,
+          ),
+        ],
+      };
+    }
+
     try {
+      // 有効 storyId 一覧を traceability-model の StoryCatalog から取得する（REAL registry）
+      const storyIds = await this.loadValidStoryIds(rootDir);
+
       const { createNyquistValidationModule } = await import('../../../nyquist-validation/composition-root.js');
       const mod = createNyquistValidationModule({
-        rootDir: process.cwd(),
-        getStoryIds: async () => [],
-      } as {
-        rootDir: string;
-        getStoryIds: () => Promise<readonly string[]>;
+        getStoryIds: async () => storyIds,
       });
       const output = await mod.checkAcCoverageGateUseCase.execute({
-        matrixFilePath: context.matrixFilePath ?? '',
+        matrixFilePath,
       });
 
       return {
         passed: output.passed,
-        errors: output.errors.map((err) => ({
-          code: { value: 'L3-004', toString: () => 'L3-004' },
-          severity: { value: 'error', toString: () => 'error' },
-          message: err.message,
-          suggestion: '',
-        })),
+        errors: output.errors.map((err) =>
+          toL3004Error(err.message, ''),
+        ),
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      // FAIL-CLOSED: 例外を握り潰して合格扱いにせず、不合格として通知する
+      return {
+        passed: false,
+        errors: [
+          toL3004Error(
+            `AC網羅ゲートの検査に失敗しました（fail-closed）: ${message}`,
+            'requirement-test-matrix.json の存在・形式・スキーマ整合性を確認してください',
+          ),
+        ],
       };
-    } catch {
-      return { passed: true, errors: [] };
     }
   }
+
+  private async loadValidStoryIds(rootDir: string): Promise<readonly string[]> {
+    const { createConfigFoundationModule } = await import('../../../config-foundation/composition-root.js');
+    const configModule = createConfigFoundationModule();
+    const resolvedConfig = await configModule.usecases.loadResolvedConfigUseCase.execute();
+
+    const { createTraceabilityModelModule } = await import('../../../traceability-model/composition-root.js');
+    const traceModule = createTraceabilityModelModule(rootDir, {
+      pathRoots: { designDocsRoot: resolvedConfig.config.paths.designDocs },
+    });
+    const storyIds = await traceModule.storyCatalog.getAllStoryIds();
+    return storyIds.map((s) => s.value);
+  }
 }

package/scripts/harness/validator-system/infrastructure/adapters/phase-dependency-phase-gate-policy-adapter.ts

@@ -51,9 +51,35 @@ export class PhaseDependencyPhaseGatePolicyAdapter implements PhaseGatePolicyPor
         };
       }
 
-      return { satisfied: true, violations: [] };
-    } catch {
-      return { satisfied: true, violations: [] };
+      // Fail-closed: an unexpected exit code means prerequisites could not be confirmed.
+      console.error(`[validator-system] phase gate check returned unexpected exit code ${result.exitCode}`);
+      return {
+        satisfied: false,
+        violations: [
+          {
+            code: { value: 'L2-002', toString: () => 'L2-002' },
+            severity: { value: 'error', toString: () => 'error' },
+            message: `phase gate check returned unexpected exit code ${result.exitCode}; prerequisites cannot be confirmed`,
+            suggestion: 'phase gate prerequisites could not be evaluated; treating as NOT satisfied (fail-closed)',
+          },
+        ],
+      };
+    } catch (err) {
+      // Fail-closed: if the phase-dependency-model could not be loaded/executed we cannot
+      // confirm prerequisites are met, so treat them as NOT satisfied rather than opening the gate.
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[validator-system] phase gate prerequisite check failed to run: ${message}`);
+      return {
+        satisfied: false,
+        violations: [
+          {
+            code: { value: 'L2-002', toString: () => 'L2-002' },
+            severity: { value: 'error', toString: () => 'error' },
+            message: `phase gate prerequisite check could not be evaluated: ${message}`,
+            suggestion: 'phase gate prerequisites could not be evaluated; treating as NOT satisfied (fail-closed)',
+          },
+        ],
+      };
     }
   }
 }

package/skills/cascade-updater/SKILL.md

@@ -3,6 +3,7 @@ name: cascade-updater
 description: 下位フェーズの発見・変更を上位設計文書にフィードバックし影響範囲を整合的に更新
 model: sonnet
 review: opus
+languages: [typescript]
 ---
 
 # Cascade Updater

package/skills/codebase-mapper/SKILL.md

@@ -3,6 +3,7 @@ name: codebase-mapper
 description: コードベースの構造マップを生成するスキル。全ソースファイルの `@unit`/`@layer` アノテーションを解析し、Unit・レイヤー分布・Unit間依存関係・循環依存を可視化したマップ文書を出力する。L4バリデータ（drift-detection/dead-code）の入力精度向上にも使用。使用タイミング: 「コードベースの構造を把握したい」「Unitマップを作って」「どのファイルがどのUnitに属するか調べて」「依存関係を可視化して」など。
 model: sonnet
 review: opus
+languages: [typescript]
 ---
 
 # Codebase Mapper