phasegate 0.254.0 → 0.283.0

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),
+    }),
   });
 };

package/scripts/harness/world-model/application/dto/world-snapshot-root-dto.ts

@@ -0,0 +1,8 @@
+// @unit world-model
+// @layer application
+// @work-item-id WI-306
+
+export interface WorldSnapshotRootDto {
+  readonly schemaVersion: "phasegate-world-snapshot-root/v1";
+  readonly worldSnapshotRoot: string;
+}

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

@@ -0,0 +1,63 @@
+// @unit world-model
+// @layer application
+// @work-item-id WI-305
+
+import type { PinnedDesignEndpointDto, PinnedDesignEndpointReadResultDto } from "../dto/pinned-design-endpoint-dto.js";
+import type { ConstraintDeclarationRepositoryPort } from "../ports/world-control-declaration-repository-port.js";
+
+const EXPLICIT_FRAGMENT_ID = /^pgw:v1:fragment:(product|inception):(.+)$/;
+const compare = (left: string, right: string): number => (left < right ? -1 : left > right ? 1 : 0);
+
+export class PinnedDesignEndpointFacade {
+  constructor(private readonly repository: ConstraintDeclarationRepositoryPort) {}
+
+  async read(): Promise<PinnedDesignEndpointReadResultDto> {
+    const result = await this.repository.load();
+    if (result.state === "invalid") {
+      return Object.freeze({
+        state: "unavailable",
+        diagnosticCodes: Object.freeze([...new Set(result.diagnostics.map((item) => item.code))].sort(compare)),
+      });
+    }
+    if (result.value.malformedDeclarations.length > 0 || result.value.diagnostics.length > 0) {
+      return Object.freeze({
+        state: "unavailable",
+        diagnosticCodes: Object.freeze(
+          [
+            ...(result.value.malformedDeclarations.length > 0 ? ["malformed-constraint-declaration"] : []),
+            ...result.value.diagnostics.map((item) => item.code),
+          ].sort(compare),
+        ),
+      });
+    }
+    const endpoints: PinnedDesignEndpointDto[] = [];
+    for (const record of result.value.records) {
+      for (const endpoint of ["claimant", "premise"] as const) {
+        const nodeId = record[endpoint].nodeId.toString();
+        const match = EXPLICIT_FRAGMENT_ID.exec(nodeId);
+        if (!match) continue;
+        endpoints.push(
+          Object.freeze({
+            constraintId: record.constraintId.toString(),
+            endpoint,
+            nodeId,
+            corpusRole: match[1] as "product" | "inception",
+            declaredKey: match[2],
+          }),
+        );
+      }
+    }
+    endpoints.sort(
+      (left, right) =>
+        compare(left.corpusRole, right.corpusRole) ||
+        compare(left.declaredKey, right.declaredKey) ||
+        compare(left.constraintId, right.constraintId) ||
+        compare(left.endpoint, right.endpoint),
+    );
+    return Object.freeze({
+      state: "available",
+      endpoints: Object.freeze(endpoints),
+      diagnosticCodes: Object.freeze([]),
+    });
+  }
+}

package/scripts/harness/world-model/application/facades/world-snapshot-root-facade.ts

@@ -0,0 +1,19 @@
+// @unit world-model
+// @layer application
+// @work-item-id WI-306
+
+import type { WorldSnapshotRootDto } from "../dto/world-snapshot-root-dto.js";
+import type { BuildSnapshotContract } from "../usecases/build-snapshot-use-case.js";
+
+/** World domain型を公開せずcurrent corpusRootだけを返すpublic read facade。 */
+export class WorldSnapshotRootFacade {
+  constructor(private readonly buildSnapshot: BuildSnapshotContract) {}
+
+  async read(): Promise<WorldSnapshotRootDto> {
+    const snapshot = await this.buildSnapshot.execute();
+    return {
+      schemaVersion: "phasegate-world-snapshot-root/v1",
+      worldSnapshotRoot: snapshot.corpusRoot.toString(),
+    };
+  }
+}

package/scripts/harness/world-model/application/usecases/derive-world-obligations-use-case.ts

@@ -1,6 +1,7 @@
 // @unit world-model
 // @layer application
 // @work-item-id WI-296, WI-297
+// @work-item-id WI-300
 
 import { ExtractionDiagnostic } from "../../domain/entities/extraction-diagnostic.js";
 import type { Snapshot } from "../../domain/entities/snapshot.js";
@@ -38,6 +39,7 @@ interface Dependencies {
   readonly policyDate: PolicyDatePort;
   readonly constraintConfigDigest: Sha256Digest;
   readonly evaluationConfigDigest: Sha256Digest;
+  readonly constraintPath?: string;
 }
 
 const RULESET_VERSION = "phasegate-world-wcr/v1";
@@ -64,7 +66,7 @@ export class DeriveWorldObligationsUseCase {
       ...constraints.value.malformedDeclarations.map((declaration) =>
         ExtractionDiagnostic.create({
           code: "malformed-constraint-declaration",
-          path: PathKey.create("phasegate.world-constraints.json"),
+          path: PathKey.create(this.dependencies.constraintPath ?? "phasegate.world-constraints.json"),
           payload: declaration.toCanonicalValue(),
         }),
       ),

package/scripts/harness/world-model/composition-root.ts

@@ -4,6 +4,9 @@
 // @work-item-id WI-292
 // @work-item-id WI-295
 // @work-item-id WI-296, WI-297
+// @work-item-id WI-300
+// @work-item-id WI-305
+// @work-item-id WI-306
 
 import { createAttestationModule, createSha256Capability } from "../attestation/index.js";
 import { createTraceabilityModelModule } from "../traceability-model/index.js";
@@ -11,6 +14,8 @@ import {
   resolveWorldCorpusConfig,
   type WorldResolvedConfigInput,
 } from "./application/dto/world-resolved-config-input.js";
+import { PinnedDesignEndpointFacade } from "./application/facades/pinned-design-endpoint-facade.js";
+import { WorldSnapshotRootFacade } from "./application/facades/world-snapshot-root-facade.js";
 import { BuildSnapshotUseCase } from "./application/usecases/build-snapshot-use-case.js";
 import { DeriveObligationsUseCase } from "./application/usecases/derive-obligations-use-case.js";
 import {
@@ -68,15 +73,17 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
   const hashingPort = new AttestationSha256WorldHashingAdapter(createSha256Capability());
   const serializer = new CanonicalJsonSerializer();
   const markdownExtractor = new MarkdownDesignFactExtractor({ hashingPort });
-  const traceabilityFacades = config.productScopes.map(
-    (scope) =>
-      createTraceabilityModelModule(options.rootDir, {
-        pathRoots: {
-          designDocsRoot: scope.designDocsRoot,
-          inceptionRoot: config.inceptionRoot,
-          testRoots: [`${config.sourceRoot}/__tests__`],
-        },
-      }).worldReadFacade,
+  const traceabilityFacades = config.productScopes.flatMap((scope) =>
+    config.inceptionRoots.map(
+      (inceptionRoot) =>
+        createTraceabilityModelModule(options.rootDir, {
+          pathRoots: {
+            designDocsRoot: scope.designDocsRoot,
+            inceptionRoot,
+            testRoots: config.sourceRoots.map((sourceRoot) => `${sourceRoot}/__tests__`),
+          },
+        }).worldReadFacade,
+    ),
   );
   const designCorpus = new DesignCorpusFactExtractor({
     traceabilityAdapter: new TraceabilityDesignFactAdapter({
@@ -94,16 +101,14 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
           }),
       ),
     ),
-    proposalExtractor: new ProposalFactExtractor({
-      rootDir: options.rootDir,
-      markdownExtractor,
-      inceptionRoot: config.inceptionRoot,
-    }),
-    adrExtractor: new AdrFactExtractor({
-      rootDir: options.rootDir,
-      markdownExtractor,
-      adrRoot: config.adrRoot,
-    }),
+    proposalExtractor: new CompositeDesignFactSource(
+      config.inceptionRoots.map(
+        (inceptionRoot) => new ProposalFactExtractor({ rootDir: options.rootDir, markdownExtractor, inceptionRoot }),
+      ),
+    ),
+    adrExtractor: new CompositeDesignFactSource(
+      config.adrRoots.map((adrRoot) => new AdrFactExtractor({ rootDir: options.rootDir, markdownExtractor, adrRoot })),
+    ),
     unitExtractor: new CompositeDesignFactSource(
       config.productScopes.map(
         (scope) =>
@@ -118,16 +123,10 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
   const attestationModule = createAttestationModule(options.rootDir);
   const factSource = new AssembledWorldFactSource([
     designCorpus,
-    new SourceMetadataFactExtractor({
-      rootDir: options.rootDir,
-      hashingPort,
-      sourceRoot: config.sourceRoot,
-    }),
-    new TestReferenceSourceFactExtractor({
-      rootDir: options.rootDir,
-      hashingPort,
-      sourceRoot: config.sourceRoot,
-    }),
+    ...config.sourceRoots.flatMap((sourceRoot) => [
+      new SourceMetadataFactExtractor({ rootDir: options.rootDir, hashingPort, sourceRoot }),
+      new TestReferenceSourceFactExtractor({ rootDir: options.rootDir, hashingPort, sourceRoot }),
+    ]),
     new MatrixFactExtractor({
       rootDir: options.rootDir,
       hashingPort,
@@ -148,7 +147,22 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
       serializer,
     }),
   ]);
-  const corpusConfigDigest = hashingPort.sha256(serializer.serialize(config));
+  const corpusConfigDigest = hashingPort.sha256(
+    serializer.serialize({
+      schemaVersion: "phasegate-world-corpus-config/v1",
+      productScopes: config.productScopes,
+      inceptionRoots: config.inceptionRoots,
+      adrRoots: config.adrRoots,
+      sourceRoots: config.sourceRoots,
+      include: config.include,
+      exclude: config.exclude,
+      inputs: {
+        matrixPath: config.matrixPath,
+        attestationPath: config.attestationPath,
+        integrityManifestPath: config.integrityManifestPath,
+      },
+    }),
+  );
   const buildSnapshotUseCase = new BuildSnapshotUseCase({
     factSource,
     rootDeriver: new SnapshotRootDeriver(serializer, hashingPort),
@@ -158,26 +172,34 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
     corpusConfigDigest,
   });
   const inspectWorldUseCase = new InspectWorldUseCase({ buildSnapshot: buildSnapshotUseCase });
+  const worldSnapshotRootFacade = new WorldSnapshotRootFacade(buildSnapshotUseCase);
   const fingerprintDeriver = new ViolationFingerprintDeriver(serializer, hashingPort);
   const constraintRepository = new FileSystemConstraintDeclarationRepositoryAdapter({
     rootDir: options.rootDir,
+    fileName: config.constraintsPath,
   });
   const rootDeriver = new SnapshotRootDeriver(serializer, hashingPort);
   const deriveObligationsUseCase = new DeriveObligationsUseCase({
     baselineRepository: new FileSystemAdoptionBaselineRepositoryAdapter({
       rootDir: options.rootDir,
+      fileName: config.baselinePath,
     }),
     waiverRepository: new FileSystemWaiverDeclarationRepositoryAdapter({
       rootDir: options.rootDir,
+      fileName: config.waiversPath,
     }),
     semanticDebtRepository: new FileSystemSemanticDebtRepositoryAdapter({
       rootDir: options.rootDir,
+      fileName: config.debtsPath,
     }),
     policyInputsDigestDeriver: new PolicyInputsDigestDeriver(serializer, hashingPort),
     evaluationIdDeriver: new SnapshotRootDeriver(serializer, hashingPort),
     obligationDerivationService: new ObligationDerivationService(fingerprintDeriver),
     serializer,
-    writer: new FileSystemObligationReportWriterAdapter({ rootDir: options.rootDir }),
+    writer: new FileSystemObligationReportWriterAdapter({
+      rootDir: options.rootDir,
+      reportPath: config.obligationReportPath,
+    }),
   });
   const deriveWorldObligationsUseCase = new DeriveWorldObligationsUseCase({
     buildSnapshot: buildSnapshotUseCase,
@@ -190,7 +212,7 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
     constraintConfigDigest: hashingPort.sha256(
       serializer.serialize({
         schemaVersion: "phasegate-world-constraint-config/v1",
-        constraintsPath: "phasegate.world-constraints.json",
+        constraintsPath: config.constraintsPath,
       }),
     ),
     evaluationConfigDigest: hashingPort.sha256(
@@ -199,11 +221,16 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
         rulesetVersion: "phasegate-world-wcr/v1",
       }),
     ),
+    constraintPath: config.constraintsPath,
   });
   const pinConstraintEndpointUseCase = new PinConstraintEndpointUseCase(buildSnapshotUseCase, constraintRepository);
+  const pinnedDesignEndpointFacade = new PinnedDesignEndpointFacade(constraintRepository);
   const worldInspectCommandHandler = new WorldInspectCommandHandler({ inspectWorld: inspectWorldUseCase });
   const worldPinCommandHandler = new WorldPinCommandHandler(pinConstraintEndpointUseCase);
-  const worldDeriveCommandHandler = new WorldDeriveCommandHandler(deriveWorldObligationsUseCase);
+  const worldDeriveCommandHandler = new WorldDeriveCommandHandler(
+    deriveWorldObligationsUseCase,
+    config.obligationReportPath,
+  );
 
   return {
     buildSnapshotUseCase,
@@ -211,8 +238,10 @@ export function createWorldModelModule(options: WorldModelModuleOptions) {
     deriveWorldObligationsUseCase,
     inspectWorldUseCase,
     pinConstraintEndpointUseCase,
+    pinnedDesignEndpointFacade,
     worldDeriveCommandHandler,
     worldInspectCommandHandler,
+    worldSnapshotRootFacade,
     worldPinCommandHandler,
   } as const;
 }

package/scripts/harness/world-model/index.ts

@@ -1,7 +1,14 @@
 // @unit world-model
 // @layer public-api
 // @work-item-id WI-291, WI-296
+// @work-item-id WI-304
+// @work-item-id WI-305
+// @work-item-id WI-306
 
+export type {
+  PinnedDesignEndpointDto,
+  PinnedDesignEndpointReadResultDto,
+} from "./application/dto/pinned-design-endpoint-dto.js";
 export type {
   WorldExtractionDiagnosticDto,
   WorldInspectionDto,
@@ -9,10 +16,14 @@ export type {
   WorldJsonObject,
   WorldJsonValue,
 } from "./application/dto/world-inspection-dto.js";
+export type { WorldObligationReportDto } from "./application/dto/world-obligation-report-dto.js";
 export type {
   WorldCorpusConfig,
   WorldResolvedConfigInput,
 } from "./application/dto/world-resolved-config-input.js";
+export type { WorldSnapshotRootDto } from "./application/dto/world-snapshot-root-dto.js";
+export { PinnedDesignEndpointFacade } from "./application/facades/pinned-design-endpoint-facade.js";
+export { WorldSnapshotRootFacade } from "./application/facades/world-snapshot-root-facade.js";
 export type { WorldModelModuleOptions } from "./composition-root.js";
 export { createWorldModelModule } from "./composition-root.js";
 export type { WorldCommandResult } from "./presentation/cli/world-command-support.js";