phasegate 0.254.0 → 0.264.0

package/scripts/harness/config-foundation/domain/value-objects/world-config.ts

@@ -0,0 +1,198 @@
+// @unit config-foundation
+// @layer domain
+// @work-item-id WI-300
+
+import { ConfigValidationError } from "../errors/config-validation-error.js";
+
+export interface WorldConfigDocument {
+  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;
+  };
+}
+
+export type WorldConfigSourceDocument = {
+  readonly [K in keyof WorldConfigDocument]?: WorldConfigDocument[K] extends readonly string[]
+    ? readonly string[]
+    : WorldConfigDocument[K] extends object
+      ? Partial<WorldConfigDocument[K]>
+      : WorldConfigDocument[K];
+};
+
+export const WORLD_CONFIG_DEFAULTS: WorldConfigDocument = Object.freeze({
+  enabled: false,
+  corpus: Object.freeze({
+    productRoots: Object.freeze(["docs/product"]),
+    inceptionRoots: Object.freeze(["docs/inception"]),
+    adrRoots: Object.freeze(["docs/ADR"]),
+    sourceRoots: Object.freeze(["scripts/harness"]),
+    include: Object.freeze(["**/*"]),
+    exclude: Object.freeze([]),
+  }),
+  inputs: Object.freeze({
+    matrixPath: ".harness/requirement-test-matrix.json",
+    attestationPath: ".harness/attestation.json",
+    integrityManifestPath: "phasegate.integrity.json",
+  }),
+  declarations: Object.freeze({
+    constraintsPath: "phasegate.world-constraints.json",
+    baselinePath: "phasegate.world-baseline.json",
+    waiversPath: "phasegate.world-waivers.json",
+    debtsPath: "phasegate.world-debts.json",
+  }),
+  output: Object.freeze({
+    obligationReportPath: ".harness/world-obligations.json",
+  }),
+  sessionStart: Object.freeze({ enabled: true, maxItems: 5, maxChars: 2000 }),
+});
+
+const cloneDocument = (document: WorldConfigDocument): WorldConfigDocument =>
+  Object.freeze({
+    enabled: document.enabled,
+    corpus: Object.freeze({
+      productRoots: Object.freeze([...document.corpus.productRoots]),
+      inceptionRoots: Object.freeze([...document.corpus.inceptionRoots]),
+      adrRoots: Object.freeze([...document.corpus.adrRoots]),
+      sourceRoots: Object.freeze([...document.corpus.sourceRoots]),
+      include: Object.freeze([...document.corpus.include]),
+      exclude: Object.freeze([...document.corpus.exclude]),
+    }),
+    inputs: Object.freeze({ ...document.inputs }),
+    declarations: Object.freeze({ ...document.declarations }),
+    output: Object.freeze({ ...document.output }),
+    sessionStart: Object.freeze({ ...document.sessionStart }),
+  });
+
+const assertProjectRelativePosixPath = (value: string): void => {
+  const segments = value.split("/");
+  if (
+    value.length === 0 ||
+    value.startsWith("/") ||
+    value.includes("\\") ||
+    segments.some((segment) => segment === "" || segment === "." || segment === "..")
+  ) {
+    throw new ConfigValidationError(`world path must be a project-relative POSIX path: ${value}`);
+  }
+};
+
+const assertUniqueStrings = (name: string, values: readonly string[], allowEmpty: boolean): void => {
+  if (!allowEmpty && values.length === 0) {
+    throw new ConfigValidationError(`${name} must not be empty`);
+  }
+  if (values.some((value) => value.length === 0) || new Set(values).size !== values.length) {
+    throw new ConfigValidationError(`${name} must contain unique non-empty values`);
+  }
+};
+
+interface CorpusRootEntry {
+  readonly role: string;
+  readonly path: string;
+}
+
+const rootsOverlap = (left: string, right: string): boolean =>
+  left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+
+const assertCorpusRoots = (document: WorldConfigDocument): void => {
+  const entries: readonly CorpusRootEntry[] = [
+    ...document.corpus.productRoots.map((path) => ({ role: "product", path })),
+    ...document.corpus.inceptionRoots.map((path) => ({ role: "inception", path })),
+    ...document.corpus.adrRoots.map((path) => ({ role: "adr", path })),
+    ...document.corpus.sourceRoots.map((path) => ({ role: "source", path })),
+  ];
+
+  for (let leftIndex = 0; leftIndex < entries.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < entries.length; rightIndex += 1) {
+      const left = entries[leftIndex];
+      const right = entries[rightIndex];
+      if (left.path.toLowerCase() === right.path.toLowerCase() && left.path !== right.path) {
+        throw new ConfigValidationError(`world path case-fold collision: ${left.path} / ${right.path}`);
+      }
+      if (left.role !== right.role && rootsOverlap(left.path, right.path)) {
+        throw new ConfigValidationError(`world corpus root role overlap: ${left.path} / ${right.path}`);
+      }
+    }
+  }
+};
+
+const allPaths = (document: WorldConfigDocument): readonly string[] => [
+  ...document.corpus.productRoots,
+  ...document.corpus.inceptionRoots,
+  ...document.corpus.adrRoots,
+  ...document.corpus.sourceRoots,
+  document.inputs.matrixPath,
+  document.inputs.attestationPath,
+  document.inputs.integrityManifestPath,
+  document.declarations.constraintsPath,
+  document.declarations.baselinePath,
+  document.declarations.waiversPath,
+  document.declarations.debtsPath,
+  document.output.obligationReportPath,
+];
+
+const assertNoCaseFoldPathCollisions = (paths: readonly string[]): void => {
+  const byFoldedPath = new Map<string, string>();
+  for (const path of paths) {
+    const folded = path.toLowerCase();
+    const existing = byFoldedPath.get(folded);
+    if (existing !== undefined && existing !== path) {
+      throw new ConfigValidationError(`world path case-fold collision: ${existing} / ${path}`);
+    }
+    byFoldedPath.set(folded, path);
+  }
+};
+
+export class WorldConfig {
+  private constructor(private readonly document: WorldConfigDocument) {}
+
+  static create(document: WorldConfigDocument): WorldConfig {
+    assertUniqueStrings("world.corpus.productRoots", document.corpus.productRoots, false);
+    assertUniqueStrings("world.corpus.inceptionRoots", document.corpus.inceptionRoots, false);
+    assertUniqueStrings("world.corpus.adrRoots", document.corpus.adrRoots, false);
+    assertUniqueStrings("world.corpus.sourceRoots", document.corpus.sourceRoots, false);
+    assertUniqueStrings("world.corpus.include", document.corpus.include, false);
+    assertUniqueStrings("world.corpus.exclude", document.corpus.exclude, true);
+    const paths = allPaths(document);
+    for (const path of paths) assertProjectRelativePosixPath(path);
+    assertNoCaseFoldPathCollisions(paths);
+    assertCorpusRoots(document);
+    if (
+      !Number.isInteger(document.sessionStart.maxItems) ||
+      document.sessionStart.maxItems < 1 ||
+      document.sessionStart.maxItems > 20 ||
+      !Number.isInteger(document.sessionStart.maxChars) ||
+      document.sessionStart.maxChars < 1 ||
+      document.sessionStart.maxChars > 8000
+    ) {
+      throw new ConfigValidationError("world.sessionStart must use maxItems 1..20 and maxChars 1..8000");
+    }
+    return new WorldConfig(cloneDocument(document));
+  }
+
+  toDocument(): WorldConfigDocument {
+    return cloneDocument(this.document);
+  }
+}

package/scripts/harness/config-foundation/index.ts

@@ -1,18 +1,17 @@
 // @unit config-foundation
 // @layer application
+// @work-item-id WI-300
 
-export { createConfigFoundationModule } from './composition-root.js';
-
-export { LoadResolvedConfigUseCase } from './application/usecases/load-resolved-config-use-case.js';
-export { toValidatorSystemConfig } from './application/mappers/validator-system-config-mapper.js';
-
-export type { ResolvedConfigOutput } from './application/dto/resolved-config-output.js';
-export type { FeatureToggleResult } from './application/dto/feature-toggle-result.js';
-export type { AvailableFeatureItem } from './application/dto/available-feature-item.js';
-
-export { EnableFeatureCommandHandler } from './presentation/cli/enable-feature-command-handler.js';
-export { DisableFeatureCommandHandler } from './presentation/cli/disable-feature-command-handler.js';
-
-export type { ConfigRepositoryPort } from './domain/ports/config-repository-port.js';
-export type { ConfigSchemaValidatorPort } from './domain/ports/config-schema-validator-port.js';
-export type { FeatureRegistryPort } from './domain/ports/feature-registry-port.js';
+export type { AvailableFeatureItem } from "./application/dto/available-feature-item.js";
+export type { FeatureToggleResult } from "./application/dto/feature-toggle-result.js";
+export type { ResolvedConfigOutput } from "./application/dto/resolved-config-output.js";
+export { toValidatorSystemConfig } from "./application/mappers/validator-system-config-mapper.js";
+export { toWorldModelConfig } from "./application/mappers/world-model-config-mapper.js";
+export { LoadResolvedConfigUseCase } from "./application/usecases/load-resolved-config-use-case.js";
+export { createConfigFoundationModule } from "./composition-root.js";
+export type { ConfigRepositoryPort } from "./domain/ports/config-repository-port.js";
+export type { ConfigSchemaValidatorPort } from "./domain/ports/config-schema-validator-port.js";
+export type { FeatureRegistryPort } from "./domain/ports/feature-registry-port.js";
+export type { WorldConfigDocument } from "./domain/value-objects/world-config.js";
+export { DisableFeatureCommandHandler } from "./presentation/cli/disable-feature-command-handler.js";
+export { EnableFeatureCommandHandler } from "./presentation/cli/enable-feature-command-handler.js";

package/scripts/harness/config-foundation/infrastructure/presets/minimal.json

@@ -55,5 +55,29 @@
   },
   "preCommit": {
     "implementationExtensions": [".ts"]
+  },
+  "world": {
+    "enabled": false,
+    "corpus": {
+      "productRoots": ["docs/product"],
+      "inceptionRoots": ["docs/inception"],
+      "adrRoots": ["docs/ADR"],
+      "sourceRoots": ["scripts/harness"],
+      "include": ["**/*"],
+      "exclude": []
+    },
+    "inputs": {
+      "matrixPath": ".harness/requirement-test-matrix.json",
+      "attestationPath": ".harness/attestation.json",
+      "integrityManifestPath": "phasegate.integrity.json"
+    },
+    "declarations": {
+      "constraintsPath": "phasegate.world-constraints.json",
+      "baselinePath": "phasegate.world-baseline.json",
+      "waiversPath": "phasegate.world-waivers.json",
+      "debtsPath": "phasegate.world-debts.json"
+    },
+    "output": { "obligationReportPath": ".harness/world-obligations.json" },
+    "sessionStart": { "enabled": true, "maxItems": 5, "maxChars": 2000 }
   }
 }

package/scripts/harness/config-foundation/infrastructure/presets/standard.json

@@ -55,5 +55,29 @@
   },
   "preCommit": {
     "implementationExtensions": [".ts"]
+  },
+  "world": {
+    "enabled": false,
+    "corpus": {
+      "productRoots": ["docs/product"],
+      "inceptionRoots": ["docs/inception"],
+      "adrRoots": ["docs/ADR"],
+      "sourceRoots": ["scripts/harness"],
+      "include": ["**/*"],
+      "exclude": []
+    },
+    "inputs": {
+      "matrixPath": ".harness/requirement-test-matrix.json",
+      "attestationPath": ".harness/attestation.json",
+      "integrityManifestPath": "phasegate.integrity.json"
+    },
+    "declarations": {
+      "constraintsPath": "phasegate.world-constraints.json",
+      "baselinePath": "phasegate.world-baseline.json",
+      "waiversPath": "phasegate.world-waivers.json",
+      "debtsPath": "phasegate.world-debts.json"
+    },
+    "output": { "obligationReportPath": ".harness/world-obligations.json" },
+    "sessionStart": { "enabled": true, "maxItems": 5, "maxChars": 2000 }
   }
 }

package/scripts/harness/config-foundation/infrastructure/presets/strict.json

@@ -55,5 +55,29 @@
   },
   "preCommit": {
     "implementationExtensions": [".ts"]
+  },
+  "world": {
+    "enabled": false,
+    "corpus": {
+      "productRoots": ["docs/product"],
+      "inceptionRoots": ["docs/inception"],
+      "adrRoots": ["docs/ADR"],
+      "sourceRoots": ["scripts/harness"],
+      "include": ["**/*"],
+      "exclude": []
+    },
+    "inputs": {
+      "matrixPath": ".harness/requirement-test-matrix.json",
+      "attestationPath": ".harness/attestation.json",
+      "integrityManifestPath": "phasegate.integrity.json"
+    },
+    "declarations": {
+      "constraintsPath": "phasegate.world-constraints.json",
+      "baselinePath": "phasegate.world-baseline.json",
+      "waiversPath": "phasegate.world-waivers.json",
+      "debtsPath": "phasegate.world-debts.json"
+    },
+    "output": { "obligationReportPath": ".harness/world-obligations.json" },
+    "sessionStart": { "enabled": true, "maxItems": 5, "maxChars": 2000 }
   }
 }

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v2.schema.json

@@ -477,6 +477,89 @@
         }
       }
     },
+    "world": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "corpus": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "productRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "inceptionRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "adrRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "sourceRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "include": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            },
+            "exclude": {
+              "type": "array",
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            }
+          }
+        },
+        "inputs": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "matrixPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "attestationPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "integrityManifestPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "declarations": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "constraintsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "baselinePath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "waiversPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "debtsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "output": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "obligationReportPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "sessionStart": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "maxItems": { "type": "integer", "minimum": 1, "maximum": 20 },
+            "maxChars": { "type": "integer", "minimum": 1, "maximum": 8000 }
+          }
+        }
+      }
+    },
     "ci": {
       "type": "object",
       "additionalProperties": false,

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v3.schema.json

@@ -495,6 +495,89 @@
         }
       }
     },
+    "world": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "corpus": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "productRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "inceptionRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "adrRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "sourceRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "include": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            },
+            "exclude": {
+              "type": "array",
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            }
+          }
+        },
+        "inputs": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "matrixPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "attestationPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "integrityManifestPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "declarations": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "constraintsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "baselinePath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "waiversPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "debtsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "output": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "obligationReportPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "sessionStart": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "maxItems": { "type": "integer", "minimum": 1, "maximum": 20 },
+            "maxChars": { "type": "integer", "minimum": 1, "maximum": 8000 }
+          }
+        }
+      }
+    },
     "ci": {
       "type": "object",
       "additionalProperties": false,

package/scripts/harness/harness-api/domain/value-objects/ci-check-result.ts

@@ -1,5 +1,6 @@
 // @layer domain
 // @unit harness-api
+// @work-item-id WI-307
 // ci-check-result.ts — CiCheckResult Value Object
 
 import type { HarnessError } from "./harness-api-response.js";
@@ -40,12 +41,25 @@ function isEffectivelyPassed(item: ValidatorCheckItem, failOnWarning: boolean):
   return !hasFail;
 }
 
+/**
+ * WI-307: public ci-check projection の `passed` を aggregate policy と一致させる。
+ * skipped は独立した green state のため raw passed を維持し、warning-only failure だけを
+ * failOnWarning=false のとき passed=true に射影する。diagnostic は lossless に保持する。
+ */
+function toPublicValidatorResult(item: ValidatorCheckItem, failOnWarning: boolean): ValidatorCheckItem {
+  return Object.freeze({
+    ...item,
+    passed: item.skipped ? item.passed : isEffectivelyPassed(item, failOnWarning),
+    errors: item.errors === undefined ? undefined : Object.freeze([...item.errors]),
+  });
+}
+
 export class CiCheckResult {
   readonly validatorResults: readonly ValidatorCheckItem[];
   readonly allPassed: boolean;
 
-  private constructor(validatorResults: readonly ValidatorCheckItem[], allPassed: boolean) {
-    this.validatorResults = Object.freeze([...validatorResults]);
+  private constructor(validatorResults: readonly ValidatorCheckItem[], allPassed: boolean, failOnWarning: boolean) {
+    this.validatorResults = Object.freeze(validatorResults.map((item) => toPublicValidatorResult(item, failOnWarning)));
     this.allPassed = allPassed;
     Object.freeze(this);
   }
@@ -63,7 +77,7 @@ export class CiCheckResult {
         `HarnessApiDomainError: allPassed=${props.allPassed} does not match validatorResults state (computed: ${computedAllPassed})`,
       );
     }
-    return new CiCheckResult(props.validatorResults, props.allPassed);
+    return new CiCheckResult(props.validatorResults, props.allPassed, failOnWarning);
   }
 
   static fromResults(validatorResults: readonly ValidatorCheckItem[], failOnWarning = false): CiCheckResult {
@@ -71,7 +85,7 @@ export class CiCheckResult {
       throw new Error("EmptyValidatorResultsError: validatorResults must have at least one item (INV-5)");
     }
     const allPassed = validatorResults.every((r) => isEffectivelyPassed(r, failOnWarning));
-    return new CiCheckResult(validatorResults, allPassed);
+    return new CiCheckResult(validatorResults, allPassed, failOnWarning);
   }
 
   getFailedValidators(): readonly ValidatorCheckItem[] {