phasegate 0.134.0 → 0.136.0

package/scripts/harness/phase2-extensions/infrastructure/adapters/harness-config-freshness-adapter.ts

@@ -9,6 +9,10 @@ import type { FreshnessConfigPort } from '../../domain/ports/freshness-config-po
 import { FreshnessThreshold } from '../../domain/value-objects/freshness-threshold.js';
 
 type Phase2RuleConfig = {
+  paths?: {
+    designDocs?: string;
+    inceptionDocs?: string;
+  };
   phase2Extensions?: {
     freshnessRules?: Array<{
       ruleId: string;
@@ -25,16 +29,22 @@ type Phase2RuleConfig = {
   };
 };
 
+function normalizePathPatternRoot(value: string | undefined): string {
+  const normalized = value?.replace(/\\/g, '/').replace(/\/+$/g, '');
+  return normalized && normalized.length > 0 ? normalized : 'docs/product/construction';
+}
+
 export class HarnessConfigFreshnessAdapter implements FreshnessConfigPort {
   constructor(private readonly config?: HarnessConfigV2 | Phase2RuleConfig) {}
 
   async loadRules(): Promise<DocFreshnessRule[]> {
     const configRules = this.config && 'phase2Extensions' in this.config ? this.config.phase2Extensions?.freshnessRules : undefined;
     if (!configRules || configRules.length === 0) {
+      const designDocsRoot = normalizePathPatternRoot(this.config?.paths?.designDocs);
       return [
         DocFreshnessRule.create({
           ruleId: 'default-doc-freshness',
-          documentPattern: 'docs/**/*.md',
+          documentPattern: `${designDocsRoot}/**/*.md`,
           threshold: FreshnessThreshold.create({ warnThresholdDays: 30, errorThresholdDays: 90 }),
           enabled: true,
         }),
@@ -57,10 +67,11 @@ export class HarnessConfigFreshnessAdapter implements FreshnessConfigPort {
   async loadPointerRules(): Promise<PointerRule[]> {
     const configRules = this.config && 'phase2Extensions' in this.config ? this.config.phase2Extensions?.pointerRules : undefined;
     if (!configRules || configRules.length === 0) {
+      const designDocsRoot = normalizePathPatternRoot(this.config?.paths?.designDocs);
       return [
         PointerRule.create({
           ruleId: 'default-pointer-rule',
-          documentPattern: 'docs/**/*.md',
+          documentPattern: `${designDocsRoot}/**/*.md`,
           failOnBroken: true,
         }),
       ];

package/scripts/harness/phase2-extensions/infrastructure/adapters/regex-pointer-extractor-adapter.ts

@@ -8,12 +8,38 @@ import type { PointerExtractorPort } from '../../domain/ports/pointer-extractor-
 import { Pointer } from '../../domain/value-objects/pointer.js';
 
 const MARKDOWN_LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
-const RELATIVE_PATH_REGEX = /(?:^|\s)((?:docs|scripts)\/[^\s,'")\]]+)/gm;
+const RELATIVE_PATH_REGEX = /(?:^|\s)((?:docs|scripts)\/[^\s,'"`")\]）]+)/gm;
 
 function isUrlTarget(target: string): boolean {
   return target.startsWith('http://') || target.startsWith('https://');
 }
 
+function hasFileExtension(target: string): boolean {
+  return /\.[A-Za-z0-9]+$/u.test(path.posix.basename(target));
+}
+
+function normalizeFileTarget(documentPath: string, rawTarget: string): string | null {
+  const withoutFragment = rawTarget.split('#')[0] ?? '';
+  const cleaned = withoutFragment
+    .replace(/^`+|`+$/g, '')
+    .replace(/（.*$/u, '')
+    .replace(/:\d+$/u, '')
+    .replace(/[.,;:]+$/g, '')
+    .trim();
+
+  if (cleaned.length === 0) return null;
+  if (cleaned.includes('{') || cleaned.includes('}') || cleaned.includes('*') || cleaned.includes('...')) return null;
+  if (/[^\x00-\x7F]/u.test(cleaned)) return null;
+  if (cleaned.startsWith('/')) return path.posix.normalize(cleaned);
+  if (cleaned.startsWith('docs/') || cleaned.startsWith('scripts/')) return path.posix.normalize(cleaned);
+  if (!cleaned.includes('/') && !hasFileExtension(cleaned)) return null;
+  if (cleaned.startsWith('./') || cleaned.startsWith('../') || !cleaned.includes('/')) {
+    return path.posix.normalize(path.posix.join(path.posix.dirname(documentPath), cleaned));
+  }
+
+  return path.posix.normalize(cleaned);
+}
+
 export class RegexPointerExtractorAdapter implements PointerExtractorPort {
   constructor(private readonly projectRoot: string) {}
 
@@ -29,15 +55,20 @@ export class RegexPointerExtractorAdapter implements PointerExtractorPort {
         continue;
       }
       const type = isUrlTarget(target) ? 'url' : 'file-path';
-      const key = `${type}:${target}`;
+      const normalizedTarget = type === 'url' ? target : normalizeFileTarget(documentPath, target);
+      if (!normalizedTarget) {
+        continue;
+      }
+      const key = `${type}:${normalizedTarget}`;
       if (!seen.has(key)) {
         seen.add(key);
-        pointers.push(Pointer.create({ type, rawText, target }));
+        pointers.push(Pointer.create({ type, rawText, target: normalizedTarget }));
       }
     }
 
     for (const match of content.matchAll(RELATIVE_PATH_REGEX)) {
-      const target = match[1]?.trim();
+      const rawTarget = match[1]?.trim();
+      const target = rawTarget ? normalizeFileTarget(documentPath, rawTarget) : null;
       if (!target) {
         continue;
       }

package/scripts/harness/quick-mode/infrastructure/adapters/validator-system-validator-id-registry-adapter.ts

@@ -9,7 +9,7 @@ const STATIC_VALIDATOR_IDS: readonly string[] = Object.freeze([
   'L1-001', 'L1-002', 'L1-003', 'L1-004', 'L1-005', 'L1-006', 'L1-007', 'L1-008',
   'L2-001', 'L2-002', 'L2-003',
   'L3-001', 'L3-002', 'L3-003', 'L3-004',
-  'L4-001', 'L4-002', 'L4-003',
+  'L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005',
 ]);
 
 export class ValidatorSystemValidatorIdRegistryAdapter {

package/scripts/harness/setup/skill-deployer.ts

@@ -420,10 +420,15 @@ export async function deployHookScripts(harnessRoot: string, projectRoot: string
   };
 }
 
+export interface InitHarnessConfigOptions {
+  ciEnabled?: boolean;
+}
+
 export async function initHarnessConfig(
   projectRoot: string,
   projectName: string,
   phasePreset?: "full" | "standard" | "minimal" | "custom",
+  options: InitHarnessConfigOptions = {},
 ): Promise<{ created: boolean; path: string }> {
   const configPath = join(projectRoot, HARNESS_CONFIG_FILE);
   try {
@@ -461,6 +466,7 @@ export async function initHarnessConfig(
       format: "json",
       outputDir: "reports",
     },
+    ...(options.ciEnabled ? { ci: { enabled: true } } : {}),
   };
 
   await fs.writeFile(configPath, JSON.stringify(template, null, 2) + "\n", "utf-8");
@@ -532,6 +538,46 @@ export interface DeployHuskyHookResult {
   path: string;
 }
 
+export interface DeployCiWorkflowsResult {
+  copiedFiles: string[];
+  skippedFiles: string[];
+}
+
+export async function deployCiWorkflows(harnessRoot: string, projectRoot: string): Promise<DeployCiWorkflowsResult> {
+  const copiedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+  const workflows = [
+    {
+      relativeSource: join("docs", "templates", "ci", "aidlc-gate.yml"),
+      relativeTarget: join(".github", "workflows", "aidlc-gate.yml"),
+    },
+    {
+      relativeSource: join("docs", "templates", "ci", "consistency-check.yml"),
+      relativeTarget: join(".github", "workflows", "consistency-check.yml"),
+    },
+  ];
+
+  await fs.mkdir(join(projectRoot, ".github", "workflows"), { recursive: true });
+
+  for (const workflow of workflows) {
+    const sourcePath = join(harnessRoot, workflow.relativeSource);
+    const targetPath = join(projectRoot, workflow.relativeTarget);
+
+    try {
+      await fs.access(targetPath);
+      skippedFiles.push(workflow.relativeTarget);
+      continue;
+    } catch {
+      // ファイルが存在しない場合のみコピーする
+    }
+
+    await fs.copyFile(sourcePath, targetPath);
+    copiedFiles.push(workflow.relativeTarget);
+  }
+
+  return { copiedFiles, skippedFiles };
+}
+
 export async function deployHuskyHook(harnessRoot: string, projectRoot: string): Promise<DeployHuskyHookResult> {
   const targetPath = join(projectRoot, ".husky", "pre-commit");
 
@@ -540,7 +586,7 @@ export async function deployHuskyHook(harnessRoot: string, projectRoot: string):
     return { created: false, path: targetPath };
   } catch {}
 
-  const sourcePath = join(harnessRoot, "templates", ".husky", "pre-commit");
+  const sourcePath = join(harnessRoot, "docs", "templates", "hooks", "pre-commit");
   await fs.mkdir(join(projectRoot, ".husky"), { recursive: true });
   await fs.copyFile(sourcePath, targetPath);
   await fs.chmod(targetPath, 0o755);
@@ -559,7 +605,7 @@ export async function deployHuskyCommitMsgHook(
     return { created: false, path: targetPath };
   } catch {}
 
-  const sourcePath = join(harnessRoot, "templates", ".husky", "commit-msg");
+  const sourcePath = join(harnessRoot, "docs", "templates", "hooks", "commit-msg");
   await fs.mkdir(join(projectRoot, ".husky"), { recursive: true });
   await fs.copyFile(sourcePath, targetPath);
   await fs.chmod(targetPath, 0o755);

package/scripts/harness/skill-quality/infrastructure/adapters/validator-id-registry-bridge-adapter.ts

@@ -8,7 +8,7 @@ const FALLBACK_VALIDATOR_IDS = [
   'L1-001', 'L1-002', 'L1-003', 'L1-004', 'L1-005', 'L1-006', 'L1-007', 'L1-008',
   'L2-001', 'L2-002', 'L2-003',
   'L3-001', 'L3-002', 'L3-003', 'L3-004',
-  'L4-001', 'L4-002', 'L4-003',
+  'L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005',
 ];
 
 export class ValidatorIdRegistryBridgeAdapter implements ValidatorIdRegistryPort {

package/scripts/harness/traceability-model/domain/value-objects/work-item-frontmatter.ts

@@ -13,7 +13,8 @@ export type WorkItemStatus =
   | 'drafted'
   | 'reflected'
   | 'implemented'
-  | 'tested';
+  | 'tested'
+  | 'completed';
 
 export interface WorkItemFrontmatter {
   readonly id: string;
@@ -54,4 +55,5 @@ export const WORK_ITEM_STATUSES: ReadonlySet<WorkItemStatus> = new Set([
   'reflected',
   'implemented',
   'tested',
+  'completed',
 ]);

package/scripts/harness/validator-system/application/dto/run-l4-validators-input.ts

@@ -8,4 +8,5 @@ export interface RunL4ValidatorsInput {
   readonly validatorIds?: readonly string[];
   readonly targetUnits?: readonly string[];
   readonly strictMode?: boolean;
+  readonly forceLayerEnabled?: boolean;
 }

package/scripts/harness/validator-system/application/use-cases/run-full-validation-usecase.ts

@@ -78,6 +78,7 @@ export class RunFullValidationUseCase {
     if (runL4) {
       l4Results = await this.l4UseCase.execute({
         targetUnits: input.targetUnits,
+        forceLayerEnabled: input.targetLayers?.length === 1 && input.targetLayers.includes('L4'),
       });
     }
 

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

@@ -6,6 +6,7 @@
  */
 import { ValidatorId } from '../../domain/value-objects/validator-id.js';
 import { ValidationResult } from '../../domain/value-objects/validation-result.js';
+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 { ValidationResultContractMapper } from '../mappers/validation-result-contract-mapper.js';
@@ -16,6 +17,38 @@ import type { DriftDetectionService } from '../../domain/services/l4/drift-detec
 import type { ConsistencyCheckService } from '../../domain/services/l4/consistency-check-service.js';
 import type { DeadCodeDetectionService } from '../../domain/services/l4/dead-code-detection-service.js';
 
+interface ScheduledHarnessErrorContract {
+  readonly severity: string;
+  readonly message: string;
+  readonly suggestion: string;
+}
+
+interface CheckDocFreshnessOutputContract {
+  readonly results: readonly {
+    readonly level: 'ok' | 'warn' | 'error';
+    readonly message: string;
+  }[];
+  readonly errors: readonly ScheduledHarnessErrorContract[];
+}
+
+interface ValidateDocPointersOutputContract {
+  readonly results: readonly {
+    readonly documentPath: string;
+    readonly pointerTarget: string;
+    readonly isResolvable: boolean;
+    readonly errorMessage: string | null;
+  }[];
+  readonly errors: readonly ScheduledHarnessErrorContract[];
+}
+
+interface CheckDocFreshnessUseCasePort {
+  execute(input: { targetPattern?: string; format?: 'text' | 'json'; dryRun?: boolean }): Promise<CheckDocFreshnessOutputContract>;
+}
+
+interface ValidateDocPointersUseCasePort {
+  execute(input: { targetPattern?: string; includeUrlPointers?: boolean; format?: 'text' | 'json' }): Promise<ValidateDocPointersOutputContract>;
+}
+
 export class DesignDocumentReadError extends Error {
   constructor(message: string) {
     super(message);
@@ -31,6 +64,8 @@ export interface RunL4ValidatorsUseCaseDeps {
   driftDetectionService?: DriftDetectionService;
   consistencyCheckService?: ConsistencyCheckService;
   deadCodeDetectionService?: DeadCodeDetectionService;
+  checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
+  validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
 }
 
 export class RunL4ValidatorsUseCase {
@@ -41,6 +76,8 @@ export class RunL4ValidatorsUseCase {
   private readonly driftDetectionService?: DriftDetectionService;
   private readonly consistencyCheckService?: ConsistencyCheckService;
   private readonly deadCodeDetectionService?: DeadCodeDetectionService;
+  private readonly checkDocFreshnessUseCase?: CheckDocFreshnessUseCasePort;
+  private readonly validateDocPointersUseCase?: ValidateDocPointersUseCasePort;
 
   constructor(deps: RunL4ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -50,6 +87,8 @@ export class RunL4ValidatorsUseCase {
     this.driftDetectionService = deps.driftDetectionService;
     this.consistencyCheckService = deps.consistencyCheckService;
     this.deadCodeDetectionService = deps.deadCodeDetectionService;
+    this.checkDocFreshnessUseCase = deps.checkDocFreshnessUseCase;
+    this.validateDocPointersUseCase = deps.validateDocPointersUseCase;
   }
 
   async execute(input: RunL4ValidatorsInput): Promise<readonly ValidationResultContract[]> {
@@ -69,11 +108,22 @@ export class RunL4ValidatorsUseCase {
       throw new ValidatorExecutionError(`Failed to get L4 LayerConfig: ${err instanceof Error ? err.message : String(err)}`, err);
     }
 
-    if (!layerConfig.enabled) {
+    if (!layerConfig.enabled && !input.forceLayerEnabled) {
       return [];
     }
 
-    const results = this.executionService.execute(definitions, [layerConfig]);
+    const effectiveLayerConfig = input.forceLayerEnabled && !layerConfig.enabled
+      ? LayerConfig.create({
+          layer: layerConfig.layer,
+          enabled: true,
+          validatorIds: layerConfig.validatorIds,
+          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]));
 
     if (this.driftDetectionService) {
@@ -109,7 +159,7 @@ export class RunL4ValidatorsUseCase {
     if (this.deadCodeDetectionService) {
       const l4003Result = overrideMap.get('L4-003');
       if (l4003Result && !l4003Result.skipped) {
-        const strictOnly = input.strictMode ?? layerConfig.strictOnly ?? false;
+        const strictOnly = input.strictMode ?? effectiveLayerConfig.strictOnly ?? false;
         const report = await this.deadCodeDetectionService.detect({ strictOnly });
         if (report.hasDeadCode()) {
           overrideMap.set(
@@ -120,9 +170,89 @@ export class RunL4ValidatorsUseCase {
       }
     }
 
+    if (this.checkDocFreshnessUseCase) {
+      const l4004Result = overrideMap.get('L4-004');
+      if (l4004Result && !l4004Result.skipped) {
+        const freshnessOutput = await this.checkDocFreshnessUseCase.execute({ format: 'json' });
+        const errors = this.toDocFreshnessHarnessErrors(freshnessOutput);
+        overrideMap.set(
+          'L4-004',
+          errors.length > 0
+            ? ValidationResult.fail(ValidatorId.create('L4-004'), errors, 0)
+            : ValidationResult.pass(ValidatorId.create('L4-004'), 0),
+        );
+      }
+    }
+
+    if (this.validateDocPointersUseCase) {
+      const l4005Result = overrideMap.get('L4-005');
+      if (l4005Result && !l4005Result.skipped) {
+        const pointerOutput = await this.validateDocPointersUseCase.execute({ includeUrlPointers: false, format: 'json' });
+        const errors = this.toPointerValidationHarnessErrors(pointerOutput);
+        overrideMap.set(
+          'L4-005',
+          errors.length > 0
+            ? ValidationResult.fail(ValidatorId.create('L4-005'), errors, 0)
+            : ValidationResult.pass(ValidatorId.create('L4-005'), 0),
+        );
+      }
+    }
+
     const finalResults = definitions.map(
       (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
     );
     return this.mapper.toContracts(finalResults);
   }
+
+  private toDocFreshnessHarnessErrors(output: CheckDocFreshnessOutputContract): readonly ValidationResult['errors'][number][] {
+    const executionErrors = output.errors.map((error) => this.toHarnessErrorLike(
+      'L4-004',
+      error.severity,
+      error.message,
+      error.suggestion,
+    ));
+    const freshnessFindings = output.results
+      .filter((result) => result.level !== 'ok')
+      .map((result) => this.toHarnessErrorLike(
+        'L4-004',
+        result.level === 'error' ? 'error' : 'warning',
+        result.message,
+        'Review the document freshness threshold or update the design document.',
+      ));
+
+    return [...executionErrors, ...freshnessFindings];
+  }
+
+  private toPointerValidationHarnessErrors(output: ValidateDocPointersOutputContract): readonly ValidationResult['errors'][number][] {
+    const executionErrors = output.errors.map((error) => this.toHarnessErrorLike(
+      'L4-005',
+      error.severity,
+      error.message,
+      error.suggestion,
+    ));
+    const brokenPointers = output.results
+      .filter((result) => !result.isResolvable)
+      .map((result) => this.toHarnessErrorLike(
+        'L4-005',
+        'warning',
+        `${result.documentPath} has an unresolved pointer to ${result.pointerTarget}`,
+        result.errorMessage ?? 'Fix or remove the pointer target.',
+      ));
+
+    return [...executionErrors, ...brokenPointers];
+  }
+
+  private toHarnessErrorLike(
+    code: string,
+    severity: string,
+    message: string,
+    suggestion: string,
+  ): ValidationResult['errors'][number] {
+    return {
+      code: { value: code, toString: () => code },
+      severity: { value: severity, toString: () => severity },
+      message,
+      suggestion,
+    };
+  }
 }

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

@@ -35,6 +35,7 @@ import { ImportGraphSourceAnalysisAdapter } from './infrastructure/adapters/impo
 import { DriftDetectionService } from './domain/services/l4/drift-detection-service.js';
 import { ConsistencyCheckService } from './domain/services/l4/consistency-check-service.js';
 import { DeadCodeDetectionService } from './domain/services/l4/dead-code-detection-service.js';
+import { buildPhase2Extensions } from '../phase2-extensions/composition-root.js';
 import { RunValidatorsHandler } from './presentation/handlers/run-validators-handler.js';
 import { RunQuickModeHandler } from './presentation/handlers/run-quick-mode-handler.js';
 import { ReportValidationResultsHandler } from './presentation/handlers/report-validation-results-handler.js';
@@ -46,12 +47,12 @@ const DEFAULT_CONFIG = {
   layers: {
     L2: { enabled: true, validators: ['L2-001', 'L2-002', 'L2-003'] },
     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: { enabled: true, validators: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'] },
   },
   validate: { failOnWarning: false },
 };
 
-/** バリデータ定義カタログ（全10件） */
+/** バリデータ定義カタログ */
 function buildDefaultRegistry(): ValidatorRegistry {
   const defaultRule = ValidationRule.create({
     ruleName: 'default-rule',
@@ -83,6 +84,8 @@ function buildDefaultRegistry(): ValidatorRegistry {
     createDef('L4-001', 'L4', 'always'),
     createDef('L4-002', 'L4', 'always'),
     createDef('L4-003', 'L4', 'strictOnly'),
+    createDef('L4-004', 'L4', 'always'),
+    createDef('L4-005', 'L4', 'always'),
   ];
 
   return new ValidatorRegistry(definitions);
@@ -157,6 +160,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const deadCodeDetectionService = new DeadCodeDetectionService({
     sourceAnalysisPort,
   });
+  const phase2Extensions = buildPhase2Extensions(process.cwd(), configData as never);
 
   const runL4ValidatorsUseCase = new RunL4ValidatorsUseCase({
     validatorRegistry: registry,
@@ -166,6 +170,8 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     driftDetectionService,
     consistencyCheckService,
     deadCodeDetectionService,
+    checkDocFreshnessUseCase: phase2Extensions.checkDocFreshnessUseCase,
+    validateDocPointersUseCase: phase2Extensions.validateDocPointersUseCase,
   });
 
   const runQuickModeUseCase = new RunQuickModeUseCase({

package/scripts/harness/validator-system/domain/value-objects/validator-id.ts

@@ -3,7 +3,7 @@
  * @unit validator-system
  *
  * ValidatorId 値オブジェクト
- * L1-001〜L4-003 のバリデータを識別する不変値オブジェクト
+ * L1-001〜L4-005 のバリデータを識別する不変値オブジェクト
  * Wave 2A で L1-017, L1-018, L2-013 を追加
  */
 
@@ -33,12 +33,19 @@ const VALIDATOR_NAME_MAP: Record<string, string> = {
   'L4-001': 'drift-detect',
   'L4-002': 'consistency-check',
   'L4-003': 'dead-code',
+  'L4-004': 'doc-freshness',
+  'L4-005': 'pointer-validation',
 };
 
 /** バリデータ名 -> バリデータID の逆引きマップ */
-const NAME_TO_ID_MAP: Record<string, string> = Object.fromEntries(
-  Object.entries(VALIDATOR_NAME_MAP).map(([id, name]) => [name, id])
-);
+const NAME_TO_ID_MAP: Record<string, string> = {
+  ...Object.fromEntries(Object.entries(VALIDATOR_NAME_MAP).map(([id, name]) => [name, id])),
+  'drift-detector': 'L4-001',
+  'consistency-checker': 'L4-002',
+  'dead-code-detector': 'L4-003',
+  'doc-freshness-checker': 'L4-004',
+  'pointer-validator': 'L4-005',
+};
 
 /** 有効なValidatorID集合 */
 const VALID_IDS = new Set(Object.keys(VALIDATOR_NAME_MAP));

package/scripts/harness/validator-system/infrastructure/adapters/biome-ast-source-code-analyzer-adapter.ts

@@ -12,9 +12,23 @@ import { basename, join, relative, sep } from 'node:path';
 
 const HARNESS_ROOT = join(process.cwd(), 'scripts', 'harness');
 
+export interface BiomeAstSourceCodeAnalyzerAdapterOptions {
+  readonly sourceRoot?: string;
+  /** スキャン対象から除外するパスパターン（デフォルト: テストディレクトリを除外） */
+  readonly excludePattern?: RegExp;
+}
+
 export class BiomeAstSourceCodeAnalyzerAdapter implements SourceCodeAnalyzerPort {
+  private readonly sourceRoot: string;
+  private readonly excludePattern: RegExp;
+
+  constructor(options: BiomeAstSourceCodeAnalyzerAdapterOptions = {}) {
+    this.sourceRoot = options.sourceRoot ?? HARNESS_ROOT;
+    this.excludePattern = options.excludePattern ?? /__tests__\//;
+  }
+
   async analyzeExports(targetUnits?: readonly string[]): Promise<readonly SourceAnalysisResult[]> {
-    const targetFiles = await collectTargetFiles(targetUnits);
+    const targetFiles = await collectTargetFiles(this.sourceRoot, this.excludePattern, targetUnits);
     if (targetFiles.length === 0) return [];
 
     const program = ts.createProgram(targetFiles, {
@@ -30,7 +44,7 @@ export class BiomeAstSourceCodeAnalyzerAdapter implements SourceCodeAnalyzerPort
       const sourceFile = program.getSourceFile(filePath);
       if (!sourceFile) continue;
       results.push({
-        unitName: resolveUnitName(filePath),
+        unitName: resolveUnitName(this.sourceRoot, filePath),
         filePath,
         exports: extractExports(sourceFile),
         imports: extractImports(sourceFile),
@@ -134,26 +148,31 @@ function extractImports(sourceFile: ts.SourceFile): SourceAnalysisResult['import
   return imports;
 }
 
-async function collectTargetFiles(targetUnits?: readonly string[]): Promise<readonly string[]> {
+async function collectTargetFiles(
+  sourceRoot: string,
+  excludePattern: RegExp,
+  targetUnits?: readonly string[],
+): Promise<readonly string[]> {
   const roots = targetUnits && targetUnits.length > 0
-    ? targetUnits.map((unit) => join(HARNESS_ROOT, unit))
-    : [HARNESS_ROOT];
+    ? targetUnits.map((unit) => join(sourceRoot, unit))
+    : [sourceRoot];
 
   const files: string[] = [];
   for (const root of roots) {
-    files.push(...await walkTsFiles(root));
+    files.push(...await walkTsFiles(root, excludePattern));
   }
 
   return files;
 }
 
-async function walkTsFiles(root: string): Promise<string[]> {
+async function walkTsFiles(root: string, excludePattern: RegExp): Promise<string[]> {
   try {
     const entries = await readdir(root, { withFileTypes: true });
     const files = await Promise.all(entries.map(async (entry) => {
       const fullPath = join(root, entry.name);
+      if (excludePattern.test(fullPath)) return [];
       if (entry.isDirectory()) {
-        return walkTsFiles(fullPath);
+        return walkTsFiles(fullPath, excludePattern);
       }
       return fullPath.endsWith('.ts') ? [fullPath] : [];
     }));
@@ -163,8 +182,8 @@ async function walkTsFiles(root: string): Promise<string[]> {
   }
 }
 
-function resolveUnitName(filePath: string): string {
-  const relativePath = relative(HARNESS_ROOT, filePath);
+function resolveUnitName(sourceRoot: string, filePath: string): string {
+  const relativePath = relative(sourceRoot, filePath);
   const [firstSegment] = relativePath.split(sep);
   return firstSegment || basename(filePath);
 }

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

@@ -6,6 +6,7 @@
  * HarnessConfigV2からLayerConfig VOを構築する
  */
 import { LayerConfig } from '../../domain/value-objects/layer-config.js';
+import { ValidatorId } from '../../domain/value-objects/validator-id.js';
 import type { ValidatorConfigPort } from '../../domain/ports/validator-config-port.js';
 
 export interface HarnessConfigLayers {
@@ -39,7 +40,7 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
     const defaultValidators: Record<string, string[]> = {
       L2: ['L2-001', 'L2-002', 'L2-003'],
       L3: ['L3-001', 'L3-002', 'L3-003', 'L3-004'],
-      L4: ['L4-001', 'L4-002', 'L4-003'],
+      L4: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005'],
     };
 
     const thresholds: Record<string, number> = {};
@@ -62,10 +63,18 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
     return LayerConfig.create({
       layer,
       enabled: layerData.enabled !== false,
-      validatorIds: layerData.validators ?? defaultValidators[layer],
+      validatorIds: (layerData.validators ?? defaultValidators[layer]).map((idOrName) => this.normalizeValidatorId(idOrName)),
       thresholds,
       strictOnly: layerData.strictOnly ?? strictOnly,
       preset,
     });
   }
+
+  private normalizeValidatorId(idOrName: string): string {
+    try {
+      return ValidatorId.create(idOrName).value;
+    } catch {
+      return ValidatorId.fromName(idOrName).value;
+    }
+  }
 }

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

@@ -12,6 +12,10 @@ export class PhaseDependencyPhaseGatePolicyAdapter implements PhaseGatePolicyPor
     satisfied: boolean;
     violations: readonly HarnessErrorLike[];
   }> {
+    if (context.unitName.trim().length === 0) {
+      return { satisfied: true, violations: [] };
+    }
+
     try {
       // WI-085: paths config を phase-dependency-model に流入させる
       const { createConfigFoundationModule } = await import('../../../config-foundation/composition-root.js');