phasegate 0.254.0 → 0.264.0

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[] };

package/scripts/harness/world-model/application/dto/world-resolved-config-input.ts

@@ -1,62 +1,127 @@
 // @unit world-model
 // @layer application
-// @work-item-id WI-291
+// @work-item-id WI-291, WI-300
 
 import { PathKey } from "../../domain/value-objects/path-key.js";
 
 export interface WorldResolvedConfigInput {
+  readonly enabled?: boolean;
+  readonly corpus?: {
+    readonly productRoots?: readonly string[];
+    readonly inceptionRoots?: readonly string[];
+    readonly adrRoots?: readonly string[];
+    readonly sourceRoots?: readonly string[];
+    readonly include?: readonly string[];
+    readonly exclude?: readonly string[];
+  };
+  readonly inputs?: {
+    readonly matrixPath?: string;
+    readonly attestationPath?: string;
+    readonly integrityManifestPath?: string;
+  };
+  readonly declarations?: {
+    readonly constraintsPath?: string;
+    readonly baselinePath?: string;
+    readonly waiversPath?: string;
+    readonly debtsPath?: string;
+  };
+  readonly output?: { readonly obligationReportPath?: string };
+  readonly sessionStart?: {
+    readonly enabled?: boolean;
+    readonly maxItems?: number;
+    readonly maxChars?: number;
+  };
   readonly designDocsRoot?: string;
   readonly inceptionRoot?: string;
   readonly requirementMatrixPath?: string;
 }
 
 export interface WorldCorpusConfig {
+  readonly enabled: boolean;
   readonly productScopes: readonly {
     readonly productRoot: string;
     readonly designDocsRoot: string;
     readonly unitRoot: string;
   }[];
-  readonly inceptionRoot: string;
-  readonly adrRoot: string;
-  readonly sourceRoot: string;
+  readonly inceptionRoots: readonly string[];
+  readonly adrRoots: readonly string[];
+  readonly sourceRoots: readonly string[];
   readonly include: readonly string[];
   readonly exclude: readonly string[];
   readonly matrixPath: string;
   readonly attestationPath: string;
   readonly integrityManifestPath: string;
+  readonly constraintsPath: string;
+  readonly baselinePath: string;
+  readonly waiversPath: string;
+  readonly debtsPath: string;
+  readonly obligationReportPath: string;
+  readonly sessionStart: { readonly enabled: boolean; readonly maxItems: number; readonly maxChars: number };
 }
 
-const DEFAULT_DESIGN_DOCS_ROOT = "docs/product/construction";
-
 const validatePath = (value: string): string => PathKey.create(value).toString();
+const validatePaths = (values: readonly string[]): readonly string[] => Object.freeze(values.map(validatePath));
 
 const deriveProductRoot = (designDocsRoot: string): string => {
   const normalized = designDocsRoot.replace(/\/+$/, "");
   return normalized.endsWith("/construction") ? normalized.slice(0, -"/construction".length) : normalized;
 };
 
+const resolveProductRoots = (input?: WorldResolvedConfigInput): readonly string[] => {
+  if (input?.corpus?.productRoots !== undefined) return validatePaths(input.corpus.productRoots);
+  if (input?.designDocsRoot === undefined) return Object.freeze(["docs/product"]);
+  const productRoot = validatePath(deriveProductRoot(input.designDocsRoot));
+  return Object.freeze(productRoot === "docs/product" ? [productRoot] : ["docs/product", productRoot]);
+};
+
+const assertLimit = (name: string, value: number, maximum: number): number => {
+  if (!Number.isInteger(value) || value < 1 || value > maximum) {
+    throw new Error(`${name} must be an integer between 1 and ${maximum}`);
+  }
+  return value;
+};
+
 export const resolveWorldCorpusConfig = (input?: WorldResolvedConfigInput): WorldCorpusConfig => {
-  const designDocsRoot = validatePath(input?.designDocsRoot ?? DEFAULT_DESIGN_DOCS_ROOT);
-  const productRoot = validatePath(deriveProductRoot(designDocsRoot));
-  const productScopes = [
-    {
-      productRoot: "docs/product",
-      designDocsRoot: DEFAULT_DESIGN_DOCS_ROOT,
-      unitRoot: "docs/product/units",
-    },
-    ...(productRoot === "docs/product"
-      ? []
-      : [{ productRoot, designDocsRoot, unitRoot: validatePath(`${productRoot}/units`) }]),
-  ];
+  const productRoots = resolveProductRoots(input);
+  const inceptionRoots = validatePaths(input?.corpus?.inceptionRoots ?? [input?.inceptionRoot ?? "docs/inception"]);
+  const adrRoots = validatePaths(input?.corpus?.adrRoots ?? ["docs/ADR"]);
+  const sourceRoots = validatePaths(input?.corpus?.sourceRoots ?? ["scripts/harness"]);
+  if ([productRoots, inceptionRoots, adrRoots, sourceRoots].some((roots) => roots.length === 0)) {
+    throw new Error("World corpus roots must not be empty");
+  }
+  const include = Object.freeze([...(input?.corpus?.include ?? ["**/*"])]);
+  const exclude = Object.freeze([...(input?.corpus?.exclude ?? [])]);
+  if (include.length === 0 || [...include, ...exclude].some((pattern) => pattern.length === 0)) {
+    throw new Error("World corpus selection patterns must not be empty");
+  }
   return Object.freeze({
-    productScopes: Object.freeze(productScopes),
-    inceptionRoot: validatePath(input?.inceptionRoot ?? "docs/inception"),
-    adrRoot: "docs/ADR",
-    sourceRoot: "scripts/harness",
-    include: Object.freeze(["**/*"]),
-    exclude: Object.freeze([]),
-    matrixPath: validatePath(input?.requirementMatrixPath ?? ".harness/requirement-test-matrix.json"),
-    attestationPath: ".harness/attestation.json",
-    integrityManifestPath: "phasegate.integrity.json",
+    enabled: input?.enabled ?? false,
+    productScopes: Object.freeze(
+      productRoots.map((productRoot) => ({
+        productRoot,
+        designDocsRoot: validatePath(`${productRoot}/construction`),
+        unitRoot: validatePath(`${productRoot}/units`),
+      })),
+    ),
+    inceptionRoots,
+    adrRoots,
+    sourceRoots,
+    include,
+    exclude,
+    matrixPath: validatePath(
+      input?.inputs?.matrixPath ?? input?.requirementMatrixPath ?? ".harness/requirement-test-matrix.json",
+    ),
+    attestationPath: validatePath(input?.inputs?.attestationPath ?? ".harness/attestation.json"),
+    integrityManifestPath: validatePath(input?.inputs?.integrityManifestPath ?? "phasegate.integrity.json"),
+    constraintsPath: validatePath(input?.declarations?.constraintsPath ?? "phasegate.world-constraints.json"),
+    baselinePath: validatePath(input?.declarations?.baselinePath ?? "phasegate.world-baseline.json"),
+    waiversPath: validatePath(input?.declarations?.waiversPath ?? "phasegate.world-waivers.json"),
+    debtsPath: validatePath(input?.declarations?.debtsPath ?? "phasegate.world-debts.json"),
+    obligationReportPath: validatePath(input?.output?.obligationReportPath ?? ".harness/world-obligations.json"),
+    sessionStart: Object.freeze({
+      enabled: input?.sessionStart?.enabled ?? true,
+      maxItems: assertLimit("world.sessionStart.maxItems", input?.sessionStart?.maxItems ?? 5, 20),
+      maxChars: assertLimit("world.sessionStart.maxChars", input?.sessionStart?.maxChars ?? 2000, 8000),
+    }),
   });
 };