@onlineapps/conn-orch-validator 9.0.0 → 10.0.0

package/src/sync/uniformFiles.js

@@ -11,12 +11,19 @@
  * points the check at. A second list here would be a second owner of the shape,
  * and the two would diverge exactly the way the nine copies of `init.sh` did.
  *
- * The corollary is that a row the manifest does not make renderable is NOT
- * rendered. `G-PROD-IMAGE` names no reference — it is a requirement about a
- * file, not a file — so it is reported NOT RUN, with the reason, rather than
- * being filled from something this module decided
- * (`.claude/rules/automation-gates.md` §5: silence is a defect, and so is a
- * mechanism that quietly covers less than it claims).
+ * The corollary is that a row the manifest does not make renderable is not a
+ * row of this run at all. `G-PROD-IMAGE` and `G-SETUP` name no reference — the
+ * first is a requirement about a pin inside a file, the second about a directory
+ * existing — so the MANIFEST run answers them and the sync does not plan them
+ * (`syncRows` below). Until d.507 the sync planned them and printed NOT RUN: a
+ * line every `--check` in every repository ended on, naming a state its reader
+ * could do nothing about, which is the false guarantee
+ * `.claude/rules/automation-gates.md` §5 calls a defect and the `Fix`-less
+ * message its §1 requirement 4 forbids.
+ *
+ * NOT RUN stays for the other case, which is the one it was made for: a row the
+ * sync MUST render and cannot reach the reference of — named, with the reason
+ * and the command that makes it reachable, never skipped in silence.
  *
  * WHERE A ROW NEEDS MORE THAN A SPLICE, THE MODULE THAT OWNS THE RULE RENDERS
  * IT. Two rows are not "the reference, verbatim": the runner block carries three
@@ -39,10 +46,11 @@ const {
   withoutBlock, IGNORE_BLOCK, DOCKERIGNORE_BLOCK
 } = require('../manifest/checks/serviceFiles');
 const {
-  spliceBlock, insertBlockUnder, topLevelKeys, replaceTopLevelKeys
+  spliceBlock, insertBlockUnder, insertBlockAfterFunction, topLevelKeys, replaceTopLevelKeys
 } = require('./serviceTemplate');
 const { requireIdentity } = require('../manifest/serviceIdentity');
 const { rowNeedsWorkspace } = require('../manifest/manifestShape');
+const { describeWorkspaceFix } = require('../manifest/workspaceRoot');
 const { KINDS, applyUniformRegion } = require('./readmePointer');
 const { serviceRegion } = require('./readmeLocation');
 const { CHECK_REGISTRY } = require('../manifest/checks');
@@ -291,7 +299,12 @@ function renderDockerignoreEntries({ row, current, workspaceRoot }) {
     `# --- ${DOCKERIGNORE_BLOCK}`,
     `# Derived from ${referenceOwner(row.from)}, the declaration .gitignore reads too —`,
     '# what a LOCAL production build must not copy into the image (being ignored by git',
-    "# excludes nothing from COPY . .). Everything above this block is this repository's own.",
+    '# excludes nothing from COPY . .), PLUS the test tree: tests stay in the repository',
+    '# and out of the artefact that runs, the same decision the library uniform makes as',
+    '# L-PACK-TESTS. The one exception is tests/cookbooks, which is not a test but a',
+    '# declaration the runtime reads — Tier-1 of the boot runs those cookbooks at phase',
+    '# 0.2, and an image without them refuses its own validation proof as NO_TESTS.',
+    "# Everything above this block is this repository's own.",
     ...missing,
     `# --- end ${DOCKERIGNORE_BLOCK}`,
     ''
@@ -322,7 +335,11 @@ const RENDERERS = Object.freeze({
 const SYNCABLE_CLASSES = Object.freeze(['identical', 'generated', 'contains']);
 
 /**
- * The manifest rows this run is defined by, in manifest order.
+ * The manifest rows of the classes the generator owns, in manifest order.
+ *
+ * Not every one of them is a row this run renders — see `syncRows`. This is the
+ * full declaration, and the CLI needs it to tell a path the uniform declares as
+ * a REQUIREMENT from a path it has never heard of.
  *
  * @param {object} manifest
  * @returns {object[]}
@@ -332,6 +349,34 @@ function uniformRows(manifest) {
   return SYNCABLE_CLASSES.flatMap((className) => files[className] || []);
 }
 
+/**
+ * Whether the sync is defined for this row: does it name what its content comes
+ * from?
+ *
+ * The predicate is the manifest's own distinction, not a list of ids: a row with
+ * a `from:` reference is a file rendered from that reference, a row without one
+ * is a requirement about the repository, and the reference is exactly what
+ * `desiredContent` would read. Judging the reference rather than the id is why a
+ * new requirement row needs no change here.
+ *
+ * @param {object} row
+ * @returns {boolean}
+ */
+function isSyncRow(row) {
+  if (!row || !row.from) return false;
+  return typeof row.from.path === 'string' || isPackageReference(row.from);
+}
+
+/**
+ * The manifest rows this run is defined by, in manifest order.
+ *
+ * @param {object} manifest
+ * @returns {object[]}
+ */
+function syncRows(manifest) {
+  return uniformRows(manifest).filter(isSyncRow);
+}
+
 /**
  * Where two texts first differ, what the file says there, and what the run would
  * put there instead.
@@ -373,17 +418,14 @@ function readServiceFile(serviceRoot, relative) {
 }
 
 /**
- * What a row's file should contain, or why this run cannot say.
+ * What a row's file should contain.
  *
- * @returns {{desired: string}|{reason: string}}
+ * Only ever called for a row `isSyncRow` accepts, so the reference is there to
+ * be read; `planRow` is where that is checked, once, before anything reads.
+ *
+ * @returns {{desired: string}}
  */
 function desiredContent({ row, current, serviceRoot, workspaceRoot }) {
-  if (!row.from || (typeof row.from.path !== 'string' && !isPackageReference(row.from))) {
-    return {
-      reason: 'the row declares no "from" reference, so nothing says what this file\'s content is rendered from'
-    };
-  }
-
   const render = RENDERERS[row.check];
   if (render !== undefined) return { desired: render({ row, current, serviceRoot, workspaceRoot }) };
 
@@ -401,6 +443,18 @@ function desiredContent({ row, current, serviceRoot, workspaceRoot }) {
     throw new Error(`[UniformSync] Reference block "${row.block}" not found in ${referenceOwner(row.from)} - the row `
       + 'names a block the template does not carry. Fix: restore the block in the template, or correct the row.');
   }
+
+  // The block is missing from a file that exists. That is "not synced", not
+  // "paste it in by hand": the content is generated and the run holds it, so the
+  // only open question is WHERE — and a row answers that by naming an anchor the
+  // file itself declares (`insert_after_function`). Without one the refusal
+  // stands, because the position would then be a decision about this service
+  // rather than a fact about the file (the same line `insertBlockUnder` draws
+  // for a compose mapping). A message that tells a human to copy generated bytes
+  // is the defect `.claude/rules/automation-gates.md` §1.4 names.
+  if (blockLines(current, row.block).length === 0 && typeof row.insert_after_function === 'string') {
+    return { desired: insertBlockAfterFunction({ text: current, fn: row.insert_after_function, replacement }) };
+  }
   return { desired: spliceBlock({ text: current, block: row.block, replacement }) };
 }
 
@@ -412,6 +466,15 @@ function desiredContent({ row, current, serviceRoot, workspaceRoot }) {
  *            current: string|null, desired?: string, detail?: string, reason?: string}}
  */
 function planRow({ row, serviceRoot, workspaceRoot }) {
+  // Fail-fast rather than a NOT RUN line: `planSync` hands over only the rows
+  // `syncRows` selected, so a requirement row arriving here is a caller's
+  // mistake, and the caller is told which run does answer that row.
+  if (!isSyncRow(row)) {
+    throw new Error(`[UniformSync] ${row.id} declares no "from" reference - nothing says what ${row.path} `
+      + 'would be rendered from, so this row is a requirement about the repository rather than a file this '
+      + 'run writes. Fix: check it with npx oa-validate <serviceRoot>, which is the run that answers it.');
+  }
+
   const current = readServiceFile(serviceRoot, row.path);
   const base = { id: row.id, path: row.path, current };
 
@@ -425,9 +488,17 @@ function planRow({ row, serviceRoot, workspaceRoot }) {
     return {
       ...base,
       outcome: 'not-run',
+      // The check's own sentence, remedy included — not that sentence plus one
+      // of this module's. `workspaceRoot.js` § describeWorkspaceFix is the ONE
+      // owner of "point --workspace at a checkout that carries X" (d.516), and
+      // since d.523 every workspace-dependent check ends its NOT RUN sentence
+      // with it. Appending a second `Fix:` here produced two remedies for one
+      // absence, separated by a stray full stop — the second rail
+      // `.claude/rules/change-discipline.md` § One rail per concern names, in
+      // the one line a reader acts on.
       reason: check.describeNotRun
         ? check.describeNotRun({ row, block: null })
-        : 'the workspace root is not reachable'
+        : `the workspace root is not reachable. ${describeWorkspaceFix('api/ and api_biz/')}`
     };
   }
 
@@ -438,7 +509,6 @@ function planRow({ row, serviceRoot, workspaceRoot }) {
     return { ...base, outcome: 'blocked', reason: error.message };
   }
 
-  if (outcome.reason !== undefined) return { ...base, outcome: 'not-run', reason: outcome.reason };
   if (outcome.desired === current) return { ...base, outcome: 'unchanged', desired: outcome.desired };
 
   return {
@@ -456,7 +526,7 @@ function planRow({ row, serviceRoot, workspaceRoot }) {
  * @returns {object[]} one entry per row, in manifest order
  */
 function planSync({ manifest, serviceRoot, workspaceRoot, paths = [] }) {
-  const rows = uniformRows(manifest);
+  const rows = syncRows(manifest);
 
   const wanted = paths.length === 0 ? rows : paths.map((wantedPath) => {
     const row = rows.find((candidate) => candidate.path === wantedPath);
@@ -471,4 +541,4 @@ function planSync({ manifest, serviceRoot, workspaceRoot, paths = [] }) {
   return wanted.map((row) => planRow({ row, serviceRoot, workspaceRoot }));
 }
 
-module.exports = { SYNCABLE_CLASSES, uniformRows, planRow, planSync, firstDifference };
+module.exports = { SYNCABLE_CLASSES, uniformRows, isSyncRow, syncRows, planRow, planSync, firstDifference };

package/src/utils/bizCiGateContract.js

@@ -82,7 +82,31 @@ function assertRepoRelativePath(value, fieldName) {
 function normalizeDatabaseDeclaration(database, connectors) {
   // Absent means "this service has no database". Null rather than {} so callers
   // distinguish that from an empty declaration and skip the steps explicitly.
-  if (database === undefined || database === null) return null;
+  //
+  // Absent is only allowed together with its connector. `db: true` with no
+  // block used to pass — a transition allowance while the six repositories
+  // still carried their own ci-setup-db.js ("F4 tightens this"). F4 landed:
+  // utils/setupDatabase.js replaced all six, none of the eight biz
+  // repositories carries one, and every repository declaring `db: true`
+  // declares a block (measured 2026-09-16), so the gate lands with compliance
+  // already in place (`automation-gates.md` §3) and the allowance goes with it
+  // (`architecture-principles.md` §11, no transition shims).
+  //
+  // What it cost while it stood: the combination makes `setup-db` report NOT
+  // APPLICABLE — correctly, there is no schema to build — while
+  // `wait-connectors` waits for a database and `run-prevalidation` then
+  // dispatches the service's own handlers against a schema nobody built. The
+  // DB steps must run exactly where a database is declared, and the two keys
+  // are one fact stated twice.
+  if (database === undefined || database === null) {
+    if (connectors.db) {
+      throw new Error('[BizCiGate] Contradictory contract - requiredConnectors.db is true but the contract '
+        + 'carries no "database" block, so setup-db has no schema to build while wait-connectors waits for '
+        + 'one and the cookbooks run against whatever is there. '
+        + 'Fix: declare the database block (engine, schema, migrations), or set requiredConnectors.db to false.');
+    }
+    return null;
+  }
 
   if (typeof database !== 'object' || Array.isArray(database)) {
     throw new Error('[BizCiGate] Invalid database - Expected an object with engine, schema and migrations. '

package/src/utils/installContract.js

@@ -20,7 +20,10 @@
  *                applies — in both directions (§7)
  *   SQL_HEADERS  every live SQL file declares its dataset class and safety, with
  *                VALUES from the contract's closed vocabularies and not merely the
- *                four keys (§4)
+ *                four keys (§4). "Live" is what the installer applies: the
+ *                migrations tree outside history, AND the seeds the integration
+ *                contract declares, wherever they sit
+ *                (`installation-sql-contract-scope` 003)
  *
  * Rules: api/docs/standards/repository-installation-sql-contract.md §2-§5, §7
  * @see api/docs/governance/confirmations/installation-sql-contract-scope.md
@@ -127,8 +130,22 @@ function listSqlFiles(absoluteDir) {
  * package directories alone: the root `migrations/*.sql` set IS the live
  * migration set of four services, and until this loop reached it those files
  * carried no header requirement at all while the gate reported PASS.
+ *
+ * `migrations/**` is not the whole scope either. What the contract covers is
+ * what the INSTALLER APPLIES, whatever directory it sits in
+ * (`installation-sql-contract-scope` 003: "Ano, vše co instalátor aplikuje"),
+ * and what the installer applies beyond the migration set is exactly the
+ * `database.seeds` list of the integration contract — read here from that one
+ * declaration rather than from a second list of directories, which would rot
+ * the moment a service put a seed somewhere new (`doc-code-binding.md` §1).
+ * Measured 2026-09-16: converter declares two seeds under `scripts/seed/` and
+ * ingest one, and the header gate had never looked at any of them.
+ *
+ * @param {string} serviceRoot repository root to walk
+ * @param {string[]} seeds repo-relative seed paths the contract declares, which
+ *   exist; one already inside `migrations/**` is not listed twice
  */
-function listLiveSqlFiles(serviceRoot) {
+function listLiveSqlFiles(serviceRoot, seeds = []) {
   const found = [];
 
   const walk = (relativeDir) => {
@@ -149,6 +166,11 @@ function listLiveSqlFiles(serviceRoot) {
   };
 
   walk(MIGRATIONS_ROOT);
+
+  for (const seed of seeds) {
+    if (!found.includes(seed)) found.push(seed);
+  }
+
   return found;
 }
 
@@ -285,7 +307,26 @@ function checkManifestCompleteness(serviceRoot, manifestFile, add) {
   }
 }
 
-function checkSqlPackage(serviceRoot, add) {
+/**
+ * The seeds the contract declares AND the repository carries. A declared file
+ * that is not there is reported rather than read: the installer would stop on
+ * it, so the gate says so with the same words instead of throwing ENOENT out of
+ * a header check (`automation-gates.md` §1 requirement 4).
+ */
+function existingSeeds(serviceRoot, database, add) {
+  const declared = Array.isArray(database?.seeds) ? database.seeds : [];
+
+  return declared.filter((relativeFile) => {
+    if (existsExactly(serviceRoot, relativeFile.split('/'))) return true;
+
+    add('SQL_PACKAGE', 'Declared seed does not exist - config/service/integration-contract.json '
+      + `declares "${relativeFile}" in database.seeds and the repository does not carry it. `
+      + 'Fix: add the file, or remove the declaration — the installer applies exactly what is declared.');
+    return false;
+  });
+}
+
+function checkSqlPackage(serviceRoot, database, add) {
   for (const relativeDir of SQL_DIRECTORIES) {
     const absoluteDir = path.join(serviceRoot, relativeDir);
 
@@ -303,7 +344,7 @@ function checkSqlPackage(serviceRoot, add) {
     }
   }
 
-  const liveFiles = listLiveSqlFiles(serviceRoot);
+  const liveFiles = listLiveSqlFiles(serviceRoot, existingSeeds(serviceRoot, database, add));
 
   for (const relativeFile of liveFiles) {
     checkSqlHeaders(serviceRoot, relativeFile, add);
@@ -374,7 +415,7 @@ function verifyInstallContract(serviceRoot, database) {
 
   const databaseChecked = database !== null && database !== undefined;
   if (databaseChecked) {
-    checkSqlPackage(serviceRoot, add);
+    checkSqlPackage(serviceRoot, database, add);
   }
 
   return {

package/src/utils/libCompat.js

@@ -23,6 +23,15 @@
  * to "not gated" (principle 3), and it would let a typo or a retired package
  * name travel into an image with the gate reporting OK (measured 2026-09-14).
  *
+ * The narrowing decides one thing only: which packages are COMPARED against an
+ * infra version. It never relaxes the exact-pin rule, which `^`, `~` and
+ * `latest` break in EVERY `@onlineapps/*` dependency, gated or not
+ * (`.claude/rules/architecture-principles.md` § Version pinning) — a floating
+ * range makes the same commit install different code on different days whether
+ * or not infra happens to ship that package too. Until 2026-09-15 (W413) the
+ * exactness test sat inside the gated branch, so a biz-only pin could float
+ * past a green gate.
+ *
  * Pure module: the rules and the fetch live here, presentation and exit codes
  * live in the CLI.
  *
@@ -85,40 +94,51 @@ function checkLibCompat(pkg, librarySet) {
   const violations = [];
 
   for (const [name, version] of ours) {
-    if (infraConsumed && !infraConsumed.has(name)) {
-      if (!(name in versions)) {
-        violations.push({
-          package: name,
-          message: `${name}: unknown to the platform library SSOT `
-            + "- declared in neither 'libraries' nor 'infraConsumed', so no platform version exists to pin against. "
-            + `Fix: publish ${name} and add it to config/libraries.json, or remove the pin.`
-        });
-        continue;
-      }
-      notGated.push(name);
+    const bizOnly = Boolean(infraConsumed) && !infraConsumed.has(name);
+    const declared = versions[name];
+
+    if (bizOnly && declared === undefined) {
+      violations.push({
+        package: name,
+        message: `${name}: unknown to the platform library SSOT `
+          + "- declared in neither 'libraries' nor 'infraConsumed', so no platform version exists to pin against. "
+          + `Fix: publish ${name} and add it to config/libraries.json, or remove the pin.`
+      });
       continue;
     }
 
-    gated.push(name);
-    if (!EXACT_VERSION.test(version)) {
+    if (bizOnly) notGated.push(name);
+    else gated.push(name);
+
+    if (declared === undefined) {
       violations.push({
         package: name,
-        message: `${name}: version '${version}' is not exact x.y.z — caret/tilde/range pins are banned, `
-          + 'because what resolves today is not what resolved when the image was built.'
+        message: `${name}: not present in the infra library set — the platform does not ship this package version contract.`
       });
       continue;
     }
-    if (!(name in versions)) {
+
+    // The exact-pin rule is unconditional: `.claude/rules/architecture-principles.md`
+    // § Version pinning bans `^`, `~` and `latest` in EVERY `@onlineapps/*`
+    // dependency, so it is checked before the narrowing has any say. Being "not
+    // gated" answers one question only — is there an infra version to diverge
+    // from — and it never answers whether the pin may float.
+    if (!EXACT_VERSION.test(version)) {
       violations.push({
         package: name,
-        message: `${name}: not present in the infra library set — the platform does not ship this package version contract.`
+        message: `${name}: version '${version}' is not exact x.y.z — caret/tilde/range pins are banned, `
+          + 'because what resolves today is not what resolved when the image was built. '
+          + `Fix: npm install ${name}@${declared} --save-exact.`
       });
       continue;
     }
-    if (versions[name] !== version) {
+
+    if (bizOnly) continue;
+
+    if (declared !== version) {
       violations.push({
         package: name,
-        message: `${name}: biz pins ${version}, infra ships ${versions[name]} — `
+        message: `${name}: biz pins ${version}, infra ships ${declared} — `
           + 'rebuild the service against the current platform, or deploy the matching infra release first.'
       });
     }

package/src/utils/preValidation.js

@@ -25,6 +25,8 @@
 const fs = require('fs');
 const path = require('path');
 
+const { KIND_STEP, KIND_COOKBOOK_LOAD_FAILURE } = require('./stepFailure');
+
 /**
  * A step error is whatever the handler threw or the transport returned — often
  * an object, not a string. The scripts this replaces interpolated it straight
@@ -42,10 +44,56 @@ function describeStepError(error) {
   }
 }
 
+/**
+ * One failed record of `results.steps`, in the shape the caller reports.
+ *
+ * `results.steps` holds TWO kinds of record and they are not both steps: a step
+ * result, and the entry `CookbookTestRunner.runCookbooks` pushes for a file the
+ * format check rejected — a whole cookbook that produced no step at all. Each
+ * DECLARES which it is in `kind`, written where the record is made (d.516b), so
+ * nothing here infers it from a missing field
+ * (`.claude/rules/architecture-principles.md` §8).
+ *
+ * This is the switchboard `utils/stepFailure.js` § describeStepFailureWithContext
+ * already keeps, for the structured half of the same answer: a cookbook that
+ * never ran is named by its FILE, because there is no step in it to name. Until
+ * d.518 both kinds were read as steps, so a rejected file reached the reader as
+ * `step_id: undefined` — a field naming nothing, about a step that does not
+ * exist, which `src/cli/biz-ci-gate.js` prints verbatim.
+ *
+ * The step's own `step_id` and nothing standing in for it: until d.516 this read
+ * `step.step_id || step.operation`, so a step that named no step_id was reported
+ * under its OPERATION — a field called `step_id` carrying something that is not
+ * one, which the reader has no way to see (§3, No Fallbacks). Since
+ * `@onlineapps/cookbook-core` 5.0.0 the schema requires `step_id` on every task
+ * step (`schemas/cookbook.v2.schema.json` definitions.TaskStep.required), and
+ * since d.460 the orchestrator refuses a task step that names no operation
+ * either (`@onlineapps/conn-orch-orchestrator` § _requireStepOperation), so a
+ * step arriving here without one is a broken cookbook — and a broken cookbook is
+ * what the outcome must show, not a plausible name.
+ *
+ * @param {object} record a failed entry of `results.steps`
+ * @returns {{kind: string, error: string, validationErrors: string[]}} plus
+ *   `cookbook` for a load failure, `step_id` for a step; WHICH of the two it is
+ *   stays in `kind`, so a reader names it with `stepFailure.js`
+ *   § describeRecordIdentity instead of picking a field
+ */
+function describeFailedRecord(record) {
+  const reason = {
+    error: describeStepError(record.error),
+    validationErrors: record.validationErrors || []
+  };
+
+  if (record.kind === KIND_COOKBOOK_LOAD_FAILURE) {
+    return { kind: KIND_COOKBOOK_LOAD_FAILURE, cookbook: record.cookbook, ...reason };
+  }
+
+  return { kind: KIND_STEP, step_id: record.step_id, ...reason };
+}
+
 const COOKBOOKS_RELATIVE_DIR = path.join('tests', 'cookbooks');
 const PROOF_RELATIVE_PATH = path.join('conn-runtime', 'validation-proof.json');
 const OPERATIONS_RELATIVE_PATH = path.join('config', 'service', 'operations.json');
-const VALIDATOR_NAME = '@onlineapps/conn-orch-validator';
 const COOKBOOK_TIMEOUT_MS = 30000;
 
 /**
@@ -104,7 +152,6 @@ async function runPreValidation({ serviceRoot, RunnerClass, ProofGeneratorClass,
   const runner = new RunnerClass({
     serviceName: packageJson.name,
     servicePath: serviceRoot,
-    mockInfrastructure: true,
     timeout: COOKBOOK_TIMEOUT_MS,
     logger
   });
@@ -117,12 +164,8 @@ async function runPreValidation({ serviceRoot, RunnerClass, ProofGeneratorClass,
     // No proof on a failed run. A proof is a claim that the cookbooks passed,
     // so writing one here would make the Registry trust a run that did not.
     const failedSteps = results.steps
-      .filter((step) => !step.passed)
-      .map((step) => ({
-        step_id: step.step_id || step.operation,
-        error: describeStepError(step.error),
-        validationErrors: step.validationErrors || []
-      }));
+      .filter((record) => !record.passed)
+      .map(describeFailedRecord);
 
     return { ok: false, results, failedSteps, proof: null, proofPath: null, filteredBy };
   }
@@ -131,11 +174,13 @@ async function runPreValidation({ serviceRoot, RunnerClass, ProofGeneratorClass,
     return { ok: true, results, failedSteps: [], proof: null, proofPath: null, filteredBy };
   }
 
+  // The validator's own name and version are NOT passed in: they are this
+  // package's identity and the generator reads them from its own package.json
+  // (`src/validatorIdentity.js`, d.524). Passing them made this module carry a
+  // second copy of the package name.
   const proofGenerator = new ProofGeneratorClass({
     serviceName: packageJson.name,
-    serviceVersion: packageJson.version,
-    validatorName: VALIDATOR_NAME,
-    validatorVersion: require('../../package.json').version
+    serviceVersion: packageJson.version
   });
 
   const proof = proofGenerator.generateProof(results, packageJson.dependencies || {});