phasegate 0.229.0 → 0.264.0

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

@@ -5,6 +5,9 @@
  * DI 組み立て — validator-system の全依存関係を構築する
  * @work-item-id WI-110 / WI-111 / WI-132 / WI-133 / WI-136 / WI-137 / WI-138 / WI-156
  * @work-item-id WI-217
+ * @work-item-id WI-301
+ * @work-item-id WI-302
+ * @work-item-id WI-305
  */
 
 import { join } from "node:path";
@@ -17,6 +20,7 @@ import { RunL2ValidatorsUseCase } from "./application/use-cases/run-l2-validator
 import { RunL3ValidatorsUseCase } from "./application/use-cases/run-l3-validators-usecase.js";
 import { RunL4ValidatorsUseCase } from "./application/use-cases/run-l4-validators-usecase.js";
 import { RunQuickModeUseCase } from "./application/use-cases/run-quick-mode-usecase.js";
+import { DesignChangeDeclarationPolicy } from "./domain/services/design-change-declaration-policy.js";
 import {
   ArchitectureSemanticAnalysisService,
   type ArchitectureSemanticPolicy,
@@ -55,6 +59,8 @@ import { PhaseDependencyPhaseGatePolicyAdapter } from "./infrastructure/adapters
 import { SourceFileTextScannerAdapter } from "./infrastructure/adapters/source-file-text-scanner-adapter.js";
 import { TraceabilityMetadataPolicyAdapter } from "./infrastructure/adapters/traceability-metadata-policy-adapter.js";
 import { TraceabilityWorkItemStatusPolicyAdapter } from "./infrastructure/adapters/traceability-work-item-status-policy-adapter.js";
+import { WorldModelConstraintAdmissionAdapter } from "./infrastructure/adapters/world-model-constraint-admission-adapter.js";
+import { WorldModelConstraintRederivationAdapter } from "./infrastructure/adapters/world-model-constraint-rederivation-adapter.js";
 import { ReportValidationResultsHandler } from "./presentation/handlers/report-validation-results-handler.js";
 import { RunQuickModeHandler } from "./presentation/handlers/run-quick-mode-handler.js";
 import { RunValidatorsHandler } from "./presentation/handlers/run-validators-handler.js";
@@ -99,12 +105,6 @@ const DEFAULT_CONFIG = {
 
 /** バリデータ定義カタログ */
 export function buildDefaultRegistry(): ValidatorRegistry {
-  const defaultRule = ValidationRule.create({
-    ruleName: "default-rule",
-    errorTemplate: { code: "L2-001", severity: "error", messageTemplate: "{{message}}" },
-    fixExample: null,
-  });
-
   const createDef = (
     id: string,
     layer: "L2" | "L3" | "L4",
@@ -134,6 +134,7 @@ export function buildDefaultRegistry(): ValidatorRegistry {
     createDef("L2-015", "L2", "always", "ContractTraceabilityPolicyPort"),
     // WI-258 / ADR-030 §Decision.3.②: L2-016 (coverage-attestation-gating, fail-closed, default-ON)。
     createDef("L2-016", "L2", "always", "CoverageAttestationGatingPolicyPort"),
+    createDef("L2-017", "L2", "always", "WorldConstraintAdmissionPolicyPort"),
     createDef("L3-001", "L3", "always"),
     createDef("L3-002", "L3", "strictOnly"),
     createDef("L3-003", "L3", "always"),
@@ -146,6 +147,7 @@ export function buildDefaultRegistry(): ValidatorRegistry {
     // WI-268 / ADR-030 §Decision.1・§Decision.3.② 第2段: L3-007 (coverage-attestation-verification)
     // は fail-closed / default-ON。L2-016 の authoritative 相棒。
     createDef("L3-007", "L3", "always", "CoverageAttestationVerificationPolicyPort"),
+    createDef("L3-008", "L3", "always", "WorldConstraintRederivationPolicyPort"),
     createDef("L4-001", "L4", "always"),
     createDef("L4-002", "L4", "always"),
     createDef("L4-003", "L4", "strictOnly"),
@@ -170,6 +172,7 @@ export interface ValidatorSystemModule {
   aggregateValidationResultsUseCase: AggregateValidationResultsUseCase;
   runFullValidationUseCase: RunFullValidationUseCase;
   driftDetectionService: DriftDetectionService;
+  designChangeDeclarationPolicy: DesignChangeDeclarationPolicy;
   handlers: {
     runValidators: RunValidatorsHandler;
     runQuickMode: RunQuickModeHandler;
@@ -184,6 +187,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   const defaultFailOnWarning = configData.validate?.failOnWarning ?? false;
   const registry = buildDefaultRegistry();
   const executionService = new ValidatorExecutionService({ configPort });
+  const designChangeDeclarationPolicy = new DesignChangeDeclarationPolicy();
   const contractMapper = new ValidationResultContractMapper();
   const phaseGatePolicyPort = new PhaseDependencyPhaseGatePolicyAdapter();
   const metadataPolicyPort = new TraceabilityMetadataPolicyAdapter();
@@ -201,6 +205,14 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
   // WI-258 / ADR-030 §Decision.3.②: L2-016 (coverage-attestation-gating) 用アダプタ。
   // docs/product/construction/*​/coverage_report.md を cwd 起点で走査する（targetPaths 非依存）。
   const coverageAttestationGatingPolicyPort = new FileSystemCoverageAttestationGatingAdapter(process.cwd());
+  const worldConstraintAdmissionPolicyPort = new WorldModelConstraintAdmissionAdapter({
+    rootDir: process.cwd(),
+    resolvedConfig: (configData as { world?: import("../world-model/index.js").WorldResolvedConfigInput }).world,
+  });
+  const worldConstraintRederivationPolicyPort = new WorldModelConstraintRederivationAdapter({
+    rootDir: process.cwd(),
+    resolvedConfig: (configData as { world?: import("../world-model/index.js").WorldResolvedConfigInput }).world,
+  });
   // WI-259 / ADR-030 §Decision.3.④: L3-006 (injection-scan, advisory) 用アダプタ。
   // 指示搭載ファイル群（skills/**​/SKILL.md / CLAUDE.md / AGENTS.md / agent-context / .claude/settings.json）を
   // cwd 起点で走査する（targetPaths 非依存）。
@@ -249,6 +261,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     workItemStatusPolicyPort,
     contractTraceabilityPolicyPort,
     coverageAttestationGatingPolicyPort,
+    worldConstraintAdmissionPolicyPort,
   });
 
   // WI-227 / H16-03: L3-005 のスコープ対象 story-id を config から取得（既定 []）。
@@ -267,6 +280,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     performanceScannerPort,
     injectionScanPolicyPort,
     coverageAttestationVerificationPolicyPort,
+    worldConstraintRederivationPolicyPort,
     acBoundStories,
   });
 
@@ -367,6 +381,7 @@ export function createValidatorSystemModule(config?: object): ValidatorSystemMod
     aggregateValidationResultsUseCase,
     runFullValidationUseCase,
     driftDetectionService,
+    designChangeDeclarationPolicy,
     handlers,
   };
 }

package/scripts/harness/validator-system/domain/ports/world-constraint-admission-policy-port.ts

@@ -0,0 +1,28 @@
+// @unit validator-system
+// @layer domain
+// @work-item-id WI-301
+
+export type WorldAdmissionClassification = "adopted-legacy" | "new-structural" | "invalid-declaration" | "waived";
+
+export interface WorldConstraintAdmissionObligation {
+  readonly ruleId: string;
+  readonly violationFingerprint: string;
+  readonly constraintId: string | null;
+  readonly classification: WorldAdmissionClassification;
+}
+
+export interface WorldConstraintAdmissionDiagnostic {
+  readonly code: string;
+  readonly path: string;
+  readonly message: string;
+  readonly scope: "constraint" | "other";
+}
+
+export interface WorldConstraintAdmissionObservation {
+  readonly obligations: readonly WorldConstraintAdmissionObligation[];
+  readonly diagnostics: readonly WorldConstraintAdmissionDiagnostic[];
+}
+
+export interface WorldConstraintAdmissionPolicyPort {
+  collect(): Promise<WorldConstraintAdmissionObservation>;
+}

package/scripts/harness/validator-system/domain/ports/world-constraint-rederivation-policy-port.ts

@@ -0,0 +1,11 @@
+// @unit validator-system
+// @layer domain
+// @work-item-id WI-302
+
+import type { WorldConstraintAdmissionObservation } from "./world-constraint-admission-policy-port.js";
+
+export type WorldConstraintRederivationObservation = WorldConstraintAdmissionObservation;
+
+export interface WorldConstraintRederivationPolicyPort {
+  collect(): Promise<WorldConstraintRederivationObservation>;
+}

package/scripts/harness/validator-system/domain/services/design-change-declaration-policy.ts

@@ -0,0 +1,75 @@
+// @unit validator-system
+// @layer domain
+// @work-item-id WI-305
+
+export interface DesignChangedFragmentInput {
+  readonly corpusRole: "product" | "inception";
+  readonly declaredKey: string;
+  readonly path: string;
+  readonly workItemIds: readonly string[];
+}
+
+export interface DesignPinnedEndpointInput {
+  readonly constraintId: string;
+  readonly endpoint: "claimant" | "premise";
+  readonly corpusRole: "product" | "inception";
+  readonly declaredKey: string;
+}
+
+export interface DesignChangeDeclarationFinding {
+  readonly code: "design-change-declaration-missing";
+  readonly corpusRole: "product" | "inception";
+  readonly declaredKey: string;
+  readonly path: string;
+  readonly expectedWorkItemIds: readonly string[];
+  readonly constraintIds: readonly string[];
+}
+
+export interface DesignChangeDeclarationEvaluation {
+  readonly checkedFragmentCount: number;
+  readonly findings: readonly DesignChangeDeclarationFinding[];
+}
+
+export interface DesignChangeDeclarationInput {
+  readonly changedFragments: readonly DesignChangedFragmentInput[];
+  readonly pinnedEndpoints: readonly DesignPinnedEndpointInput[];
+  readonly trailerWorkItemIds: readonly string[];
+}
+
+const compare = (left: string, right: string): number => (left < right ? -1 : left > right ? 1 : 0);
+const keyOf = (value: { readonly corpusRole: string; readonly declaredKey: string }): string =>
+  `${value.corpusRole}\u0000${value.declaredKey}`;
+const uniqueSorted = (values: readonly string[]): readonly string[] =>
+  Object.freeze([...new Set(values)].sort(compare));
+
+export class DesignChangeDeclarationPolicy {
+  evaluate(input: DesignChangeDeclarationInput): DesignChangeDeclarationEvaluation {
+    const endpointsByFragment = new Map<string, DesignPinnedEndpointInput[]>();
+    for (const endpoint of input.pinnedEndpoints) {
+      const key = keyOf(endpoint);
+      const current = endpointsByFragment.get(key) ?? [];
+      current.push(endpoint);
+      endpointsByFragment.set(key, current);
+    }
+    const trailerIds = new Set(input.trailerWorkItemIds);
+    const pinnedChanges = input.changedFragments
+      .filter((fragment) => endpointsByFragment.has(keyOf(fragment)))
+      .sort((left, right) => compare(keyOf(left), keyOf(right)) || compare(left.path, right.path));
+    const findings = pinnedChanges.flatMap((fragment): readonly DesignChangeDeclarationFinding[] => {
+      if (fragment.workItemIds.some((workItemId) => trailerIds.has(workItemId))) return [];
+      return [
+        Object.freeze({
+          code: "design-change-declaration-missing" as const,
+          corpusRole: fragment.corpusRole,
+          declaredKey: fragment.declaredKey,
+          path: fragment.path,
+          expectedWorkItemIds: uniqueSorted(fragment.workItemIds),
+          constraintIds: uniqueSorted(
+            (endpointsByFragment.get(keyOf(fragment)) ?? []).map((endpoint) => endpoint.constraintId),
+          ),
+        }),
+      ];
+    });
+    return Object.freeze({ checkedFragmentCount: pinnedChanges.length, findings: Object.freeze(findings) });
+  }
+}

package/scripts/harness/validator-system/domain/services/world-constraint-admission-service.ts

@@ -0,0 +1,78 @@
+// @unit validator-system
+// @layer domain
+// @work-item-id WI-301
+
+import type {
+  WorldAdmissionClassification,
+  WorldConstraintAdmissionObservation,
+} from "../ports/world-constraint-admission-policy-port.js";
+
+export interface WorldConstraintAdmissionFinding {
+  readonly severity: "error" | "warning";
+  readonly ruleId: string | null;
+  readonly violationFingerprint: string | null;
+  readonly constraintId: string | null;
+  readonly classification: WorldAdmissionClassification | "constraint-input-invalid" | "local-evaluation-incomplete";
+  readonly message: string;
+  readonly suggestion: string;
+  readonly sourcePath: string | null;
+}
+
+const LOCAL_TRUST_NOTICE = "Local L2 evidence can be forged; authoritative L3 re-derivation is required.";
+const AUTHORITATIVE_SUGGESTION =
+  "Repair the declaration or structural finding, then rely on authoritative L3 clean-corpus re-derivation.";
+
+const compareNullable = (left: string | null, right: string | null): number =>
+  (left ?? "") < (right ?? "") ? -1 : (left ?? "") > (right ?? "") ? 1 : 0;
+
+export class WorldConstraintAdmissionService {
+  evaluate(observation: WorldConstraintAdmissionObservation): readonly WorldConstraintAdmissionFinding[] {
+    const obligationFindings = observation.obligations.map((obligation): WorldConstraintAdmissionFinding => {
+      const blocking =
+        obligation.classification === "new-structural" || obligation.classification === "invalid-declaration";
+      const label =
+        obligation.classification === "invalid-declaration"
+          ? "non-adoptable invalid World constraint declaration"
+          : obligation.classification === "new-structural"
+            ? "new World structural violation"
+            : obligation.classification === "adopted-legacy"
+              ? "adopted legacy World violation"
+              : "actively waived World violation";
+      return Object.freeze({
+        severity: blocking ? "error" : "warning",
+        ruleId: obligation.ruleId,
+        violationFingerprint: obligation.violationFingerprint,
+        constraintId: obligation.constraintId,
+        classification: obligation.classification,
+        message: `L2 local fast-path reports ${label}: ${obligation.ruleId} ${obligation.violationFingerprint}. ${LOCAL_TRUST_NOTICE}`,
+        suggestion: AUTHORITATIVE_SUGGESTION,
+        sourcePath: null,
+      });
+    });
+    const diagnosticFindings = observation.diagnostics.map((item): WorldConstraintAdmissionFinding => {
+      const constraintInput = item.scope === "constraint";
+      return Object.freeze({
+        severity: constraintInput ? "error" : "warning",
+        ruleId: constraintInput ? "WCR-001" : null,
+        violationFingerprint: null,
+        constraintId: null,
+        classification: constraintInput ? "constraint-input-invalid" : "local-evaluation-incomplete",
+        message: constraintInput
+          ? `L2 local fast-path cannot admit constraint declaration input (${item.code}): ${item.message}. ${LOCAL_TRUST_NOTICE}`
+          : `L2 local fast-path could not complete non-constraint policy observation (${item.code}): ${item.message}. ${LOCAL_TRUST_NOTICE}`,
+        suggestion: AUTHORITATIVE_SUGGESTION,
+        sourcePath: item.path,
+      });
+    });
+
+    return Object.freeze(
+      [...obligationFindings, ...diagnosticFindings].sort(
+        (left, right) =>
+          compareNullable(left.ruleId, right.ruleId) ||
+          compareNullable(left.violationFingerprint, right.violationFingerprint) ||
+          compareNullable(left.sourcePath, right.sourcePath) ||
+          left.classification.localeCompare(right.classification),
+      ),
+    );
+  }
+}

package/scripts/harness/validator-system/domain/services/world-constraint-rederivation-service.ts

@@ -0,0 +1,76 @@
+// @unit validator-system
+// @layer domain
+// @work-item-id WI-302
+
+import type { WorldAdmissionClassification } from "../ports/world-constraint-admission-policy-port.js";
+import type { WorldConstraintRederivationObservation } from "../ports/world-constraint-rederivation-policy-port.js";
+
+export interface WorldConstraintRederivationFinding {
+  readonly severity: "error" | "warning";
+  readonly ruleId: string | null;
+  readonly violationFingerprint: string | null;
+  readonly constraintId: string | null;
+  readonly classification:
+    | WorldAdmissionClassification
+    | "constraint-input-invalid"
+    | "authoritative-evaluation-failed";
+  readonly message: string;
+  readonly suggestion: string;
+  readonly sourcePath: string | null;
+}
+
+const REPAIR_SUGGESTION =
+  "Repair the versioned declaration or current corpus finding, then rerun authoritative L3 clean-corpus re-derivation.";
+
+const compareNullable = (left: string | null, right: string | null): number =>
+  (left ?? "") < (right ?? "") ? -1 : (left ?? "") > (right ?? "") ? 1 : 0;
+
+export class WorldConstraintRederivationService {
+  evaluate(observation: WorldConstraintRederivationObservation): readonly WorldConstraintRederivationFinding[] {
+    const obligationFindings = observation.obligations.map((obligation): WorldConstraintRederivationFinding => {
+      const blocking =
+        obligation.classification === "new-structural" || obligation.classification === "invalid-declaration";
+      const label =
+        obligation.classification === "invalid-declaration"
+          ? "non-adoptable invalid World constraint declaration"
+          : obligation.classification === "new-structural"
+            ? "new World structural violation"
+            : obligation.classification === "adopted-legacy"
+              ? "adopted legacy World violation"
+              : "actively waived World violation";
+      return Object.freeze({
+        severity: blocking ? "error" : "warning",
+        ruleId: obligation.ruleId,
+        violationFingerprint: obligation.violationFingerprint,
+        constraintId: obligation.constraintId,
+        classification: obligation.classification,
+        message: `L3 authoritative clean-corpus re-derivation reports ${label}: ${obligation.ruleId} ${obligation.violationFingerprint}.`,
+        suggestion: REPAIR_SUGGESTION,
+        sourcePath: null,
+      });
+    });
+    const diagnosticFindings = observation.diagnostics.map((item): WorldConstraintRederivationFinding => {
+      const constraintInput = item.scope === "constraint";
+      return Object.freeze({
+        severity: "error",
+        ruleId: constraintInput ? "WCR-001" : null,
+        violationFingerprint: null,
+        constraintId: null,
+        classification: constraintInput ? "constraint-input-invalid" : "authoritative-evaluation-failed",
+        message: `L3 authoritative clean-corpus re-derivation cannot produce a trustworthy result (${item.code}): ${item.message}.`,
+        suggestion: REPAIR_SUGGESTION,
+        sourcePath: item.path,
+      });
+    });
+
+    return Object.freeze(
+      [...obligationFindings, ...diagnosticFindings].sort(
+        (left, right) =>
+          compareNullable(left.ruleId, right.ruleId) ||
+          compareNullable(left.violationFingerprint, right.violationFingerprint) ||
+          compareNullable(left.sourcePath, right.sourcePath) ||
+          left.classification.localeCompare(right.classification),
+      ),
+    );
+  }
+}

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

@@ -14,6 +14,8 @@
  * WI-258 (ADR-030 §Decision.3.②) で L2-016（coverage-attestation-gating, fail-closed）を追加
  * WI-259 (ADR-030 §Decision.3.④) で L3-006（injection-scan, advisory warning-only）を追加
  * WI-268 (ADR-030 §Decision.1・§Decision.3.② 第2段) で L3-007（coverage-attestation-verification, fail-closed）を追加
+ * WI-301 で L2-017（world-constraint-admission, local fast-path）を追加
+ * WI-302 で L3-008（world-constraint-rederivation, authoritative）を追加
  */
 
 export class InvalidValidatorIdError extends Error {
@@ -38,6 +40,7 @@ const VALIDATOR_NAME_MAP: Record<string, string> = {
   "L2-014": "work-item-status-staleness",
   "L2-015": "contract-traceability-coverage",
   "L2-016": "coverage-attestation-gating",
+  "L2-017": "world-constraint-admission",
   "L3-001": "security",
   "L3-002": "performance",
   "L3-003": "coverage",
@@ -45,6 +48,7 @@ const VALIDATOR_NAME_MAP: Record<string, string> = {
   "L3-005": "ac-bound-coverage",
   "L3-006": "injection-scan",
   "L3-007": "coverage-attestation-verification",
+  "L3-008": "world-constraint-rederivation",
   "L4-001": "drift-detect",
   "L4-002": "consistency-check",
   "L4-003": "dead-code",

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

@@ -3,28 +3,39 @@
  * @unit validator-system
  * @work-item-id WI-156
  * @work-item-id WI-212
+ * @work-item-id WI-301
+ * @work-item-id WI-302
  *
  * HarnessConfigValidatorConfigAdapter — ValidatorConfigPort実装
  * 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';
+
+import type { ValidatorConfigPort } from "../../domain/ports/validator-config-port.js";
+import { LayerConfig } from "../../domain/value-objects/layer-config.js";
+import { ValidatorId } from "../../domain/value-objects/validator-id.js";
 
 export interface HarnessConfigLayers {
   L2?: { enabled?: boolean; validators?: string[]; strictOnly?: boolean; preset?: string };
-  L3?: { enabled?: boolean; validators?: string[]; strictOnly?: boolean; preset?: string; coverageThreshold?: number; bundleSizeLimit?: number };
+  L3?: {
+    enabled?: boolean;
+    validators?: string[];
+    strictOnly?: boolean;
+    preset?: string;
+    coverageThreshold?: number;
+    bundleSizeLimit?: number;
+  };
   L4?: { enabled?: boolean; validators?: string[]; strictOnly?: boolean; preset?: string; deadCodeGC?: boolean };
 }
 
 export interface HarnessConfigV2Like {
-  preset?: 'minimal' | 'standard' | 'strict';
-  project?: { preset?: 'minimal' | 'standard' | 'strict'; languages?: readonly string[] };
+  preset?: "minimal" | "standard" | "strict";
+  project?: { preset?: "minimal" | "standard" | "strict"; languages?: readonly string[] };
   layers?: HarnessConfigLayers;
   harnesses?: {
     bundleSizeLimit?: number;
     deadCodeGC?: boolean;
   };
+  world?: { enabled?: boolean };
 }
 
 export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort {
@@ -34,20 +45,23 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
     this.config = config;
   }
 
-  async getLayerConfig(layer: 'L2' | 'L3' | 'L4'): Promise<LayerConfig> {
-    const preset = (this.config.project?.preset ?? this.config.preset ?? 'standard') as 'minimal' | 'standard' | 'strict';
-    const strictOnly = preset === 'strict';
+  async getLayerConfig(layer: "L2" | "L3" | "L4"): Promise<LayerConfig> {
+    const preset = (this.config.project?.preset ?? this.config.preset ?? "standard") as
+      | "minimal"
+      | "standard"
+      | "strict";
+    const strictOnly = preset === "strict";
     const layerData = this.config.layers?.[layer] ?? {};
 
     const defaultValidators: Record<string, string[]> = {
-      L2: ['L2-001', 'L2-002', 'L2-003', 'L2-013', 'L2-014', 'L2-015'],
-      L3: ['L3-001', 'L3-002', 'L3-003', 'L3-004'],
-      L4: ['L4-001', 'L4-002', 'L4-003', 'L4-004', 'L4-005', 'L4-006'],
+      L2: ["L2-001", "L2-002", "L2-003", "L2-013", "L2-014", "L2-015"],
+      L3: ["L3-001", "L3-002", "L3-003", "L3-004"],
+      L4: ["L4-001", "L4-002", "L4-003", "L4-004", "L4-005", "L4-006"],
     };
 
     const thresholds: Record<string, number> = {};
 
-    if (layer === 'L3') {
+    if (layer === "L3") {
       const l3 = this.config.layers?.L3;
       if (l3?.coverageThreshold !== undefined) thresholds.coverageThreshold = l3.coverageThreshold;
       if (l3?.bundleSizeLimit !== undefined) thresholds.bundleSizeLimit = l3.bundleSizeLimit;
@@ -56,16 +70,24 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
       }
     }
 
-    if (layer === 'L4') {
+    if (layer === "L4") {
       if (this.config.harnesses?.deadCodeGC !== undefined) {
         thresholds.deadCodeGC = this.config.harnesses.deadCodeGC ? 1 : 0;
       }
     }
 
+    const configuredValidatorIds = layerData.validators ?? defaultValidators[layer];
+    const automaticWorldValidatorId = layer === "L2" ? "L2-017" : layer === "L3" ? "L3-008" : null;
+    const selectedValidatorIds =
+      automaticWorldValidatorId === null
+        ? configuredValidatorIds
+        : this.config.world?.enabled === true
+          ? [...configuredValidatorIds, automaticWorldValidatorId]
+          : configuredValidatorIds.filter((validatorId) => validatorId !== automaticWorldValidatorId);
     return LayerConfig.create({
       layer,
       enabled: layerData.enabled !== false,
-      validatorIds: (layerData.validators ?? defaultValidators[layer]).map((idOrName) => this.normalizeValidatorId(idOrName)),
+      validatorIds: [...new Set(selectedValidatorIds.map((idOrName) => this.normalizeValidatorId(idOrName)))],
       thresholds,
       strictOnly: layerData.strictOnly ?? strictOnly,
       preset,
@@ -74,7 +96,7 @@ export class HarnessConfigValidatorConfigAdapter implements ValidatorConfigPort
 
   async getProjectLanguages(): Promise<readonly string[]> {
     const languages = this.config.project?.languages;
-    return languages && languages.length > 0 ? [...languages] : ['typescript'];
+    return languages && languages.length > 0 ? [...languages] : ["typescript"];
   }
 
   private normalizeValidatorId(idOrName: string): string {

package/scripts/harness/validator-system/infrastructure/adapters/world-model-constraint-admission-adapter.ts

@@ -0,0 +1,56 @@
+// @unit validator-system
+// @layer infrastructure
+// @work-item-id WI-301
+
+import { createWorldModelModule, type WorldResolvedConfigInput } from "../../../world-model/index.js";
+import type {
+  WorldConstraintAdmissionObservation,
+  WorldConstraintAdmissionPolicyPort,
+} from "../../domain/ports/world-constraint-admission-policy-port.js";
+
+interface Options {
+  readonly rootDir: string;
+  readonly resolvedConfig?: WorldResolvedConfigInput;
+}
+
+export class WorldModelConstraintAdmissionAdapter implements WorldConstraintAdmissionPolicyPort {
+  constructor(private readonly options: Options) {}
+
+  async collect(): Promise<WorldConstraintAdmissionObservation> {
+    const module = createWorldModelModule({
+      rootDir: this.options.rootDir,
+      resolvedConfig: this.options.resolvedConfig,
+    });
+    const actual = await module.deriveWorldObligationsUseCase.execute({ writeReport: false });
+    const constraintsPath =
+      this.options.resolvedConfig?.declarations?.constraintsPath ?? "phasegate.world-constraints.json";
+    if (actual.status === "execution-failure") {
+      return Object.freeze({
+        obligations: Object.freeze([]),
+        diagnostics: Object.freeze(
+          actual.diagnostics.map((item) =>
+            Object.freeze({
+              code: item.code,
+              path: item.path,
+              message: item.message,
+              scope: item.path === constraintsPath ? ("constraint" as const) : ("other" as const),
+            }),
+          ),
+        ),
+      });
+    }
+    return Object.freeze({
+      obligations: Object.freeze(
+        actual.result.report.structuralObligations.map((item) =>
+          Object.freeze({
+            ruleId: item.ruleId,
+            violationFingerprint: item.violationFingerprint,
+            constraintId: item.constraintId,
+            classification: item.classification,
+          }),
+        ),
+      ),
+      diagnostics: Object.freeze([]),
+    });
+  }
+}

package/scripts/harness/validator-system/infrastructure/adapters/world-model-constraint-rederivation-adapter.ts

@@ -0,0 +1,56 @@
+// @unit validator-system
+// @layer infrastructure
+// @work-item-id WI-302
+
+import { createWorldModelModule, type WorldResolvedConfigInput } from "../../../world-model/index.js";
+import type {
+  WorldConstraintRederivationObservation,
+  WorldConstraintRederivationPolicyPort,
+} from "../../domain/ports/world-constraint-rederivation-policy-port.js";
+
+interface Options {
+  readonly rootDir: string;
+  readonly resolvedConfig?: WorldResolvedConfigInput;
+}
+
+export class WorldModelConstraintRederivationAdapter implements WorldConstraintRederivationPolicyPort {
+  constructor(private readonly options: Options) {}
+
+  async collect(): Promise<WorldConstraintRederivationObservation> {
+    const module = createWorldModelModule({
+      rootDir: this.options.rootDir,
+      resolvedConfig: this.options.resolvedConfig,
+    });
+    const actual = await module.deriveWorldObligationsUseCase.execute({ writeReport: false });
+    const constraintsPath =
+      this.options.resolvedConfig?.declarations?.constraintsPath ?? "phasegate.world-constraints.json";
+    if (actual.status === "execution-failure") {
+      return Object.freeze({
+        obligations: Object.freeze([]),
+        diagnostics: Object.freeze(
+          actual.diagnostics.map((item) =>
+            Object.freeze({
+              code: item.code,
+              path: item.path,
+              message: item.message,
+              scope: item.path === constraintsPath ? ("constraint" as const) : ("other" as const),
+            }),
+          ),
+        ),
+      });
+    }
+    return Object.freeze({
+      obligations: Object.freeze(
+        actual.result.report.structuralObligations.map((item) =>
+          Object.freeze({
+            ruleId: item.ruleId,
+            violationFingerprint: item.violationFingerprint,
+            constraintId: item.constraintId,
+            classification: item.classification,
+          }),
+        ),
+      ),
+      diagnostics: Object.freeze([]),
+    });
+  }
+}

package/scripts/harness/world-model/application/dto/pinned-design-endpoint-dto.ts

@@ -0,0 +1,19 @@
+// @unit world-model
+// @layer application
+// @work-item-id WI-305
+
+export interface PinnedDesignEndpointDto {
+  readonly constraintId: string;
+  readonly endpoint: "claimant" | "premise";
+  readonly nodeId: string;
+  readonly corpusRole: "product" | "inception";
+  readonly declaredKey: string;
+}
+
+export type PinnedDesignEndpointReadResultDto =
+  | {
+      readonly state: "available";
+      readonly endpoints: readonly PinnedDesignEndpointDto[];
+      readonly diagnosticCodes: readonly string[];
+    }
+  | { readonly state: "unavailable"; readonly diagnosticCodes: readonly string[] };