phasegate 0.229.0 → 0.264.0

package/scripts/harness/traceability-model/infrastructure/adapters/file-system-traceability-world-read-adapter.ts

@@ -0,0 +1,223 @@
+// @unit traceability-model
+// @layer infrastructure
+// @work-item-id WI-288
+
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import type {
+  RawTraceabilityDiagnostic,
+  RawTraceabilityStory,
+  RawTraceabilityTestAnnotation,
+  RawTraceabilityUnit,
+  RawTraceabilityWorkItem,
+  TraceabilityWorldReadSourceDto,
+  TraceabilityWorldReadSourcePort,
+} from "../../application/ports/traceability-world-read-source-port.js";
+import type { MarkdownUnitDefinitionGateway } from "../gateways/markdown-unit-definition-gateway.js";
+import { parseTestTags } from "../parsers/source-metadata-parser.js";
+import { parseStoryCatalogEntries } from "../parsers/story-catalog-parser.js";
+import { parseWorkItemFrontmatter } from "../parsers/work-item-frontmatter-parser.js";
+
+const compareStrings = (left: string, right: string): number => (left < right ? -1 : left > right ? 1 : 0);
+
+const toProjectRelativePath = (rootDir: string, absolutePath: string): string =>
+  path.relative(rootDir, absolutePath).split(path.sep).join("/");
+
+const collectFiles = async (rootDir: string, accept: (fileName: string) => boolean): Promise<readonly string[]> => {
+  const result: string[] = [];
+  const visit = async (directory: string): Promise<void> => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((left, right) => compareStrings(left.name, right.name));
+    for (const entry of entries) {
+      const absolutePath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(absolutePath);
+      } else if (entry.isFile() && accept(entry.name)) {
+        result.push(absolutePath);
+      }
+    }
+  };
+  await visit(rootDir);
+  return result;
+};
+
+const sourceDiagnostic = (
+  code: string,
+  subjectId: string | null,
+  sourcePaths: readonly string[],
+  error: unknown,
+): RawTraceabilityDiagnostic => ({
+  code,
+  subjectId,
+  sourcePaths,
+  message: error instanceof Error ? error.message : String(error),
+});
+
+const classifyTestType = (filePath: string): RawTraceabilityTestAnnotation["testType"] => {
+  if (filePath.includes("/e2e/") || filePath.includes("/scenario/")) {
+    return "scenario";
+  }
+  if (filePath.includes("/integration/") || /\.it\.test\.[cm]?[jt]sx?$/.test(filePath)) {
+    return "it";
+  }
+  return "unit";
+};
+
+export interface FileSystemTraceabilityWorldReadAdapterDeps {
+  readonly rootDir: string;
+  readonly productDocsRoot: string;
+  readonly designDocsRoot: string;
+  readonly storyCatalogPath: string;
+  readonly inceptionRoot: string;
+  readonly testRoots: readonly string[];
+  readonly unitDefinitionGateway: MarkdownUnitDefinitionGateway;
+}
+
+export class FileSystemTraceabilityWorldReadAdapter implements TraceabilityWorldReadSourcePort {
+  private readonly deps: FileSystemTraceabilityWorldReadAdapterDeps;
+
+  constructor(deps: FileSystemTraceabilityWorldReadAdapterDeps) {
+    this.deps = deps;
+  }
+
+  async read(): Promise<TraceabilityWorldReadSourceDto> {
+    const diagnostics: RawTraceabilityDiagnostic[] = [];
+    const [units, stories, workItems, testAnnotations] = await Promise.all([
+      this.readUnits(diagnostics),
+      this.readStories(diagnostics),
+      this.readWorkItems(diagnostics),
+      this.readTestAnnotations(diagnostics),
+    ]);
+    return {
+      units,
+      stories,
+      workItems,
+      testAnnotations,
+      diagnostics,
+    };
+  }
+
+  private async readUnits(diagnostics: RawTraceabilityDiagnostic[]): Promise<readonly RawTraceabilityUnit[]> {
+    try {
+      const unitIds = await this.deps.unitDefinitionGateway.getAllUnitNames();
+      const result: RawTraceabilityUnit[] = [];
+      for (const unitId of unitIds) {
+        const constructionRoot = await this.deps.unitDefinitionGateway.findConstructionRoot(unitId);
+        result.push({
+          unitId,
+          definitionPath: path.posix.join(this.deps.productDocsRoot, "units", `${unitId}_unit.md`),
+          constructionRoot: constructionRoot?.value ?? null,
+        });
+      }
+      return result;
+    } catch (error) {
+      diagnostics.push(
+        sourceDiagnostic(
+          "TM-WORLD-READ-UNIT-SOURCE-ERROR",
+          null,
+          [path.posix.join(this.deps.productDocsRoot, "units")],
+          error,
+        ),
+      );
+      return [];
+    }
+  }
+
+  private async readStories(diagnostics: RawTraceabilityDiagnostic[]): Promise<readonly RawTraceabilityStory[]> {
+    try {
+      const absolutePath = path.join(this.deps.rootDir, this.deps.storyCatalogPath);
+      const content = await readFile(absolutePath, "utf8");
+      return parseStoryCatalogEntries(content).map((entry) => ({
+        storyId: entry.storyId,
+        legacyIds: [...entry.legacyIds],
+        sourcePath: this.deps.storyCatalogPath,
+        line: entry.lineNumber,
+        acceptanceCriteria: entry.acceptanceCriteria.map((criterion) => ({
+          acId: criterion.acId,
+          line: criterion.lineNumber,
+        })),
+      }));
+    } catch (error) {
+      diagnostics.push(sourceDiagnostic("TM-WORLD-READ-STORY-SOURCE-ERROR", null, [this.deps.storyCatalogPath], error));
+      return [];
+    }
+  }
+
+  private async readWorkItems(diagnostics: RawTraceabilityDiagnostic[]): Promise<readonly RawTraceabilityWorkItem[]> {
+    const absoluteRoot = path.join(this.deps.rootDir, this.deps.inceptionRoot);
+    let files: readonly string[];
+    try {
+      files = await collectFiles(absoluteRoot, (fileName) => fileName === "description.md");
+    } catch (error) {
+      diagnostics.push(
+        sourceDiagnostic("TM-WORLD-READ-WORK-ITEM-SOURCE-ERROR", null, [this.deps.inceptionRoot], error),
+      );
+      return [];
+    }
+
+    const result: RawTraceabilityWorkItem[] = [];
+    for (const absolutePath of files) {
+      const directoryId = path.basename(path.dirname(absolutePath));
+      if (!/^WI-/.test(directoryId)) continue;
+      const relativePath = toProjectRelativePath(this.deps.rootDir, absolutePath);
+      try {
+        const frontmatter = parseWorkItemFrontmatter(await readFile(absolutePath, "utf8"));
+        if (!frontmatter) {
+          diagnostics.push({
+            code: "TM-WORLD-READ-MISSING-WORK-ITEM-FRONTMATTER",
+            subjectId: directoryId,
+            sourcePaths: [relativePath],
+            message: `WorkItem ${directoryId} has no readable frontmatter`,
+          });
+          continue;
+        }
+        result.push({
+          directoryId,
+          workItemId: frontmatter.id,
+          legacyId: frontmatter.legacyId ?? null,
+          type: frontmatter.type,
+          severity: frontmatter.severity ?? null,
+          status: frontmatter.status ?? null,
+          affects: [...(frontmatter.affects ?? [])],
+          descriptionPath: relativePath,
+        });
+      } catch (error) {
+        diagnostics.push(sourceDiagnostic("TM-WORLD-READ-WORK-ITEM-PARSE-ERROR", directoryId, [relativePath], error));
+      }
+    }
+    return result;
+  }
+
+  private async readTestAnnotations(
+    diagnostics: RawTraceabilityDiagnostic[],
+  ): Promise<readonly RawTraceabilityTestAnnotation[]> {
+    const result: RawTraceabilityTestAnnotation[] = [];
+    for (const testRoot of this.deps.testRoots) {
+      const absoluteRoot = path.join(this.deps.rootDir, testRoot);
+      let files: readonly string[];
+      try {
+        files = await collectFiles(absoluteRoot, (fileName) => /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(fileName));
+      } catch (error) {
+        diagnostics.push(sourceDiagnostic("TM-WORLD-READ-TEST-SOURCE-ERROR", null, [testRoot], error));
+        continue;
+      }
+      for (const absolutePath of files) {
+        const relativePath = toProjectRelativePath(this.deps.rootDir, absolutePath);
+        try {
+          const tags = parseTestTags(await readFile(absolutePath, "utf8"));
+          for (const tag of tags) {
+            result.push({
+              storyId: tag.value,
+              filePath: relativePath,
+              line: tag.lineNumber,
+              testType: classifyTestType(relativePath),
+            });
+          }
+        } catch (error) {
+          diagnostics.push(sourceDiagnostic("TM-WORLD-READ-TEST-PARSE-ERROR", null, [relativePath], error));
+        }
+      }
+    }
+    return result;
+  }
+}

package/scripts/harness/traceability-model/infrastructure/adapters/git-staged-design-change-adapter.ts

@@ -0,0 +1,155 @@
+// @unit traceability-model
+// @layer infrastructure
+// @work-item-id WI-305
+
+import { execFileSync } from "node:child_process";
+import type {
+  ChangedDesignFragmentDto,
+  DesignChangeReadDiagnosticDto,
+  DesignChangeReadResultDto,
+  DesignFragmentCorpusRole,
+} from "../../application/dto/changed-design-fragment-dto.js";
+import type { StagedDesignChangeSourcePort } from "../../application/ports/staged-design-change-source-port.js";
+
+const FRAGMENT = /^\s*<!--\s*@world-fragment-id\s+(\S+)\s*-->\s*$/;
+const WORK_ITEM = /^\s*<!--\s*@work-item-id\s+(.+?)\s*-->\s*$/;
+const REFLECTS = /^\s*<!--\s*@world-reflects\s+(\S+)\s*-->\s*$/;
+const HEADING = /^#{1,6}\s+/;
+const FENCE = /^\s*(`{3,}|~{3,})/;
+const compare = (left: string, right: string): number => (left < right ? -1 : left > right ? 1 : 0);
+
+interface ParsedFragment {
+  readonly declaredKey: string;
+  readonly content: string;
+  readonly workItemIds: readonly string[];
+  readonly reflectionTargets: readonly string[];
+}
+
+interface ParsedFragmentSet {
+  readonly fragments: readonly ParsedFragment[];
+  readonly validPrelude: boolean;
+}
+
+const corpusRoleOf = (filePath: string): DesignFragmentCorpusRole | null => {
+  if (filePath.startsWith("docs/product/")) return "product";
+  if (filePath.startsWith("docs/inception/")) return "inception";
+  return null;
+};
+
+const uniqueSorted = (values: readonly string[]): readonly string[] =>
+  Object.freeze([...new Set(values)].sort(compare));
+
+const parseFragments = (text: string): ParsedFragmentSet => {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const markers: { readonly index: number; readonly key: string }[] = [];
+  let activeFence: string | null = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const fence = FENCE.exec(lines[index]);
+    if (fence) {
+      const character = fence[1][0];
+      activeFence = activeFence === null ? character : activeFence === character ? null : activeFence;
+      continue;
+    }
+    if (activeFence !== null) continue;
+    const marker = FRAGMENT.exec(lines[index]);
+    if (marker) markers.push({ index, key: marker[1] });
+  }
+
+  let validPrelude = true;
+  const fragments = markers.flatMap((marker, markerIndex): readonly ParsedFragment[] => {
+    const end = markers[markerIndex + 1]?.index ?? lines.length;
+    let headingIndex = marker.index + 1;
+    while (headingIndex < end && (WORK_ITEM.test(lines[headingIndex]) || REFLECTS.test(lines[headingIndex]))) {
+      headingIndex += 1;
+    }
+    if (headingIndex >= end || !HEADING.test(lines[headingIndex])) {
+      validPrelude = false;
+      return [];
+    }
+    const metadata = lines.slice(marker.index, headingIndex);
+    return [
+      Object.freeze({
+        declaredKey: marker.key,
+        content: lines.slice(marker.index, end).join("\n"),
+        workItemIds: uniqueSorted(metadata.flatMap((line) => WORK_ITEM.exec(line)?.[1].match(/\bWI-\d+\b/g) ?? [])),
+        reflectionTargets: uniqueSorted(metadata.flatMap((line) => REFLECTS.exec(line)?.[1] ?? [])),
+      }),
+    ];
+  });
+  return Object.freeze({ fragments: Object.freeze(fragments), validPrelude });
+};
+
+const indexByKey = (fragments: readonly ParsedFragment[]): Map<string, ParsedFragment> | null => {
+  const result = new Map<string, ParsedFragment>();
+  for (const fragment of fragments) {
+    if (result.has(fragment.declaredKey)) return null;
+    result.set(fragment.declaredKey, fragment);
+  }
+  return result;
+};
+
+export class GitStagedDesignChangeAdapter implements StagedDesignChangeSourcePort {
+  constructor(private readonly rootDir: string) {}
+
+  async observe(stagedFiles: readonly string[]): Promise<DesignChangeReadResultDto> {
+    const fragments: ChangedDesignFragmentDto[] = [];
+    const diagnostics: DesignChangeReadDiagnosticDto[] = [];
+    for (const filePath of [...new Set(stagedFiles)].sort(compare)) {
+      const corpusRole = corpusRoleOf(filePath);
+      if (corpusRole === null || !filePath.endsWith(".md")) continue;
+      const beforeText = this.readBlob(`HEAD:${filePath}`);
+      const afterText = this.readBlob(`:${filePath}`);
+      if (beforeText === null && afterText === null) {
+        diagnostics.push(Object.freeze({ code: "staged-design-content-unavailable", path: filePath }));
+        continue;
+      }
+      const beforeParsed = parseFragments(beforeText ?? "");
+      const afterParsed = parseFragments(afterText ?? "");
+      if (!beforeParsed.validPrelude || !afterParsed.validPrelude) {
+        diagnostics.push(Object.freeze({ code: "invalid-staged-fragment-prelude", path: filePath }));
+        continue;
+      }
+      const before = indexByKey(beforeParsed.fragments);
+      const after = indexByKey(afterParsed.fragments);
+      if (before === null || after === null) {
+        diagnostics.push(Object.freeze({ code: "duplicate-staged-fragment-key", path: filePath }));
+        continue;
+      }
+      const keys = uniqueSorted([...before.keys(), ...after.keys()]);
+      for (const key of keys) {
+        const oldFragment = before.get(key);
+        const newFragment = after.get(key);
+        if (oldFragment?.content === newFragment?.content) continue;
+        const observed = newFragment ?? oldFragment;
+        if (!observed) continue;
+        fragments.push(
+          Object.freeze({
+            corpusRole,
+            declaredKey: key,
+            path: filePath,
+            changeKind: oldFragment === undefined ? "added" : newFragment === undefined ? "deleted" : "modified",
+            workItemIds: observed.workItemIds,
+            reflectionTargets: observed.reflectionTargets,
+          }),
+        );
+      }
+    }
+    if (diagnostics.length > 0) {
+      return Object.freeze({ state: "unavailable", diagnostics: Object.freeze(diagnostics) });
+    }
+    return Object.freeze({ state: "available", fragments: Object.freeze(fragments), diagnostics: Object.freeze([]) });
+  }
+
+  private readBlob(spec: string): string | null {
+    try {
+      return execFileSync("git", ["show", spec], {
+        cwd: this.rootDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        maxBuffer: 8 * 1024 * 1024,
+      });
+    } catch {
+      return null;
+    }
+  }
+}

package/scripts/harness/traceability-model/infrastructure/parsers/story-catalog-parser.ts

@@ -10,20 +10,29 @@ export interface ParsedStoryCatalog {
   readonly aliasMap: ReadonlyMap<string, string>;
 }
 
+export interface ParsedStoryCatalogEntry {
+  readonly storyId: string;
+  readonly legacyIds: readonly string[];
+  readonly lineNumber: number;
+  readonly acceptanceCriteria: readonly {
+    readonly acId: string;
+    readonly lineNumber: number;
+  }[];
+}
+
 const STORY_ID_LINE_PATTERN = /\bH(?:F\d+|[0-9]{2})-[0-9]{2}\b/g;
-const TABLE_ALIAS_PATTERN =
-  /\|\s*(H(?:F\d+|[0-9]{2})-[0-9]{2})\s*\|.*?\|\s*(US-[0-9]{3})\s*\|/g;
+const TABLE_ALIAS_PATTERN = /\|\s*(H(?:F\d+|[0-9]{2})-[0-9]{2})\s*\|.*?\|\s*(US-[0-9]{3})\s*\|/g;
 // 旧US ラベルは Markdown 強調（**旧US**:）で囲まれることがあるため `\**` を許容する。
-const INLINE_ALIAS_PATTERN =
-  /(H(?:F\d+|[0-9]{2})-[0-9]{2}).*?旧US\**\s*[:：]\s*(US-[0-9]{3})/g;
+const INLINE_ALIAS_PATTERN = /(H(?:F\d+|[0-9]{2})-[0-9]{2}).*?旧US\**\s*[:：]\s*(US-[0-9]{3})/g;
 
 function execAll(pattern: RegExp, text: string): RegExpExecArray[] {
   const results: RegExpExecArray[] = [];
-  let match: RegExpExecArray | null;
   // Reset lastIndex to ensure clean iteration
   pattern.lastIndex = 0;
-  while ((match = pattern.exec(text)) !== null) {
+  let match = pattern.exec(text);
+  while (match !== null) {
     results.push(match);
+    match = pattern.exec(text);
   }
   return results;
 }
@@ -37,7 +46,7 @@ export function parseStoryCatalog(content: string): ParsedStoryCatalog {
   const aliasMap = new Map<string, string>();
 
   // 正規StoryIdを収集
-  const lines = content.split('\n');
+  const lines = content.split("\n");
   for (const line of lines) {
     const matches = execAll(STORY_ID_LINE_PATTERN, line);
     for (let j = 0; j < matches.length; j++) {
@@ -88,10 +97,79 @@ export function parseStoryCatalog(content: string): ParsedStoryCatalog {
   }
 
   const storyIds: string[] = [];
-  storyIdSet.forEach((id) => storyIds.push(id));
+  storyIdSet.forEach((id) => {
+    storyIds.push(id);
+  });
 
   return {
     storyIds: Object.freeze(storyIds),
     aliasMap,
   };
 }
+
+/**
+ * Story headingをowner locatorとして、heading scope内のlegacy IDとACを構造化する。
+ * `####`以下はStory内の補足見出しとして扱い、次のlevel 1-3見出しでscopeを閉じる。
+ */
+export function parseStoryCatalogEntries(content: string): readonly ParsedStoryCatalogEntry[] {
+  const lines = content.split(/\r?\n/);
+  const STORY_HEADING_PATTERN = /^###\s+(H(?:F\d+|[0-9]{2})-[0-9]{2})\b/;
+  const CLOSING_HEADING_PATTERN = /^#{1,3}\s+/;
+  const LEGACY_PATTERN = /旧US\**\s*[:：]\s*(US-[0-9]{3})/;
+  const AC_PATTERN = /^\s*-\s*\[[ xX]\]\s*(AC-[0-9]+)\s*[:：]/;
+  const entries: {
+    storyId: string;
+    legacyIds: string[];
+    lineNumber: number;
+    acceptanceCriteria: { acId: string; lineNumber: number }[];
+  }[] = [];
+  let current:
+    | {
+        storyId: string;
+        legacyIds: string[];
+        lineNumber: number;
+        acceptanceCriteria: { acId: string; lineNumber: number }[];
+      }
+    | undefined;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const storyHeading = STORY_HEADING_PATTERN.exec(line);
+    if (storyHeading) {
+      current = {
+        storyId: storyHeading[1],
+        legacyIds: [],
+        lineNumber: index + 1,
+        acceptanceCriteria: [],
+      };
+      entries.push(current);
+      continue;
+    }
+    if (CLOSING_HEADING_PATTERN.test(line)) {
+      current = undefined;
+      continue;
+    }
+    if (!current) continue;
+
+    const legacy = LEGACY_PATTERN.exec(line);
+    if (legacy && !current.legacyIds.includes(legacy[1])) {
+      current.legacyIds.push(legacy[1]);
+    }
+    const acceptanceCriterion = AC_PATTERN.exec(line);
+    if (acceptanceCriterion) {
+      current.acceptanceCriteria.push({
+        acId: acceptanceCriterion[1],
+        lineNumber: index + 1,
+      });
+    }
+  }
+
+  return entries.map((entry) => ({
+    storyId: entry.storyId,
+    legacyIds: [...entry.legacyIds],
+    lineNumber: entry.lineNumber,
+    acceptanceCriteria: entry.acceptanceCriteria.map((criterion) => ({
+      ...criterion,
+    })),
+  }));
+}

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

@@ -4,6 +4,7 @@
  *
  * RunL2ValidatorsUseCase — H08-01: L2バリデータ実行
  * @work-item-id WI-110 / WI-111 / WI-140 / WI-132 / WI-133 / WI-136 / WI-137 / WI-138
+ * @work-item-id WI-301
  */
 import { readFile } from "node:fs/promises";
 import type { CliCommandRegistryPort } from "../../domain/ports/cli-command-registry-port.js";
@@ -15,6 +16,7 @@ import type { PhaseGatePolicyPort } from "../../domain/ports/phase-gate-policy-p
 import type { TestQualityAnalyzerPort } from "../../domain/ports/test-quality-analyzer-port.js";
 import type { ValidatorConfigPort } from "../../domain/ports/validator-config-port.js";
 import type { WorkItemStatusPolicyPort } from "../../domain/ports/work-item-status-policy-port.js";
+import type { WorldConstraintAdmissionPolicyPort } from "../../domain/ports/world-constraint-admission-policy-port.js";
 import { CliE2eTestExistenceService } from "../../domain/services/cli-e2e-test-existence-service.js";
 import { ContractTraceabilityCoverageService } from "../../domain/services/contract-traceability-coverage-service.js";
 import { CoverageAttestationGatingService } from "../../domain/services/coverage-attestation-gating-service.js";
@@ -23,6 +25,7 @@ import {
   type ValidatorExecutionService,
 } from "../../domain/services/validator-execution-service.js";
 import type { ValidatorRegistry } from "../../domain/services/validator-registry.js";
+import { WorldConstraintAdmissionService } from "../../domain/services/world-constraint-admission-service.js";
 import { type HarnessErrorLike, ValidationResult } from "../../domain/value-objects/validation-result.js";
 import { ValidatorId } from "../../domain/value-objects/validator-id.js";
 import type { RunL2ValidatorsInput } from "../dto/run-l2-validators-input.js";
@@ -42,6 +45,7 @@ export interface RunL2ValidatorsUseCaseDeps {
   workItemStatusPolicyPort?: WorkItemStatusPolicyPort;
   contractTraceabilityPolicyPort?: ContractTraceabilityPolicyPort;
   coverageAttestationGatingPolicyPort?: CoverageAttestationGatingPolicyPort;
+  worldConstraintAdmissionPolicyPort?: WorldConstraintAdmissionPolicyPort;
 }
 
 export class RunL2ValidatorsUseCase {
@@ -57,9 +61,11 @@ export class RunL2ValidatorsUseCase {
   private readonly workItemStatusPolicyPort?: WorkItemStatusPolicyPort;
   private readonly contractTraceabilityPolicyPort?: ContractTraceabilityPolicyPort;
   private readonly coverageAttestationGatingPolicyPort?: CoverageAttestationGatingPolicyPort;
+  private readonly worldConstraintAdmissionPolicyPort?: WorldConstraintAdmissionPolicyPort;
   private readonly cliE2eTestExistenceService = new CliE2eTestExistenceService();
   private readonly contractTraceabilityCoverageService = new ContractTraceabilityCoverageService();
   private readonly coverageAttestationGatingService = new CoverageAttestationGatingService();
+  private readonly worldConstraintAdmissionService = new WorldConstraintAdmissionService();
 
   constructor(deps: RunL2ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -74,6 +80,7 @@ export class RunL2ValidatorsUseCase {
     this.workItemStatusPolicyPort = deps.workItemStatusPolicyPort;
     this.contractTraceabilityPolicyPort = deps.contractTraceabilityPolicyPort;
     this.coverageAttestationGatingPolicyPort = deps.coverageAttestationGatingPolicyPort;
+    this.worldConstraintAdmissionPolicyPort = deps.worldConstraintAdmissionPolicyPort;
   }
 
   async execute(input: RunL2ValidatorsInput): Promise<readonly ValidationResultContract[]> {
@@ -241,6 +248,30 @@ export class RunL2ValidatorsUseCase {
       }
     }
 
+    if (this.worldConstraintAdmissionPolicyPort) {
+      const l2017Result = overrideMap.get("L2-017");
+      if (l2017Result && !l2017Result.skipped) {
+        const observation = await this.worldConstraintAdmissionPolicyPort.collect();
+        const findings = this.worldConstraintAdmissionService.evaluate(observation);
+        if (findings.length > 0) {
+          const errors: HarnessErrorLike[] = findings.map((finding) => ({
+            code: { value: "L2-017", toString: () => "L2-017" },
+            severity: { value: finding.severity, toString: () => finding.severity },
+            message: finding.message,
+            suggestion: finding.suggestion,
+            ruleId: finding.ruleId,
+            violationFingerprint: finding.violationFingerprint,
+            constraintId: finding.constraintId,
+            classification: finding.classification,
+            sourcePath: finding.sourcePath,
+          }));
+          overrideMap.set("L2-017", ValidationResult.fail(ValidatorId.create("L2-017"), errors, 0));
+        } else {
+          overrideMap.set("L2-017", ValidationResult.pass(ValidatorId.create("L2-017"), 0));
+        }
+      }
+    }
+
     const finalResults = definitions.map(
       (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
     );

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

@@ -2,6 +2,7 @@
  * @layer application
  * @unit validator-system
  * @work-item-id WI-212
+ * @work-item-id WI-302
  *
  * RunL3ValidatorsUseCase — H08-02: L3バリデータ実行
  */
@@ -13,6 +14,7 @@ import type { InjectionScanPolicyPort } from "../../domain/ports/injection-scan-
 import type { PerformanceScannerPort } from "../../domain/ports/performance-scanner-port.js";
 import type { SecurityPatternScannerPort } from "../../domain/ports/security-pattern-scanner-port.js";
 import type { ValidatorConfigPort } from "../../domain/ports/validator-config-port.js";
+import type { WorldConstraintRederivationPolicyPort } from "../../domain/ports/world-constraint-rederivation-policy-port.js";
 import { CoverageAttestationVerificationService } from "../../domain/services/coverage-attestation-verification-service.js";
 import { InjectionPatternScanService } from "../../domain/services/injection-pattern-scan-service.js";
 import {
@@ -20,6 +22,7 @@ import {
   type ValidatorExecutionService,
 } from "../../domain/services/validator-execution-service.js";
 import { ValidatorLanguageCapabilityService } from "../../domain/services/validator-language-capability-service.js";
+import { WorldConstraintRederivationService } from "../../domain/services/world-constraint-rederivation-service.js";
 import type { ValidatorRegistry } from "../../domain/services/validator-registry.js";
 import type { HarnessErrorLike } from "../../domain/value-objects/validation-result.js";
 import { ValidationResult } from "../../domain/value-objects/validation-result.js";
@@ -54,6 +57,8 @@ export interface RunL3ValidatorsUseCaseDeps {
   injectionScanPolicyPort?: InjectionScanPolicyPort;
   /** WI-268 / ADR-030 §Decision.1・§Decision.3.② 第2段: L3-007 (coverage-attestation-verification, fail-closed) 用ポート。 */
   coverageAttestationVerificationPolicyPort?: CoverageAttestationVerificationPolicyPort;
+  /** WI-302: L3-008 authoritative World clean-corpus re-derivation port. */
+  worldConstraintRederivationPolicyPort?: WorldConstraintRederivationPolicyPort;
   /** L3-005 のスコープ対象 story-id（config layers.L3.acBoundStories 由来。既定 []）。 */
   acBoundStories?: readonly string[];
 }
@@ -70,10 +75,12 @@ export class RunL3ValidatorsUseCase {
   private readonly performanceScannerPort?: PerformanceScannerPort;
   private readonly injectionScanPolicyPort?: InjectionScanPolicyPort;
   private readonly coverageAttestationVerificationPolicyPort?: CoverageAttestationVerificationPolicyPort;
+  private readonly worldConstraintRederivationPolicyPort?: WorldConstraintRederivationPolicyPort;
   private readonly acBoundStories: readonly string[];
   private readonly languageCapabilityService = new ValidatorLanguageCapabilityService();
   private readonly injectionScanService = new InjectionPatternScanService();
   private readonly coverageAttestationVerificationService = new CoverageAttestationVerificationService();
+  private readonly worldConstraintRederivationService = new WorldConstraintRederivationService();
 
   constructor(deps: RunL3ValidatorsUseCaseDeps) {
     this.registry = deps.validatorRegistry;
@@ -87,6 +94,7 @@ export class RunL3ValidatorsUseCase {
     this.performanceScannerPort = deps.performanceScannerPort;
     this.injectionScanPolicyPort = deps.injectionScanPolicyPort;
     this.coverageAttestationVerificationPolicyPort = deps.coverageAttestationVerificationPolicyPort;
+    this.worldConstraintRederivationPolicyPort = deps.worldConstraintRederivationPolicyPort;
     this.acBoundStories = deps.acBoundStories ?? [];
   }
 
@@ -305,6 +313,32 @@ export class RunL3ValidatorsUseCase {
       }
     }
 
+    // WI-302 / ADR-030 trust root: L3-008 independently re-derives World obligations from the
+    // current corpus and versioned control declarations. The adapter has no persisted-report input.
+    if (this.worldConstraintRederivationPolicyPort) {
+      const l3008Result = overrideMap.get("L3-008");
+      if (l3008Result && !l3008Result.skipped) {
+        const observation = await this.worldConstraintRederivationPolicyPort.collect();
+        const findings = this.worldConstraintRederivationService.evaluate(observation);
+        if (findings.length > 0) {
+          const errors: HarnessErrorLike[] = findings.map((finding) => ({
+            code: { value: "L3-008", toString: () => "L3-008" },
+            severity: { value: finding.severity, toString: () => finding.severity },
+            message: finding.message,
+            suggestion: finding.suggestion,
+            sourcePath: finding.sourcePath,
+            ruleId: finding.ruleId,
+            violationFingerprint: finding.violationFingerprint,
+            constraintId: finding.constraintId,
+            classification: finding.classification,
+          }));
+          overrideMap.set("L3-008", ValidationResult.fail(ValidatorId.create("L3-008"), errors, 0));
+        } else {
+          overrideMap.set("L3-008", ValidationResult.pass(ValidatorId.create("L3-008"), 0));
+        }
+      }
+    }
+
     const finalResults = definitions.map(
       (definition) => overrideMap.get(definition.validatorId.value) ?? ValidationResult.skip(definition.validatorId),
     );