phasegate 0.140.0 → 0.141.0

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.141.0] - 2026-05-09
+
+### Fixed
+
+- **WI-024 follow-up — metadataTags suggestion text** — `architecture.metadataTags.unit` / `architecture.metadataTags.layer` を使った L1-001 / L1-002 の `suggestion` も、固定の `@unit` / `@layer` ではなく設定タグ名を表示するようにした。
+
 ## [0.140.0] - 2026-05-09
 
 ### Added

package/README.ja.md

@@ -148,7 +148,8 @@ npx phasegate update-skills   # スキルを最新版に再デプロイ
 |     security, performance, coverage 90%/95%, 要件カバレッジ        |
 +------------------------------------------------------------------+
 | L4  週次 (default off)                                           |
-|     設計-コード乖離, 文書整合性, デッドコード                    |
+|     設計-コード乖離, 文書整合性, デッドコード,                  |
+|     doc-freshness, pointer-validation                            |
 +------------------------------------------------------------------+
 ```
 
@@ -455,7 +456,7 @@ reports/
 
 | Work Item | 内容 |
 |---|---|
-| **[WI-033](docs/inception/_cross/WI-033/description.md)** | `doc-freshness` / `pointer-validation` を L4 validator に昇格 |
+| **[WI-033](docs/inception/_cross/WI-033/description.md)** | L4 運用ロールアウトの仕上げ。`doc-freshness` / `pointer-validation` は L4-004 / L4-005 として登録済みで、`p2:*` 互換コマンドも維持。残りは scheduling / default / 運用 docs の整理。@work-item-id WI-116 |
 
 L3 Nyquist Validation の `requirement-test-matrix.json` 自動生成はまだ未自動化です。現時点では手動セットアップで利用できます。
 

package/README.md

@@ -156,7 +156,7 @@ npx phasegate update-skills
 | L1 | Editor save / `phasegate lint` | `@unit` / `@layer` metadata, layer violations, AI anti-patterns, dead code |
 | L2 | Pre-commit (also evaluated inside PreToolUse at L0) | Phase gate, metadata completeness, `@work-item-id` reflection (`L2-STORY-REFLECTION`), test quality |
 | L3 | CI/CD pipeline | Security, performance, coverage (90%/95%), requirements traceability |
-| L4 | Scheduled (weekly). Currently `layers.L4.enabled: false` by default — opt-in per project | Design-code drift, cross-document consistency, dead code. Doc freshness and pointer checks are standalone `p2:*` commands until WI-033. |
+| L4 | Scheduled (weekly). Currently `layers.L4.enabled: false` by default — opt-in per project | Design-code drift, cross-document consistency, dead code, doc freshness, and pointer validation. `p2:*` standalone commands remain available as compatibility entry points. |
 
 ---
 
@@ -466,8 +466,8 @@ npx phasegate <command> [options]
 |---|---|
 | `init --name <name>` | Initialize project, deploy skills, generate config. Use `--with-ci` to deploy GitHub Actions workflows. |
 | `lint` | Run L1 Biome AST checks |
-| `validate --layer <L2-L4\|all>` | Run validators for specified layer (`--layer L0` prints runtime hook guidance) |
-| `ci-check` | Full CI check (L2-L4) |
+| `validate --layer <L1-L4\|all>` | Run validators for specified layer (`--layer L0` prints runtime hook guidance; explicit L4 runs even when scheduled L4 is disabled) |
+| `ci-check` | Full CI check (L2-L4; disabled L4 is reported as skipped) |
 | `ci:generate-template --type <aidlc-gate\|consistency-check\|pre-commit\|agent-context-refresh> --render` | Render the bundled CI/hook template to stdout |
 | `ci:auto-refresh-agent-context --dry-run` / `--apply` | Refresh AGENTS.md pointers and CLAUDE.md standard sections |
 | `refresh-claude-md --dry-run` / `--apply` | Refresh only CLAUDE.md while preserving the user-owned section |
@@ -517,7 +517,7 @@ The main path is ready for project use, but a few documented behaviors still req
 
 | Work Item | Title | Why it matters |
 |---|---|---|
-| **[WI-033](docs/inception/_cross/WI-033/description.md)** | Promote `doc-freshness` / `pointer-validation` to L4 validators | Both capabilities exist as `p2:check-freshness` / `p2:validate-pointers` CLI commands but are not registered as L4 validators, so `validate --layer L4` skips them. WI-033 plumbs them through `validator-system` so they run via the standard L4 path and presets. |
+| **[WI-033](docs/inception/_cross/WI-033/description.md)** | Finish L4 operational rollout | `doc-freshness` and `pointer-validation` are registered as L4-004/L4-005 and also remain available through `p2:*` compatibility commands. Remaining WI-033 work is rollout polish around scheduling, defaults, and operational docs. @work-item-id WI-116 |
 
 `requirement-test-matrix.json` auto-generation for L3 Nyquist Validation is not automated yet; see the L3 guide for the current manual setup.
 

package/docs/guide/cli-reference.md

@@ -261,7 +261,7 @@ Commands exposed as npm scripts (`npm run <command>`).
 | `phasegate:status` | `--json` | Health summary |
 | `phasegate:check-ready` | `--json` | Phase Gate pass status for all stories |
 | `phasegate:check-phase` | `--unit <unitId>` `--json` | Current phase for a unit |
-| `phasegate:ci-check` | `--json` | All L3 validators |
+| `phasegate:ci-check` | `--json` | Full CI check (L2-L4; disabled L4 is reported as skipped) |
 | `phasegate:detect-drift` | `--json` | Design-code drift report |
 | `phasegate:lint` | `--target <path>` `--json` | Lint via harness-api |
 | `phasegate:complete-check` | `--json` | L2-L4 full check |

package/docs/guide/layer-model.md

@@ -147,8 +147,11 @@ L4 validators are designed to run on a weekly schedule and detect slow-moving dr
 | **drift-detect** | L4-001 | Bidirectional design-code drift detection. Compares design documents against the actual codebase to find divergence in either direction. |
 | **consistency-check** | L4-002 | Cross-document layer consistency. Ensures that references between design documents, ADRs, and code remain coherent. |
 | **dead-code** | L4-003 | Detects unused exports and unreachable code that should be removed. |
+| **doc-freshness** | L4-004 | Checks design document freshness against the configured threshold. Also available through the `p2:check-freshness` compatibility command. |
+| **pointer-validation** | L4-005 | Resolves and validates design document pointers. Also available through the `p2:validate-pointers` compatibility command. |
 
-`doc-freshness` and `pointer-validation` are implemented as `phase2-extensions` CLI commands (`p2:check-freshness` and `p2:validate-pointers`). They are not registered as L4 validators yet, so `validate --layer L4` does not run them until WI-033 promotes them into `validator-system`.
+<!-- @work-item-id WI-116 -->
+`doc-freshness` and `pointer-validation` are registered as L4-004/L4-005. The standalone `p2:check-freshness` and `p2:validate-pointers` commands remain as compatibility entry points; WI-033's remaining scope is operational rollout, not validator registration.
 
 ### Drift-detect design pointers
 
@@ -219,6 +222,8 @@ Each error catalog entry declares a `defaultSeverity` of `error` or `warning`. A
 
 **Opt-in to strict mode** via `phasegate.config.json` `validate.failOnWarning: true` or CLI `--fail-on-warning` (CLI > config). The `strict` preset defaults to `failOnWarning: true` to match the precedent set by the `ci-governance` preset adapter.
 
+For L4 specifically, `validate --layer L4` is an explicit operator request and runs L4 validators even when `layers.L4.enabled` is false. `validate --layer all` and `phasegate:ci-check` honor disabled L4 as skipped results, so skipped L4 validators are visible in the report but do not become failures under `--fail-on-warning`. @work-item-id WI-107
+
 History: prior to v0.131.0, the aggregator's `failOnWarning` flag was effectively dead code (`hasFail = !result.passed || ...` masked it), so every warning-only fail produced exit 1 regardless of severity declaration. See ADR-017 for the rationale.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.140.0",
+  "version": "0.141.0",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "MIT",

package/scripts/harness/biome-ast-engine/infrastructure/adapters/harness-error-formatter-adapter.ts

@@ -18,6 +18,20 @@ const RULE_SUGGESTIONS: Readonly<Record<string, string>> = {
   'no-comment-flood': '不要なコメントを整理し自己説明的なコードへ改善する',
 };
 
+const METADATA_TAG_MESSAGE_PATTERN = /(@[a-z][a-zA-Z0-9]*)コメントが必要です/;
+
+const resolveSuggestion = (ruleName: string, message: string): string => {
+  if (ruleName === 'require-unit-comment' || ruleName === 'require-layer-comment') {
+    const tagName = message.match(METADATA_TAG_MESSAGE_PATTERN)?.[1];
+
+    if (tagName) {
+      return `ファイル先頭に ${tagName} コメントを追加する`;
+    }
+  }
+
+  return RULE_SUGGESTIONS[ruleName] ?? '';
+};
+
 /**
  * ViolationFormatterPort の実装。
  * RuleViolation をルール名から L1-001〜L1-008 コードへマッピングし、
@@ -40,7 +54,7 @@ export class HarnessErrorFormatterAdapter implements ViolationFormatterPort {
       violations.map((v) => {
         const ruleName = v.ruleName.toString();
         const code = mapRuleNameToCode(ruleName);
-        const suggestion = RULE_SUGGESTIONS[ruleName] ?? '';
+        const suggestion = resolveSuggestion(ruleName, v.message);
 
         const entry: {
           code: string;

package/scripts/harness/biome-ast-engine/infrastructure/adapters/typescript-source-module-analyzer-adapter.ts

@@ -19,6 +19,36 @@ export interface TypeScriptSourceModuleAnalyzerAdapterDeps {
   readonly rootDir: string;
 }
 
+const HARNESS_ROOT_PREFIX = 'scripts/harness/';
+const TESTS_SEGMENT = '__tests__';
+const TEST_SCOPE_SEGMENTS = new Set(['unit', 'integration', 'e2e']);
+
+function deriveUnitNameFromPath(filePath: FilePath): string | null {
+  const normalizedPath = filePath.toString();
+  if (!normalizedPath.startsWith(HARNESS_ROOT_PREFIX)) {
+    return null;
+  }
+
+  const parts = normalizedPath.slice(HARNESS_ROOT_PREFIX.length).split('/');
+  if (parts.length < 2) {
+    return null;
+  }
+
+  if (parts[0] !== TESTS_SEGMENT) {
+    return parts[0] || null;
+  }
+
+  if (parts.length < 3) {
+    return parts[1] || null;
+  }
+
+  if (TEST_SCOPE_SEGMENTS.has(parts[1])) {
+    return parts[2] || null;
+  }
+
+  return parts[1] || null;
+}
+
 /**
  * SourceModuleAnalyzerPort の実装。
  * TypeScript Compiler API を使用して各ファイルから
@@ -69,7 +99,7 @@ export class TypeScriptSourceModuleAnalyzerAdapter implements SourceModuleAnalyz
         SourceModuleSnapshot.create(
           {
             filePath,
-            declaredUnit: unitResult.unitNames[0] ?? null,
+            declaredUnit: unitResult.unitNames[0] ?? deriveUnitNameFromPath(filePath),
             declaredLayer: layerResult.layerName,
             imports,
             anyTypeCount: anyCount,

package/scripts/harness/config-foundation/application/mappers/validator-system-config-mapper.ts

@@ -11,7 +11,7 @@ export function toValidatorSystemConfig(resolvedConfig: HarnessConfigV2 | undefi
   return {
     project: { preset: resolvedConfig.project.preset },
     layers: {
-      L2: { enabled: resolvedConfig.layers.L2.enabled },
+      L2: { enabled: resolvedConfig.layers.L2.enabled, validators: ['L2-001', 'L2-002', 'L2-003', 'L2-013'] },
       L3: { enabled: resolvedConfig.layers.L3.enabled },
       L4: { enabled: resolvedConfig.layers.L4.enabled, validators: resolvedConfig.layers.L4.validators },
     },

package/scripts/harness/harness-api/domain/services/command-dispatch-service.ts

@@ -13,6 +13,7 @@ import type { BiomeLintPort } from '../ports/biome-lint-port.js';
 import type { ImpactAnalysisPort } from '../ports/impact-analysis-port.js';
 import type { ArtifactScannerPort } from '../ports/artifact-scanner-port.js';
 import type { ConfigQueryPort } from '../ports/config-query-port.js';
+import type { LayerId } from '../value-objects/layer-health.js';
 
 export interface CommandDispatchPorts {
   validatorExecutionPort: ValidatorExecutionPort;
@@ -35,6 +36,29 @@ function makeError(message: string): HarnessError {
   return { code: 'HARNESS_ERROR', severity: 'error', message };
 }
 
+type LiveValidationState = 'pass' | 'fail' | 'skipped' | 'not-run' | 'error';
+
+function layerIdFromValidatorId(validatorId: string): LayerId | null {
+  const prefix = validatorId.slice(0, 2);
+  return prefix === 'L1' || prefix === 'L2' || prefix === 'L3' || prefix === 'L4' ? prefix : null;
+}
+
+function summarizeLayerResults(items: readonly { validatorId: string; passed: boolean; skipped?: boolean }[]): Partial<Record<LayerId, LiveValidationState>> {
+  const result: Partial<Record<LayerId, LiveValidationState>> = {};
+  for (const layerId of ['L2', 'L3', 'L4'] as const) {
+    const layerItems = items.filter((item) => layerIdFromValidatorId(item.validatorId) === layerId);
+    if (layerItems.length === 0) continue;
+    if (layerItems.every((item) => item.skipped === true)) {
+      result[layerId] = 'skipped';
+    } else if (layerItems.some((item) => !item.passed && item.skipped !== true)) {
+      result[layerId] = 'fail';
+    } else {
+      result[layerId] = 'pass';
+    }
+  }
+  return result;
+}
+
 const KNOWN_COMMANDS = new Set([
   'phasegate:check-ready',
   'phasegate:check-phase',
@@ -131,7 +155,7 @@ export class CommandDispatchService {
       }
 
       case 'phasegate:ci-check': {
-        const validatorResults = await this.ports.validatorExecutionPort.runL3Validators();
+        const validatorResults = await this.ports.validatorExecutionPort.runAllValidators();
         const result = CiCheckResult.fromResults(validatorResults);
         if (result.allPassed) {
           const r = HarnessApiResponse.pass({ ...summary, passed: 1 }, result);
@@ -152,13 +176,23 @@ export class CommandDispatchService {
           const r = HarnessApiResponse.pass({ ...summary, passed: 1 }, result);
           return { status: 'pass', errors: [], summary: r.summary, data: result as unknown as T, exitCode: 0 };
         }
-        const errors = drifts.map((d) => makeError(`Drift detected in ${d.unit}: ${d.element}`));
-        const r = HarnessApiResponse.fail(errors, { ...summary, failed: 1 }, result);
-        return { status: 'fail', errors: r.errors, summary: r.summary, data: result as unknown as T, exitCode: 1 };
+        const r = HarnessApiResponse.pass({ ...summary, passed: 1, warnings: drifts.length }, result);
+        return { status: 'pass', errors: [], summary: r.summary, data: result as unknown as T, exitCode: 0 };
       }
 
       case 'phasegate:status': {
         const scanResult = await this.ports.artifactScannerPort.scan();
+        const liveValidationByLayer: Partial<Record<LayerId, LiveValidationState>> = {};
+        try {
+          const [lintResult, validatorResults] = await Promise.all([
+            this.ports.biomeLintPort.runLint(),
+            this.ports.validatorExecutionPort.runAllValidators(),
+          ]);
+          liveValidationByLayer.L1 = lintResult.passed ? 'pass' : 'fail';
+          Object.assign(liveValidationByLayer, summarizeLayerResults(validatorResults));
+        } catch {
+          liveValidationByLayer.L1 = liveValidationByLayer.L1 ?? 'error';
+        }
         let presetInfo = { name: 'standard' as const, enabledLayers: ['L1', 'L2', 'L3'] as ('L1' | 'L2' | 'L3' | 'L4')[] };
         const configPort = this.ports.configQueryPort;
         if (configPort.getPresetInfo) {
@@ -172,6 +206,7 @@ export class CommandDispatchService {
           presetInfo,
           configSummary: { configPath: 'phasegate.config.json', lastModified: '', version: '2' },
           phaseGateSummary: { totalStories: 0, passedStories: 0, pendingStories: 0 },
+          liveValidationByLayer,
         });
         const r = HarnessApiResponse.pass({ ...summary, passed: 1 }, statusSummary);
         return { status: 'pass', errors: [], summary: r.summary, data: statusSummary as unknown as T, exitCode: 0 };

package/scripts/harness/harness-api/domain/services/status-derivation-service.ts

@@ -88,27 +88,44 @@ export class StatusDerivationService {
     presetInfo: PresetInfo;
     configSummary: ConfigSummary;
     phaseGateSummary: PhaseGateSummary;
+    liveValidationByLayer?: Partial<Record<LayerId, 'pass' | 'fail' | 'skipped' | 'not-run' | 'error'>>;
   }): HarnessStatusSummary {
-    const { scanResult, presetInfo, configSummary, phaseGateSummary } = input;
+    const { scanResult, presetInfo, configSummary, phaseGateSummary, liveValidationByLayer } = input;
 
     const layers: LayerHealth[] = ALL_LAYER_IDS.map((layerId) => {
       const enabled = presetInfo.enabledLayers.includes(layerId);
+      const configurationState = enabled ? 'enabled' : 'disabled';
 
       // Find from derivedLayerHealth
       const existing = scanResult.derivedLayerHealth.find((l) => l.layerId === layerId);
+      const layerArtifacts = scanResult.foundArtifacts.filter((a) => getLayerId(a) === layerId);
+      const hasPresent = layerArtifacts.some((a) => a.present === true);
+      const cachedArtifactState = hasPresent ? 'present' : 'missing';
+      const liveValidationState = liveValidationByLayer?.[layerId] ?? 'not-run';
+      const liveLastResult =
+        liveValidationState === 'pass' || liveValidationState === 'fail'
+          ? liveValidationState
+          : undefined;
 
       if (enabled) {
-        // Check artifacts
-        const layerArtifacts = scanResult.foundArtifacts.filter((a) => getLayerId(a) === layerId);
-        const hasPresent = layerArtifacts.some((a) => a.present === true);
-
-        if (existing && existing.lastResult) {
-          return LayerHealth.create({ layerId, enabled, lastResult: existing.lastResult });
-        }
-        const lastResult = hasPresent ? 'pass' : 'unknown';
-        return LayerHealth.create({ layerId, enabled, lastResult });
+        const lastResult = liveLastResult ?? existing?.lastResult ?? (hasPresent ? 'pass' : 'unknown');
+        return LayerHealth.create({
+          layerId,
+          enabled,
+          lastResult,
+          configurationState,
+          cachedArtifactState,
+          liveValidationState,
+        });
       } else {
-        return LayerHealth.create({ layerId, enabled: false, lastResult: undefined });
+        return LayerHealth.create({
+          layerId,
+          enabled: false,
+          lastResult: undefined,
+          configurationState,
+          cachedArtifactState,
+          liveValidationState,
+        });
       }
     });
 

package/scripts/harness/harness-api/domain/value-objects/ci-check-result.ts

@@ -6,6 +6,7 @@ import type { HarnessError } from './harness-api-response.js';
 export interface ValidatorCheckItem {
   validatorId: string;
   passed: boolean;
+  skipped?: boolean;
   errors?: readonly HarnessError[];
 }
 
@@ -29,8 +30,8 @@ export class CiCheckResult {
     if (!props.validatorResults || props.validatorResults.length === 0) {
       throw new Error('EmptyValidatorResultsError: validatorResults must have at least one item (INV-5)');
     }
-    // INV-6: allPassed === validatorResults.every(r => r.passed)
-    const computedAllPassed = props.validatorResults.every((r) => r.passed);
+    // INV-6: allPassed === validatorResults.every(r => r.passed || r.skipped)
+    const computedAllPassed = props.validatorResults.every((r) => r.passed || r.skipped);
     if (props.allPassed !== computedAllPassed) {
       throw new Error(
         `HarnessApiDomainError: allPassed=${props.allPassed} does not match validatorResults state (computed: ${computedAllPassed})`
@@ -43,12 +44,12 @@ export class CiCheckResult {
     if (!validatorResults || validatorResults.length === 0) {
       throw new Error('EmptyValidatorResultsError: validatorResults must have at least one item (INV-5)');
     }
-    const allPassed = validatorResults.every((r) => r.passed);
+    const allPassed = validatorResults.every((r) => r.passed || r.skipped);
     return new CiCheckResult(validatorResults, allPassed);
   }
 
   getFailedValidators(): readonly ValidatorCheckItem[] {
-    return this.validatorResults.filter((r) => !r.passed);
+    return this.validatorResults.filter((r) => !r.passed && !r.skipped);
   }
 
   collectAllErrors(): readonly HarnessError[] {

package/scripts/harness/harness-api/domain/value-objects/drift-report-summary.ts

@@ -8,18 +8,117 @@ export interface DriftItem {
   recommendation: string;
 }
 
+type DriftCategory =
+  | 'code-missing-design'
+  | 'design-missing-code'
+  | 'missing-pointer'
+  | 'design-granularity-mismatch'
+  | 'uncategorized';
+type DriftSeverity = 'info' | 'warning' | 'error';
+
+export interface ActionableDriftItem extends DriftItem {
+  category: DriftCategory;
+  severity: DriftSeverity;
+  nextAction: string;
+}
+
+export interface DriftCategorySummary {
+  category: DriftCategory;
+  severity: DriftSeverity;
+  count: number;
+  nextAction: string;
+}
+
 export interface DriftReportSummaryProps {
   drifts: readonly DriftItem[];
   totalCount: number;
+  sampleLimit?: number;
+}
+
+const DEFAULT_SAMPLE_LIMIT = 20;
+
+function classifyDrift(drift: DriftItem): { category: DriftCategory; severity: DriftSeverity; nextAction: string } {
+  const direction = drift.direction.toLowerCase();
+  const recommendation = drift.recommendation.toLowerCase();
+  const element = drift.element.toLowerCase();
+
+  if (recommendation.includes('pointer') || recommendation.includes('@work-item-id')) {
+    return {
+      category: 'missing-pointer',
+      severity: 'warning',
+      nextAction: 'Add or repair the traceability pointer before changing gating policy.',
+    };
+  }
+  if (element.includes('heading') || recommendation.includes('granularity')) {
+    return {
+      category: 'design-granularity-mismatch',
+      severity: 'info',
+      nextAction: 'Review the design granularity or baseline this class of advisory drift.',
+    };
+  }
+  if (direction.includes('code') && direction.includes('design')) {
+    return {
+      category: direction.indexOf('code') < direction.indexOf('design') ? 'code-missing-design' : 'design-missing-code',
+      severity: 'warning',
+      nextAction:
+        direction.indexOf('code') < direction.indexOf('design')
+          ? 'Update the matching product/construction docs with the implementation contract.'
+          : 'Implement the described design element or remove stale design text.',
+    };
+  }
+  return {
+    category: 'uncategorized',
+    severity: 'warning',
+    nextAction: 'Inspect the sampled drift and assign a narrower category or baseline rule.',
+  };
+}
+
+function enrichDrift(drift: DriftItem): ActionableDriftItem {
+  return { ...drift, ...classifyDrift(drift) };
+}
+
+function summarizeByCategory(drifts: readonly ActionableDriftItem[]): readonly DriftCategorySummary[] {
+  const byCategory = new Map<DriftCategory, DriftCategorySummary>();
+  for (const drift of drifts) {
+    const existing = byCategory.get(drift.category);
+    if (existing) {
+      byCategory.set(drift.category, { ...existing, count: existing.count + 1 });
+    } else {
+      byCategory.set(drift.category, {
+        category: drift.category,
+        severity: drift.severity,
+        count: 1,
+        nextAction: drift.nextAction,
+      });
+    }
+  }
+  return [...byCategory.values()].sort((a, b) => b.count - a.count || a.category.localeCompare(b.category));
 }
 
 export class DriftReportSummary {
-  readonly drifts: readonly DriftItem[];
+  readonly drifts: readonly ActionableDriftItem[];
   readonly totalCount: number;
+  readonly rawDriftCount: number;
+  readonly sampleLimit: number;
+  readonly truncated: boolean;
+  readonly categorySummaries: readonly DriftCategorySummary[];
+  readonly actionPlan: readonly DriftCategorySummary[];
 
-  private constructor(drifts: readonly DriftItem[], totalCount: number) {
-    this.drifts = Object.freeze([...drifts]);
+  private constructor(
+    drifts: readonly DriftItem[],
+    totalCount: number,
+    sampleLimit: number = DEFAULT_SAMPLE_LIMIT,
+    summarySource: readonly DriftItem[] = drifts,
+  ) {
+    const enriched = drifts.map(enrichDrift);
+    const enrichedSummarySource = summarySource.map(enrichDrift);
+    this.drifts = Object.freeze(enriched);
     this.totalCount = totalCount;
+    this.rawDriftCount = totalCount;
+    this.sampleLimit = sampleLimit;
+    this.truncated = totalCount > enriched.length;
+    this.categorySummaries = Object.freeze(summarizeByCategory(enrichedSummarySource));
+    this.actionPlan = Object.freeze(this.categorySummaries.slice(0, 5));
     Object.freeze(this);
   }
 
@@ -30,18 +129,18 @@ export class DriftReportSummary {
         `HarnessApiDomainError: totalCount=${props.totalCount} does not match drifts.length=${props.drifts.length} (INV-7)`
       );
     }
-    return new DriftReportSummary(props.drifts, props.totalCount);
+    return new DriftReportSummary(props.drifts, props.totalCount, props.sampleLimit);
   }
 
-  static fromDrifts(drifts: readonly DriftItem[]): DriftReportSummary {
-    return new DriftReportSummary(drifts, drifts.length);
+  static fromDrifts(drifts: readonly DriftItem[], sampleLimit: number = DEFAULT_SAMPLE_LIMIT): DriftReportSummary {
+    return new DriftReportSummary(drifts.slice(0, sampleLimit), drifts.length, sampleLimit, drifts);
   }
 
   hasDrift(): boolean {
-    return this.drifts.length > 0;
+    return this.totalCount > 0;
   }
 
-  filterByUnit(unitId: string): readonly DriftItem[] {
+  filterByUnit(unitId: string): readonly ActionableDriftItem[] {
     return this.drifts.filter((d) => d.unit === unitId);
   }
 }

package/scripts/harness/harness-api/domain/value-objects/layer-health.ts

@@ -3,6 +3,9 @@
 
 export type LayerId = 'L1' | 'L2' | 'L3' | 'L4';
 type LastResult = 'pass' | 'fail' | 'unknown' | undefined;
+type ConfigurationState = 'enabled' | 'disabled';
+type CachedArtifactState = 'present' | 'missing' | 'unknown';
+type LiveValidationState = 'pass' | 'fail' | 'skipped' | 'not-run' | 'error';
 
 const VALID_LAYER_IDS: readonly LayerId[] = ['L1', 'L2', 'L3', 'L4'];
 const VALID_LAST_RESULTS: readonly string[] = ['pass', 'fail', 'unknown'];
@@ -11,17 +14,33 @@ export interface LayerHealthProps {
   layerId: string;
   enabled: boolean;
   lastResult?: string;
+  configurationState?: ConfigurationState;
+  cachedArtifactState?: CachedArtifactState;
+  liveValidationState?: LiveValidationState;
 }
 
 export class LayerHealth {
   readonly layerId: LayerId;
   readonly enabled: boolean;
   readonly lastResult: LastResult;
+  readonly configurationState: ConfigurationState;
+  readonly cachedArtifactState: CachedArtifactState;
+  readonly liveValidationState: LiveValidationState;
 
-  private constructor(layerId: LayerId, enabled: boolean, lastResult: LastResult) {
+  private constructor(
+    layerId: LayerId,
+    enabled: boolean,
+    lastResult: LastResult,
+    configurationState: ConfigurationState,
+    cachedArtifactState: CachedArtifactState,
+    liveValidationState: LiveValidationState,
+  ) {
     this.layerId = layerId;
     this.enabled = enabled;
     this.lastResult = lastResult;
+    this.configurationState = configurationState;
+    this.cachedArtifactState = cachedArtifactState;
+    this.liveValidationState = liveValidationState;
     Object.freeze(this);
   }
 
@@ -35,7 +54,10 @@ export class LayerHealth {
     return new LayerHealth(
       props.layerId as LayerId,
       props.enabled,
-      props.lastResult as LastResult
+      props.lastResult as LastResult,
+      props.configurationState ?? (props.enabled ? 'enabled' : 'disabled'),
+      props.cachedArtifactState ?? 'unknown',
+      props.liveValidationState ?? 'not-run',
     );
   }
 

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

@@ -45,6 +45,7 @@ export class ValidatorSystemExecutionAdapter implements ValidatorExecutionPort {
         return results.map((r) => ({
           validatorId: r.validatorId,
           passed: r.passed,
+          skipped: r.skipped,
           errors: r.errors.map((e) => ({ code: e.code, severity: e.severity, message: e.message })),
         }));
       },
@@ -56,6 +57,7 @@ export class ValidatorSystemExecutionAdapter implements ValidatorExecutionPort {
         return report.results.map((r) => ({
           validatorId: r.validatorId,
           passed: r.passed,
+          skipped: r.skipped,
           errors: r.errors.map((e) => ({ code: e.code, severity: e.severity, message: e.message })),
         }));
       },

package/scripts/harness/integrations/pre-commit.ts

@@ -18,7 +18,6 @@ import { execSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { createConfigFoundationModule } from "../config-foundation/composition-root.js";
 import { toValidatorSystemConfig } from "../config-foundation/application/mappers/validator-system-config-mapper.js";
-import { ConfigNotFoundError } from "../config-foundation/infrastructure/repositories/file-system-config-repository.js";
 import { createTraceabilityModelModule } from "../traceability-model/composition-root.js";
 import type { ValidateMetadataCommandOutput } from "../traceability-model/presentation/cli/validate-metadata-command-handler.js";
 import type { AggregatedValidationReport } from "../validator-system/application/dto/aggregated-validation-report.js";
@@ -38,13 +37,17 @@ const WORK_ITEM_PATH_PATTERN = /(?:^|\/)WI-\d+(?:\/|$)/;
 const WORK_ITEM_TRAILER_PATTERN = /^Work-Item:\s*WI-\d+\s*$/m;
 const TEST_FILE_SUFFIXES = Object.freeze([".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx"]);
 
+function isConfigNotFoundError(err: unknown): boolean {
+  return err instanceof Error && err.name === "ConfigNotFoundError";
+}
+
 async function loadValidatorSystemConfig(): Promise<object | undefined> {
   const configMod = createConfigFoundationModule();
   try {
     const resolvedConfig = await configMod.usecases.loadResolvedConfigUseCase.execute();
     return toValidatorSystemConfig(resolvedConfig.config);
   } catch (err) {
-    if (err instanceof ConfigNotFoundError) return undefined;
+    if (isConfigNotFoundError(err)) return undefined;
     throw err;
   }
 }
@@ -57,7 +60,7 @@ async function loadTraceabilityModelOptions(): Promise<
     const resolvedConfig = await configMod.usecases.loadResolvedConfigUseCase.execute();
     return { pathRoots: { designDocsRoot: resolvedConfig.config.paths.designDocs } };
   } catch (err) {
-    if (err instanceof ConfigNotFoundError) return undefined;
+    if (isConfigNotFoundError(err)) return undefined;
     throw err;
   }
 }
@@ -68,7 +71,7 @@ async function loadPreCommitImplementationExtensions(): Promise<readonly string[
     const resolvedConfig = await configMod.usecases.loadResolvedConfigUseCase.execute();
     return resolvedConfig.config.preCommit?.implementationExtensions;
   } catch (err) {
-    if (err instanceof ConfigNotFoundError) return undefined;
+    if (isConfigNotFoundError(err)) return undefined;
     throw err;
   }
 }

package/scripts/harness/main.ts

@@ -192,6 +192,13 @@ function parseTriStateFlag(args: readonly string[], positiveFlag: string, negati
   return positiveIdx > negativeIdx;
 }
 
+function parseValidateFormat(args: readonly string[]): "human" | "agent" | "ci" | undefined {
+  const raw = parseFlag(args, "--format");
+  if (raw === undefined) return undefined;
+  if (raw === "human" || raw === "agent" || raw === "ci") return raw;
+  throw new Error(`Invalid --format value for validate: '${raw}'. Supported values: human, agent, ci.`);
+}
+
 function levenshtein(a: string, b: string): number {
   const m = a.length;
   const n = b.length;
@@ -1024,7 +1031,7 @@ async function main(): Promise<void> {
         const layer = parseFlag(args, "--layer") as "L0" | "L2" | "L3" | "L4" | "all" | undefined;
         const unit = parseFlag(args, "--unit");
         const phase = parseFlag(args, "--phase");
-        const format = parseFlag(args, "--format") as "human" | "agent" | "ci" | undefined;
+        const format = parseValidateFormat(args);
         // WI-094 / ADR-017: --fail-on-warning / --no-fail-on-warning / 未指定→config値
         const failOnWarning = parseTriStateFlag(args, "--fail-on-warning", "--no-fail-on-warning");
         const noL4 = hasFlag(args, "--no-l4");

package/scripts/harness/phase-dependency-model/infrastructure/filesystem/file-system-story-reflection-adapter.ts

@@ -146,7 +146,12 @@ export class FileSystemStoryReflectionAdapter implements StoryReflectionFileSyst
     }
 
     const legacyId = await this.readLegacyId(storyId);
-    return legacyId !== null && annotationIds.includes(legacyId);
+    if (legacyId === null || !annotationIds.includes(legacyId)) {
+      return false;
+    }
+
+    const unitId = this.extractProductUnitId(productPath);
+    return !(await this.isAmbiguousLegacyId(legacyId, storyId, unitId));
   }
 
   private extractAnnotationIds(content: string): readonly string[] {
@@ -182,6 +187,47 @@ export class FileSystemStoryReflectionAdapter implements StoryReflectionFileSyst
     return null;
   }
 
+  private extractProductUnitId(productPath: string): string | null {
+    const normalized = productPath.split(path.sep).join("/");
+    const match = /^docs\/product\/construction\/([^/]+)\//.exec(normalized);
+    return match?.[1] ?? null;
+  }
+
+  private async isAmbiguousLegacyId(legacyId: string, storyId: string, unitId: string | null): Promise<boolean> {
+    const scopedStoryIds = unitId === null
+      ? await this.listAllWorkItemDirectories()
+      : await this.listStoryDirectories(unitId);
+    const matchingStoryIds: string[] = [];
+
+    for (const candidateStoryId of scopedStoryIds) {
+      const candidateLegacyId = await this.readLegacyId(candidateStoryId);
+      if (candidateLegacyId === legacyId) {
+        matchingStoryIds.push(candidateStoryId);
+      }
+    }
+
+    return matchingStoryIds.length > 1 || (matchingStoryIds.length === 1 && matchingStoryIds[0] !== storyId);
+  }
+
+  private async listAllWorkItemDirectories(): Promise<readonly string[]> {
+    const ids = new Set<string>();
+    for (const id of await this.listCrossWorkItemDirectories()) {
+      ids.add(id);
+    }
+
+    const inceptionDir = path.join(this.rootDir, this.inceptionRoot);
+    for (const entry of await this.readDirectories(inceptionDir)) {
+      if (!entry.isDirectory()) continue;
+      const name = entry.name;
+      if (name.startsWith("_") || name.startsWith(".") || name === "issues") continue;
+      for (const id of await this.listUnitWorkItemDirectories(name)) {
+        ids.add(id);
+      }
+    }
+
+    return [...ids].sort();
+  }
+
   private async listDescriptionCandidates(storyId: string): Promise<readonly string[]> {
     const inceptionDir = path.join(this.rootDir, this.inceptionRoot);
     const candidates: string[] = [path.join(inceptionDir, "_cross", storyId, "description.md")];

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

@@ -9,38 +9,28 @@ import { ValidatorId } from '../../domain/value-objects/validator-id.js';
 import { ValidationResult } from '../../domain/value-objects/validation-result.js';
 import { ItTestMockDetectionService } from '../../domain/services/it-test-mock-detection-service.js';
 import { StubCommentDetectionService } from '../../domain/services/stub-comment-detection-service.js';
-import { CliE2eTestExistenceService } from '../../domain/services/cli-e2e-test-existence-service.js';
 import { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
 import type { ValidationResultContract } from '../dto/validation-result-contract.js';
 import type { RunL1ValidatorsInput } from '../dto/run-l1-validators-input.js';
 import type { ItTestFileAnalyzerPort } from '../../domain/ports/it-test-file-analyzer-port.js';
 import type { SourceFileTextScannerPort } from '../../domain/ports/source-file-text-scanner-port.js';
-import type { CliCommandRegistryPort } from '../../domain/ports/cli-command-registry-port.js';
-import type { E2eTestFileRegistryPort } from '../../domain/ports/e2e-test-file-registry-port.js';
 
 export interface RunL1ValidatorsUseCaseDeps {
   itTestFileAnalyzerPort: ItTestFileAnalyzerPort;
   sourceFileTextScannerPort: SourceFileTextScannerPort;
-  cliCommandRegistryPort?: CliCommandRegistryPort;
-  e2eTestFileRegistryPort?: E2eTestFileRegistryPort;
   contractMapper: ValidationResultContractMapper;
 }
 
 export class RunL1ValidatorsUseCase {
   private readonly itTestFileAnalyzerPort: ItTestFileAnalyzerPort;
   private readonly sourceFileTextScannerPort: SourceFileTextScannerPort;
-  private readonly cliCommandRegistryPort: CliCommandRegistryPort | undefined;
-  private readonly e2eTestFileRegistryPort: E2eTestFileRegistryPort | undefined;
   private readonly mapper: ValidationResultContractMapper;
   private readonly itTestMockDetectionService = new ItTestMockDetectionService();
   private readonly stubCommentDetectionService = new StubCommentDetectionService();
-  private readonly cliE2eTestExistenceService = new CliE2eTestExistenceService();
 
   constructor(deps: RunL1ValidatorsUseCaseDeps) {
     this.itTestFileAnalyzerPort = deps.itTestFileAnalyzerPort;
     this.sourceFileTextScannerPort = deps.sourceFileTextScannerPort;
-    this.cliCommandRegistryPort = deps.cliCommandRegistryPort;
-    this.e2eTestFileRegistryPort = deps.e2eTestFileRegistryPort;
     this.mapper = deps.contractMapper;
   }
 
@@ -49,7 +39,6 @@ export class RunL1ValidatorsUseCase {
 
     results.push(await this.runL1017(input));
     results.push(await this.runL1018(input));
-    results.push(await this.runL2013());
 
     return this.mapper.toContracts(results);
   }
@@ -115,38 +104,6 @@ export class RunL1ValidatorsUseCase {
     }
   }
 
-  /** H08-09: L2-013 CLIコマンドE2Eテスト存在チェック (Should) */
-  private async runL2013(): Promise<ValidationResult> {
-    const validatorId = ValidatorId.create('L2-013');
-    if (!this.cliCommandRegistryPort || !this.e2eTestFileRegistryPort) {
-      return ValidationResult.skip(validatorId);
-    }
-    const start = Date.now();
-    try {
-      const commands = await this.cliCommandRegistryPort.getRegisteredCommands();
-      const e2eFiles = await this.e2eTestFileRegistryPort.getE2eTestFiles();
-      const report = this.cliE2eTestExistenceService.check(commands, e2eFiles);
-      const durationMs = Date.now() - start;
-      if (report.hasViolations()) {
-        const errors = report.toMessages().map((msg) => ({
-          code: { value: 'L2-013', toString: () => 'L2-013' },
-          severity: { value: 'error', toString: () => 'error' },
-          message: msg,
-          suggestion: 'Add an E2E test for each registered CLI command in cli-harness.test.ts.',
-        }));
-        return ValidationResult.fail(validatorId, errors, durationMs);
-      }
-      return ValidationResult.pass(validatorId, durationMs);
-    } catch (err) {
-      const durationMs = Date.now() - start;
-      return ValidationResult.fail(validatorId, [{
-        code: { value: 'L2-013', toString: () => 'L2-013' },
-        severity: { value: 'error', toString: () => 'error' },
-        message: `L2-013 execution failed: ${err instanceof Error ? err.message : String(err)}`,
-        suggestion: '',
-      }], durationMs);
-    }
-  }
 }
 
-// @story-id H08-07
+// @story-id H08-07

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

@@ -16,6 +16,9 @@ import type { ValidatorConfigPort } from '../../domain/ports/validator-config-po
 import type { PhaseGatePolicyPort } from '../../domain/ports/phase-gate-policy-port.js';
 import type { MetadataPolicyPort } from '../../domain/ports/metadata-policy-port.js';
 import type { TestQualityAnalyzerPort } from '../../domain/ports/test-quality-analyzer-port.js';
+import type { CliCommandRegistryPort } from '../../domain/ports/cli-command-registry-port.js';
+import type { E2eTestFileRegistryPort } from '../../domain/ports/e2e-test-file-registry-port.js';
+import { CliE2eTestExistenceService } from '../../domain/services/cli-e2e-test-existence-service.js';
 
 export interface RunL2ValidatorsUseCaseDeps {
   validatorRegistry: ValidatorRegistry;
@@ -25,6 +28,8 @@ export interface RunL2ValidatorsUseCaseDeps {
   phaseGatePolicyPort?: PhaseGatePolicyPort;
   metadataPolicyPort?: MetadataPolicyPort;
   testQualityAnalyzerPort?: TestQualityAnalyzerPort;
+  cliCommandRegistryPort?: CliCommandRegistryPort;
+  e2eTestFileRegistryPort?: E2eTestFileRegistryPort;
 }
 
 export class RunL2ValidatorsUseCase {
@@ -35,6 +40,9 @@ export class RunL2ValidatorsUseCase {
   private readonly phaseGatePolicyPort?: PhaseGatePolicyPort;
   private readonly metadataPolicyPort?: MetadataPolicyPort;
   private readonly testQualityAnalyzerPort?: TestQualityAnalyzerPort;
+  private readonly cliCommandRegistryPort?: CliCommandRegistryPort;
+  private readonly e2eTestFileRegistryPort?: E2eTestFileRegistryPort;
+  private readonly cliE2eTestExistenceService = new CliE2eTestExistenceService();
 
   constructor(deps: RunL2ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -44,6 +52,8 @@ export class RunL2ValidatorsUseCase {
     this.phaseGatePolicyPort = deps.phaseGatePolicyPort;
     this.metadataPolicyPort = deps.metadataPolicyPort;
     this.testQualityAnalyzerPort = deps.testQualityAnalyzerPort;
+    this.cliCommandRegistryPort = deps.cliCommandRegistryPort;
+    this.e2eTestFileRegistryPort = deps.e2eTestFileRegistryPort;
   }
 
   async execute(input: RunL2ValidatorsInput): Promise<readonly ValidationResultContract[]> {
@@ -122,6 +132,26 @@ export class RunL2ValidatorsUseCase {
       }
     }
 
+    if (this.cliCommandRegistryPort && this.e2eTestFileRegistryPort) {
+      const l2013Result = overrideMap.get('L2-013');
+      if (l2013Result && !l2013Result.skipped) {
+        const commands = await this.cliCommandRegistryPort.getRegisteredCommands();
+        const e2eFiles = await this.e2eTestFileRegistryPort.getE2eTestFiles();
+        const report = this.cliE2eTestExistenceService.check(commands, e2eFiles);
+        if (report.hasViolations()) {
+          const errors = report.toMessages().map((msg) => ({
+            code: { value: 'L2-013', toString: () => 'L2-013' },
+            severity: { value: 'error', toString: () => 'error' },
+            message: msg,
+            suggestion: 'Add an E2E test for each registered CLI command in cli-harness.test.ts.',
+          }));
+          overrideMap.set('L2-013', ValidationResult.fail(ValidatorId.create('L2-013'), errors, 0));
+        } else {
+          overrideMap.set('L2-013', ValidationResult.pass(ValidatorId.create('L2-013'), 0));
+        }
+      }
+    }
+
     const finalResults = definitions.map(
       (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
     );

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

@@ -109,7 +109,7 @@ export class RunL4ValidatorsUseCase {
     }
 
     if (!layerConfig.enabled && !input.forceLayerEnabled) {
-      return [];
+      return this.mapper.toContracts(definitions.map((definition) => ValidationResult.skip(definition.validatorId)));
     }
 
     const effectiveLayerConfig = input.forceLayerEnabled && !layerConfig.enabled

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

@@ -45,7 +45,7 @@ import { join } from 'node:path';
 const DEFAULT_CONFIG = {
   preset: 'standard' as const,
   layers: {
-    L2: { enabled: true, validators: ['L2-001', 'L2-002', 'L2-003'] },
+    L2: { enabled: true, validators: ['L2-001', 'L2-002', 'L2-003', 'L2-013'] },
     L3: { enabled: true, validators: ['L3-001', 'L3-002', 'L3-003', 'L3-004'], coverageThreshold: 90, bundleSizeLimit: 512000 },
     L4: { enabled: true, validators: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'] },
   },
@@ -77,6 +77,7 @@ function buildDefaultRegistry(): ValidatorRegistry {
     createDef('L2-001', 'L2', 'always', 'PhaseGatePolicyPort'),
     createDef('L2-002', 'L2', 'always', 'MetadataPolicyPort'),
     createDef('L2-003', 'L2', 'always'),
+    createDef('L2-013', 'L2', 'always', 'CliE2eTestExistenceService'),
     createDef('L3-001', 'L3', 'always'),
     createDef('L3-002', 'L3', 'strictOnly'),
     createDef('L3-003', 'L3', 'always'),
@@ -123,6 +124,18 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const securityScannerPort = new FileSystemSecurityPatternScannerAdapter();
   const performanceScannerPort = new AstPerformanceScannerAdapter();
 
+  const docsRoot = join(process.cwd(), 'docs/product/construction');
+  const cwd = process.cwd();
+  const e2eTestFileRegistryPort = new E2eTestFileRegistryAdapter({ e2eTestRoot: join(cwd, 'scripts/harness/__tests__/e2e') });
+  const cliCommandRegistryPort = new CliCommandRegistryAdapter({
+    commands: [
+      'validate', 'lint', 'ci-check',
+      'phasegate:check-ready', 'phasegate:check-phase', 'phasegate:ci-check',
+      'phasegate:detect-drift', 'phasegate:lint', 'phasegate:complete-check',
+      'phasegate:impact-analysis', 'phasegate:status',
+    ],
+  });
+
   const runL2ValidatorsUseCase = new RunL2ValidatorsUseCase({
     validatorRegistry: registry,
     validatorExecutionService: executionService,
@@ -131,6 +144,8 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     phaseGatePolicyPort,
     metadataPolicyPort,
     testQualityAnalyzerPort,
+    e2eTestFileRegistryPort,
+    cliCommandRegistryPort,
   });
 
   const runL3ValidatorsUseCase = new RunL3ValidatorsUseCase({
@@ -143,7 +158,6 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     performanceScannerPort,
   });
 
-  const docsRoot = join(process.cwd(), 'docs/product/construction');
   const markdownDesignDocumentPort = new MarkdownDesignDocumentAdapter(docsRoot);
   const sourceCodeAnalyzerAdapter = new BiomeAstSourceCodeAnalyzerAdapter();
   const adrReferencePort = new AdrFoundationReferenceAdapter();
@@ -182,26 +196,15 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   });
 
   const aggregateValidationResultsUseCase = new AggregateValidationResultsUseCase();
-  const KNOWN_CLI_COMMANDS = [
-    'validate', 'lint', 'ci-check', 'detect-drift',
-    'phasegate:check-ready', 'phasegate:check-phase', 'phasegate:ci-check',
-    'phasegate:detect-drift', 'phasegate:lint', 'phasegate:complete-check',
-    'phasegate:impact-analysis', 'phasegate:status',
-  ];
-  const cwd = process.cwd();
   const itTestFileAnalyzerPort = new ItTestFileAnalyzerAdapter({
     itTestRoot: join(cwd, 'scripts/harness/__tests__/integration'),
     // アダプター自体のテストファイルは vi.mock() を使用しているため誤検知防止で除外
     excludePattern: /it-test-file-analyzer-adapter\.test\.ts$/,
   });
   const sourceFileTextScannerPort = new SourceFileTextScannerAdapter({ sourceRoot: join(cwd, 'scripts/harness') });
-  const e2eTestFileRegistryPort = new E2eTestFileRegistryAdapter({ e2eTestRoot: join(cwd, 'scripts/harness/__tests__/e2e') });
-  const cliCommandRegistryPort = new CliCommandRegistryAdapter({ commands: KNOWN_CLI_COMMANDS });
   const runL1ValidatorsUseCase = new RunL1ValidatorsUseCase({
     itTestFileAnalyzerPort,
     sourceFileTextScannerPort,
-    e2eTestFileRegistryPort,
-    cliCommandRegistryPort,
     contractMapper,
   });
 

package/scripts/harness/validator-system/domain/services/cli-e2e-test-existence-service.ts

@@ -5,15 +5,46 @@ import { CliE2eTestCoverageReport, type CliCommandCoverageEntry } from '../value
 
 export class CliE2eTestExistenceService {
   check(commands: readonly string[], e2eTestFiles: readonly string[]): CliE2eTestCoverageReport {
+    if (e2eTestFiles.length === 0) {
+      return CliE2eTestCoverageReport.create(
+        commands.map((commandName) => ({
+          commandName,
+          hasE2eTest: false,
+          status: 'limitation',
+          evidence: 'No CLI E2E test suite found in this project.',
+        })),
+      );
+    }
+
     const e2eContent = e2eTestFiles.join('\n').toLowerCase();
 
-    const entries: CliCommandCoverageEntry[] = commands.map((commandName) => ({
-      commandName,
-      hasE2eTest: e2eContent.includes(commandName.toLowerCase()),
-    }));
+    const entries: CliCommandCoverageEntry[] = commands.map((commandName) => {
+      const evidence = this.findCoverageEvidence(commandName, e2eContent);
+      return {
+        commandName,
+        hasE2eTest: evidence !== null,
+        status: evidence === null ? 'missing' : 'covered',
+        evidence: evidence ?? undefined,
+      };
+    });
 
     return CliE2eTestCoverageReport.create(entries);
   }
+
+  private findCoverageEvidence(commandName: string, e2eContent: string): string | null {
+    const escaped = commandName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const invocationPatterns = [
+      new RegExp(`\\brun\\(\\s*['"\`]${escaped}['"\`]`),
+      new RegExp(`\\brunin(?:cwd)?\\([^\\n]*['"\`]${escaped}['"\`]`),
+      new RegExp(`unknown command:\\s*${escaped}`),
+      new RegExp(`usage:\\s*phasegate\\s+${escaped}`),
+    ];
+    if (invocationPatterns.some((pattern) => pattern.test(e2eContent))) {
+      return commandName;
+    }
+
+    return e2eContent.includes(commandName.toLowerCase()) ? commandName : null;
+  }
 }
 
-// @story-id H08-07
+// @story-id H08-07

package/scripts/harness/validator-system/domain/value-objects/cli-e2e-test-coverage-report.ts

@@ -9,6 +9,8 @@
 export interface CliCommandCoverageEntry {
   readonly commandName: string;
   readonly hasE2eTest: boolean;
+  readonly status?: 'covered' | 'missing' | 'limitation';
+  readonly evidence?: string;
 }
 
 export class CliE2eTestCoverageReport {
@@ -28,7 +30,11 @@ export class CliE2eTestCoverageReport {
   }
 
   uncoveredCommands(): readonly CliCommandCoverageEntry[] {
-    return this.entries.filter((e) => !e.hasE2eTest);
+    return this.entries.filter((e) => !e.hasE2eTest && e.status !== 'limitation');
+  }
+
+  limitations(): readonly CliCommandCoverageEntry[] {
+    return this.entries.filter((e) => e.status === 'limitation');
   }
 
   hasViolations(): boolean {
@@ -42,4 +48,4 @@ export class CliE2eTestCoverageReport {
   }
 }
 
-// @story-id H08-07
+// @story-id H08-07

package/scripts/harness/validator-system/infrastructure/adapters/e2e-test-file-registry-adapter.ts

@@ -6,7 +6,7 @@
  * E2Eテストファイルのパス一覧を提供する。
  */
 import type { E2eTestFileRegistryPort } from '../../domain/ports/e2e-test-file-registry-port.js';
-import { readdir } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 
 export interface E2eTestFileRegistryAdapterOptions {
@@ -22,7 +22,16 @@ export class E2eTestFileRegistryAdapter implements E2eTestFileRegistryPort {
 
   async getE2eTestFiles(): Promise<readonly string[]> {
     if (!this.e2eTestRoot) return [];
-    return this.findFiles(this.e2eTestRoot, /\.test\.ts$/);
+    const filePaths = await this.findFiles(this.e2eTestRoot, /\.test\.ts$/);
+    const contents: string[] = [];
+    for (const filePath of filePaths) {
+      try {
+        contents.push(`${filePath}\n${await readFile(filePath, 'utf-8')}`);
+      } catch {
+        contents.push(filePath);
+      }
+    }
+    return contents;
   }
 
   private async findFiles(dir: string, pattern: RegExp): Promise<string[]> {
@@ -45,4 +54,4 @@ export class E2eTestFileRegistryAdapter implements E2eTestFileRegistryPort {
   }
 }
 
-// @story-id H08-07
+// @story-id H08-07

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

@@ -38,7 +38,7 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
     const layerData = this.config.layers?.[layer] ?? {};
 
     const defaultValidators: Record<string, string[]> = {
-      L2: ['L2-001', 'L2-002', 'L2-003'],
+      L2: ['L2-001', 'L2-002', 'L2-003', 'L2-013'],
       L3: ['L3-001', 'L3-002', 'L3-003', 'L3-004'],
       L4: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'],
     };