phasegate 0.254.0 → 0.264.0

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";

package/scripts/harness/world-model/infrastructure/adapters/attestation-fact-extractor.ts

@@ -1,6 +1,7 @@
 // @unit world-model
 // @layer infrastructure
 // @work-item-id WI-290
+// @work-item-id WI-306
 
 import type {
   AttestationDocument,
@@ -114,13 +115,24 @@ export class AttestationFactExtractor {
 
   private parseDocument(value: unknown): AttestationDocument {
     const root = requireObject(value, "attestation");
+    const schemaVersion = requireString(root.schemaVersion, "attestation.schemaVersion");
+    const isV2 = schemaVersion === "phasegate-attestation/v2";
     assertExactKeys(
       root,
-      ["schemaVersion", "predicateType", "subject", "inputs", "granularity", "acBoundScope", "metadata", "signature"],
+      [
+        "schemaVersion",
+        "predicateType",
+        "subject",
+        "inputs",
+        "granularity",
+        "acBoundScope",
+        "metadata",
+        "signature",
+        ...(isV2 ? ["worldSnapshotRoot"] : []),
+      ],
       "attestation",
     );
-    const schemaVersion = requireString(root.schemaVersion, "attestation.schemaVersion");
-    if (schemaVersion !== "phasegate-attestation/v1") {
+    if (schemaVersion !== "phasegate-attestation/v1" && !isV2) {
       throw new OwnerProjectionError(
         "unsupported-provider-schema",
         `unsupported attestation schema: ${schemaVersion}`,
@@ -128,14 +140,21 @@ export class AttestationFactExtractor {
       );
     }
     const predicateType = requireString(root.predicateType, "attestation.predicateType");
+    const expectedPredicate = `https://phasegate.dev/attestation/gate-run/${isV2 ? "v2" : "v1"}`;
+    if (predicateType !== expectedPredicate) {
+      throw new OwnerProjectionError("malformed-provider-document", "attestation predicateType is inconsistent");
+    }
+    const worldSnapshotRoot = isV2 ? requireString(root.worldSnapshotRoot, "attestation.worldSnapshotRoot") : undefined;
+    if (worldSnapshotRoot !== undefined) this.assertDigest(worldSnapshotRoot, "attestation.worldSnapshotRoot");
 
     const subject = requireObject(root.subject, "attestation.subject");
     assertExactKeys(subject, ["command", "gateResult", "validatorSet"], "attestation.subject");
     const command = requireString(subject.command, "attestation.subject.command");
-    const gateResult = requireString(subject.gateResult, "attestation.subject.gateResult");
-    if (gateResult !== "pass" && gateResult !== "fail") {
+    const gateResultRaw = requireString(subject.gateResult, "attestation.subject.gateResult");
+    if (gateResultRaw !== "pass" && gateResultRaw !== "fail") {
       throw new OwnerProjectionError("malformed-provider-document", "attestation gateResult is invalid");
     }
+    const gateResult: "pass" | "fail" = gateResultRaw;
     const validatorSet = requireArray(subject.validatorSet, "attestation.subject.validatorSet").map((raw, index) => {
       const field = `attestation.subject.validatorSet[${index}]`;
       const outcome = requireObject(raw, field);
@@ -174,10 +193,11 @@ export class AttestationFactExtractor {
       ["validator", "level", "claim", "knownLimitations"],
       "attestation.granularity.traceability",
     );
-    const level = requireString(traceability.level, "attestation.granularity.traceability.level");
-    if (level !== "file" && level !== "ac") {
+    const levelRaw = requireString(traceability.level, "attestation.granularity.traceability.level");
+    if (levelRaw !== "file" && levelRaw !== "ac") {
       throw new OwnerProjectionError("malformed-provider-document", "attestation granularity level is invalid");
     }
+    const level: "file" | "ac" = levelRaw;
     const knownLimitations = requireArray(
       traceability.knownLimitations,
       "attestation.granularity.traceability.knownLimitations",
@@ -193,21 +213,20 @@ export class AttestationFactExtractor {
 
     const signature = requireObject(root.signature, "attestation.signature");
     assertExactKeys(signature, ["mode", "attestationDigest", "algorithm", "keyId", "value"], "attestation.signature");
-    const mode = requireString(signature.mode, "attestation.signature.mode");
-    if (mode !== "unsigned-poc" && mode !== "signed") {
+    const modeRaw = requireString(signature.mode, "attestation.signature.mode");
+    if (modeRaw !== "unsigned-poc" && modeRaw !== "signed") {
       throw new OwnerProjectionError("malformed-provider-document", "attestation signature mode is invalid");
     }
+    const mode: "unsigned-poc" | "signed" = modeRaw;
     const attestationDigest = requireString(signature.attestationDigest, "attestation.signature.attestationDigest");
     this.assertDigest(attestationDigest, "attestation.signature.attestationDigest");
     const nullableString = (candidate: unknown, field: string): string | null =>
       candidate === null ? null : requireString(candidate, field);
 
-    return {
-      schemaVersion,
-      predicateType,
+    const common = {
       subject: { command, gateResult, validatorSet },
       inputs: {
-        digestAlgorithm: "sha256",
+        digestAlgorithm: "sha256" as const,
         sources,
         inputDigest,
       },
@@ -233,6 +252,22 @@ export class AttestationFactExtractor {
         value: nullableString(signature.value, "attestation.signature.value"),
       },
     };
+    if (isV2) {
+      if (worldSnapshotRoot === undefined) {
+        throw new OwnerProjectionError("malformed-provider-document", "attestation v2 root is missing");
+      }
+      return {
+        ...common,
+        schemaVersion: "phasegate-attestation/v2",
+        predicateType: "https://phasegate.dev/attestation/gate-run/v2",
+        worldSnapshotRoot,
+      };
+    }
+    return {
+      ...common,
+      schemaVersion: "phasegate-attestation/v1",
+      predicateType: "https://phasegate.dev/attestation/gate-run/v1",
+    };
   }
 
   private project(document: AttestationDocument, verification: VerifyAttestationOutput): CanonicalJsonObject {

package/scripts/harness/world-model/infrastructure/adapters/file-system-world-control-repository-adapters.ts

@@ -1,6 +1,7 @@
 // @unit world-model
 // @layer infrastructure
 // @work-item-id WI-294
+// @work-item-id WI-300
 
 import { readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -40,6 +41,7 @@ let temporarySequence = 0;
 
 interface RepositoryOptions {
   readonly rootDir: string;
+  readonly fileName?: string;
 }
 
 interface DeclarationSpec<T> {
@@ -238,7 +240,7 @@ export class FileSystemConstraintDeclarationRepositoryAdapter implements Constra
   private readonly repository: FileSystemWorldControlRepository<ConstraintDeclarationSet>;
 
   constructor(options: RepositoryOptions) {
-    const fileName = "phasegate.world-constraints.json";
+    const fileName = options.fileName ?? "phasegate.world-constraints.json";
     const artifactId = WorldNodeId.artifact(
       ArtifactKind.externalDeclaration(),
       CorpusRole.external(),
@@ -268,7 +270,7 @@ export class FileSystemAdoptionBaselineRepositoryAdapter implements AdoptionBase
 
   constructor(options: RepositoryOptions) {
     this.repository = new FileSystemWorldControlRepository(options, {
-      fileName: "phasegate.world-baseline.json",
+      fileName: options.fileName ?? "phasegate.world-baseline.json",
       schemaFileName: "world-baseline.schema.json",
       schemaVersion: "phasegate-world-adoption-baseline/v1",
       emptyValue: null,
@@ -290,7 +292,7 @@ export class FileSystemWaiverDeclarationRepositoryAdapter implements WaiverDecla
 
   constructor(options: RepositoryOptions) {
     this.repository = new FileSystemWorldControlRepository(options, {
-      fileName: "phasegate.world-waivers.json",
+      fileName: options.fileName ?? "phasegate.world-waivers.json",
       schemaFileName: "world-waivers.schema.json",
       schemaVersion: "phasegate-world-waivers/v1",
       emptyValue: Object.freeze([]),
@@ -312,7 +314,7 @@ export class FileSystemSemanticDebtRepositoryAdapter implements SemanticDebtRepo
 
   constructor(options: RepositoryOptions) {
     this.repository = new FileSystemWorldControlRepository(options, {
-      fileName: "phasegate.world-debts.json",
+      fileName: options.fileName ?? "phasegate.world-debts.json",
       schemaFileName: "world-debts.schema.json",
       schemaVersion: "phasegate-world-debts/v1",
       emptyValue: Object.freeze([]),

package/scripts/harness/world-model/presentation/cli/world-derive-command-handler.ts

@@ -1,13 +1,17 @@
 // @unit world-model
 // @layer presentation
 // @work-item-id WI-296
+// @work-item-id WI-300
 
 import type { DeriveWorldObligationsUseCase } from "../../application/usecases/derive-world-obligations-use-case.js";
 import { PathKey } from "../../domain/value-objects/path-key.js";
 import { envelope, parseFormat, type WorldCommandResult, type WorldOutputFormat } from "./world-command-support.js";
 
 export class WorldDeriveCommandHandler {
-  constructor(private readonly useCase: Pick<DeriveWorldObligationsUseCase, "execute">) {}
+  constructor(
+    private readonly useCase: Pick<DeriveWorldObligationsUseCase, "execute">,
+    private readonly defaultReportPath = ".harness/world-obligations.json",
+  ) {}
 
   static fromFailure(error: unknown): WorldDeriveCommandHandler {
     return new WorldDeriveCommandHandler({
@@ -57,7 +61,7 @@ export class WorldDeriveCommandHandler {
       const data = {
         report,
         persistence: result.result.persistence,
-        writtenPath: writeReport ? (reportPath ?? ".harness/world-obligations.json") : null,
+        writtenPath: writeReport ? (reportPath ?? this.defaultReportPath) : null,
       };
       if (formatted.format === "json") {
         return {