@guilz-dev/sdlc-gh 0.1.0

package/scripts/test-setup-github-scenarios.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildEvalRulesetPayload, buildRulesetPayload, parseLabels } from "./lib/github-config.mjs";
+import { resolveStackId } from "./lib/doctor-local.mjs";
+
+const labels = parseLabels(`
+- name: task:docs
+  color: "0E8A16"
+  description: Documentation changes
+
+- name: autonomy:L1
+  color: "C2E0C6"
+  description: Draft PR, human review required
+`);
+
+assert.deepEqual(labels, [
+  {
+    name: "task:docs",
+    color: "0E8A16",
+    description: "Documentation changes",
+  },
+  {
+    name: "autonomy:L1",
+    color: "C2E0C6",
+    description: "Draft PR, human review required",
+  },
+]);
+
+const tempDir = mkdtempSync(join(tmpdir(), "sdlc-gh-ruleset-"));
+const template = join(tempDir, "ruleset.example.json");
+writeFileSync(
+  template,
+  JSON.stringify({
+    name: "main-protection",
+    target: "branch",
+    enforcement: "active",
+    rules: [
+      {
+        type: "required_status_checks",
+        parameters: {
+          strict_required_status_checks_policy: false,
+          required_status_checks: [{ context: "harness-static" }],
+        },
+      },
+    ],
+    _comment: "placeholder",
+  }),
+);
+
+const payload = buildRulesetPayload(template, "python");
+const contexts = payload.rules
+  .find((rule) => rule.type === "required_status_checks")
+  .parameters.required_status_checks.map((check) => check.context);
+
+assert.equal(payload.name, "main-protection");
+assert.equal(payload.enforcement, "active");
+assert.deepEqual(contexts, ["diff-size", "harness-static", "issue-spec-check", "product-ci-python"]);
+assert.equal("strict_required_status_checks_policy" in payload.rules[0].parameters, true);
+assert.equal(readFileSync(template, "utf8").includes("_comment"), true);
+assert.equal("_comment" in payload, false);
+
+const evalTemplate = join(tempDir, "ruleset.harness-eval.example.json");
+writeFileSync(
+  evalTemplate,
+  JSON.stringify({
+    name: "harness-pr-eval-required",
+    target: "branch",
+    enforcement: "active",
+    rules: [
+      {
+        type: "required_status_checks",
+        parameters: {
+          strict_required_status_checks_policy: false,
+          required_status_checks: [{ context: "harness-static" }],
+        },
+      },
+    ],
+    _comment: "placeholder",
+  }),
+);
+
+const evalPayload = buildEvalRulesetPayload(evalTemplate);
+const evalContexts = evalPayload.rules
+  .find((rule) => rule.type === "required_status_checks")
+  .parameters.required_status_checks.map((check) => check.context);
+
+assert.equal(evalPayload.name, "harness-pr-eval-required");
+assert.deepEqual(evalContexts, ["harness-static", "select", "trajectory-conventions"]);
+assert.equal("_comment" in evalPayload, false);
+
+const stackRepo = mkdtempSync(join(tmpdir(), "sdlc-gh-stack-resolve-"));
+mkdirSync(join(stackRepo, ".github/workflows"), { recursive: true });
+writeFileSync(join(stackRepo, ".github/workflows/product-ci-go.yml"), "name: product-ci-go\n");
+assert.equal(resolveStackId(stackRepo), "go");
+writeFileSync(join(stackRepo, ".harness-stack"), "python\n");
+assert.equal(resolveStackId(stackRepo), "python");
+
+rmSync(tempDir, { recursive: true, force: true });
+rmSync(stackRepo, { recursive: true, force: true });
+console.log("GitHub setup scenario tests passed");

package/scripts/test-setup-wizard-scenarios.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { localChecks } from "./lib/doctor-local.mjs";
+import {
+  CODEOWNERS_PLACEHOLDER,
+  applyCodeownersOwner,
+  buildWizardPlan,
+  codeownersHasPlaceholder,
+  detectHarnessPresent,
+  detectRepoProfile,
+  isValidCodeownersOwner,
+  suggestStack,
+  writeHarnessStack,
+} from "./lib/setup-wizard.mjs";
+
+assert.equal(isValidCodeownersOwner("@acme/platform"), true);
+assert.equal(isValidCodeownersOwner("@kaz-toc"), true);
+assert.equal(isValidCodeownersOwner("acme/platform"), false);
+
+const templateDir = mkdtempSync(join(tmpdir(), "sdlc-gh-wizard-template-"));
+mkdirSync(join(templateDir, ".github/workflows"), { recursive: true });
+mkdirSync(join(templateDir, "sample/ts"), { recursive: true });
+mkdirSync(join(templateDir, "scripts"), { recursive: true });
+writeFileSync(join(templateDir, ".github/workflows/harness-ci.yml"), "name: harness\n");
+writeFileSync(join(templateDir, ".github/workflows/product-ci-ts.yml"), "name: product-ci-ts\n");
+writeFileSync(join(templateDir, ".github/workflows/product-ci-python.yml"), "name: product-ci-python\n");
+writeFileSync(join(templateDir, "scripts/doctor.mjs"), "// doctor\n");
+writeFileSync(join(templateDir, "sample/ts/package.json"), "{}\n");
+writeFileSync(join(templateDir, "package.json"), "{}\n");
+writeFileSync(
+  join(templateDir, ".github/CODEOWNERS"),
+  `/.github/ ${CODEOWNERS_PLACEHOLDER}\n`,
+);
+
+const templateProfile = detectRepoProfile(templateDir);
+assert.equal(templateProfile.kind, "template");
+assert.equal(templateProfile.template, true);
+assert.equal(detectHarnessPresent(templateDir), true);
+assert.equal(suggestStack(templateDir), "ts");
+
+writeHarnessStack(templateDir, "ts");
+assert.equal(readFileSync(join(templateDir, ".harness-stack"), "utf8"), "ts\n");
+assert.equal(codeownersHasPlaceholder(templateDir), true);
+
+const templateDoctor = localChecks(templateDir, { nodeVersion: "22.0.0", templateMode: true });
+assert.ok(templateDoctor.entries.every((entry) => entry.status === "PASS"));
+
+applyCodeownersOwner(templateDir, "@acme/platform");
+assert.equal(codeownersHasPlaceholder(templateDir), false);
+const templateDoctorPersonalized = localChecks(templateDir, { nodeVersion: "22.0.0", templateMode: true });
+assert.ok(templateDoctorPersonalized.entries.some((e) => e.label === "CODEOWNERS" && e.status === "FAIL"));
+
+const multiProduct = localChecks(templateDir, { nodeVersion: "22.0.0", templateMode: false });
+assert.ok(multiProduct.entries.some((e) => e.label === "product-ci workflow" && e.status === "FAIL"));
+
+const productDir = mkdtempSync(join(tmpdir(), "sdlc-gh-wizard-product-"));
+mkdirSync(join(productDir, ".github/workflows"), { recursive: true });
+writeFileSync(join(productDir, ".harness-stack"), "python\n");
+writeFileSync(join(productDir, ".github/workflows/product-ci-python.yml"), "name: product-ci-python\n");
+writeFileSync(join(productDir, ".github/CODEOWNERS"), "* @acme/platform\n");
+const productDoctor = localChecks(productDir, { nodeVersion: "22.0.0", templateMode: false });
+assert.ok(productDoctor.entries.every((entry) => entry.status === "PASS"));
+
+const plan = buildWizardPlan({
+  repoRoot: templateDir,
+  stackId: "ts",
+  owner: "@acme/platform",
+  githubRepo: "acme/sdlc-gh",
+  template: true,
+  withEvalRuleset: false,
+  yes: true,
+  skipGithub: false,
+  dryRun: false,
+  writeHarnessStack: true,
+  patchCodeowners: true,
+});
+assert.ok(plan.steps.some((step) => step.id === "setup-github"));
+assert.ok(plan.steps.some((step) => step.id === "doctor" && step.detail.includes("--template")));
+
+const unchangedPlan = buildWizardPlan({
+  repoRoot: templateDir,
+  stackId: "ts",
+  owner: "@acme/other",
+  githubRepo: "acme/sdlc-gh",
+  template: false,
+  withEvalRuleset: false,
+  yes: true,
+  skipGithub: true,
+  dryRun: false,
+  writeHarnessStack: true,
+  patchCodeowners: false,
+});
+assert.ok(!unchangedPlan.steps.some((step) => step.id === "codeowners" && step.action === "patch"));
+assert.ok(unchangedPlan.steps.some((step) => step.id === "codeowners" && step.action === "skip"));
+
+const templatePlan = buildWizardPlan({
+  repoRoot: templateDir,
+  stackId: "ts",
+  owner: "(unchanged)",
+  githubRepo: "acme/sdlc-gh",
+  template: true,
+  withEvalRuleset: false,
+  yes: true,
+  skipGithub: false,
+  dryRun: false,
+  writeHarnessStack: true,
+  patchCodeowners: false,
+});
+assert.ok(templatePlan.steps.some((step) => step.id === "codeowners" && step.detail.includes("keep template placeholder")));
+
+console.log("Setup wizard scenario tests passed");

package/scripts/test-telemetry-artifact-scenarios.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import {
+  artifactFilename,
+  buildTelemetryArtifact,
+  buildTelemetryPayload,
+  mapNameToWallFailureType,
+  missingRequiredFields,
+  resolveRetryCount,
+  resolveTaskClass,
+  resolveTaskId,
+  wallFailureTypeFromJobResults,
+} from "./lib/telemetry-artifact.mjs";
+import { patchHarnessCi, stacksForHarness } from "./lib/harness-ci-fragments.mjs";
+
+const base = buildTelemetryPayload({
+  repo: "org/repo",
+  pr_number: 42,
+  pr_body: "fixes #7",
+  labels: "task:docs,autonomy:L2,retry:2",
+  wall_failure_type: "diff-size",
+});
+
+assert.equal(base.payload.task_id, "7");
+assert.equal(base.payload.task_class, "docs");
+assert.equal(base.payload.autonomy_level, "L2");
+assert.equal(base.payload.retry_count, 2);
+assert.equal(base.payload.wall_failure_type, "diff-size");
+assert.equal(missingRequiredFields(base.payload).length, 0);
+assert.ok(base.placeholders.includes("model"));
+
+assert.equal(resolveTaskId("", 99), "pr-99");
+assert.equal(resolveTaskClass(["task:test-fix"]), "test-fix");
+assert.equal(resolveRetryCount(["retry:3"]), 3);
+assert.equal(mapNameToWallFailureType("diff-size"), "diff-size");
+assert.equal(mapNameToWallFailureType("product-ci-ts"), "test");
+assert.equal(
+  wallFailureTypeFromJobResults({
+    "diff-size": { result: "failure" },
+    "harness-static": { result: "success" },
+  }),
+  "diff-size",
+);
+
+const artifact = buildTelemetryArtifact({
+  source: "harness-ci",
+  TELEMETRY_SOURCE: "harness-ci",
+  GITHUB_REPOSITORY: "org/repo",
+  GITHUB_RUN_ID: "12345",
+  pr_number: 10,
+  pr_body: "closes #3",
+});
+assert.equal(artifact.schema_version, "1");
+assert.equal(artifact.source, "harness-ci");
+assert.equal(artifact.payload.pr_number, 10);
+assert.match(artifactFilename({ source: "eval-ci", prNumber: 5, workflowRunId: 9 }), /^eval-ci-pr5-run9\.json$/);
+
+const harnessCi = readFileSync(".github/workflows/harness-ci.yml", "utf8");
+const trimmedTs = patchHarnessCi(harnessCi, stacksForHarness("ts"));
+assert.ok(!trimmedTs.includes("product-python:"), "trimmed harness-ci should drop product-python job");
+assert.ok(trimmedTs.includes("product-ts:"), "trimmed harness-ci should keep product-ts job");
+assert.ok(
+  !/telemetry:[\s\S]*- product-python/.test(trimmedTs),
+  "telemetry needs should not reference trimmed product jobs",
+);
+assert.ok(/telemetry:[\s\S]*- product-ts/.test(trimmedTs), "telemetry needs should reference product-ts");
+
+console.log("telemetry-artifact scenarios ok");

package/scripts/trim-harness-ci.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Trim harness-ci.yml to selected stack(s) for bootstrapped repositories.
+ * Usage: node scripts/trim-harness-ci.mjs <stack-id> <harness-ci.yml path>
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { patchHarnessCi, stacksForHarness } from "./lib/harness-ci-fragments.mjs";
+
+const [stackId, targetPath] = process.argv.slice(2);
+if (!stackId || !targetPath) {
+  console.error("Usage: node scripts/trim-harness-ci.mjs <stack-id> <harness-ci.yml>");
+  process.exit(1);
+}
+
+const stacks = stacksForHarness(stackId);
+const content = readFileSync(targetPath, "utf8");
+writeFileSync(targetPath, patchHarnessCi(content, stacks));
+console.log(`Trimmed ${targetPath} to stack=${stackId}`);

package/scripts/validate-gh-aw-compile.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Validate gh-aw source .md workflows compile to committed .lock.yml without drift.
+ */
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { GH_AW_SOURCE_WORKFLOWS } from "./lib/gh-aw-dogfood.mjs";
+
+function hasGhAw() {
+  try {
+    execSync("gh aw version", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  const required = process.env.GH_AW_COMPILE_REQUIRED === "1";
+  if (!hasGhAw()) {
+    const msg = "gh aw CLI not available; compile validation skipped";
+    if (required) {
+      console.error(`::error::${msg}`);
+      process.exit(1);
+    }
+    console.warn(`::warning::${msg}`);
+    process.exit(0);
+  }
+
+  const issues = [];
+
+  for (const wf of GH_AW_SOURCE_WORKFLOWS) {
+    if (!existsSync(wf.md)) {
+      issues.push(`${wf.md} missing`);
+      continue;
+    }
+    if (!existsSync(wf.lock)) {
+      issues.push(`${wf.lock} missing`);
+      continue;
+    }
+
+    const before = readFileSync(wf.lock, "utf8");
+    try {
+      execSync(`gh aw compile ${wf.id}.md`, { stdio: ["pipe", "pipe", "pipe"] });
+    } catch (error) {
+      issues.push(`gh aw compile failed for ${wf.id}: ${error.stderr?.toString() || error.message}`);
+      continue;
+    }
+    const after = readFileSync(wf.lock, "utf8");
+    if (before !== after) {
+      issues.push(`${wf.lock} drifted after gh aw compile — commit regenerated lock`);
+    }
+  }
+
+  if (issues.length) {
+    console.error("::error::gh-aw compile validation failed:");
+    for (const issue of issues) console.error(`  - ${issue}`);
+    process.exit(1);
+  }
+
+  console.log(`gh-aw compile validation passed (${GH_AW_SOURCE_WORKFLOWS.length} workflow(s))`);
+}
+
+main();

package/scripts/validate-harness.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * Validate harness assets: hooks.json, agent frontmatter, instructions presence.
+ */
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import { loadStacks } from "./lib/stacks.mjs";
+import { patchHarnessCi, stacksForHarness } from "./lib/harness-ci-fragments.mjs";
+import {
+  BOOTSTRAP_LIB_FILES,
+  BOOTSTRAP_SCRIPT_MJS,
+  SCRIPT_LIB_IMPORTS,
+} from "./lib/bootstrap-copy.mjs";
+import { CODEOWNERS_PLACEHOLDER, detectRepoProfile } from "./lib/setup-wizard.mjs";
+import {
+  NPM_PACKAGE_FILES,
+  validateNpmSampleCoverage,
+  validatePackageJsonFiles,
+} from "./lib/npm-package.mjs";
+
+const ROOT = process.cwd();
+let errors = 0;
+
+function fail(msg) {
+  console.error(`ERROR: ${msg}`);
+  errors++;
+}
+
+function warn(msg) {
+  console.warn(`WARN: ${msg}`);
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const m = line.match(/^(\w+):\s*(.+)$/);
+    if (m) fm[m[1]] = m[2].replace(/^['"]|['"]$/g, "");
+  }
+  return fm;
+}
+
+// hooks.json
+const hooksPath = join(ROOT, ".github/hooks/hooks.json");
+if (existsSync(hooksPath)) {
+  try {
+    const hooks = JSON.parse(readFileSync(hooksPath, "utf8"));
+    if (!Array.isArray(hooks.hooks) && !hooks.hooks) {
+      fail("hooks.json: expected hooks array or object with hooks key");
+    }
+  } catch (e) {
+    fail(`hooks.json: invalid JSON — ${e.message}`);
+  }
+} else {
+  warn("hooks.json not found (optional until Phase 1)");
+}
+
+// agents
+const agentsDir = join(ROOT, ".github/agents");
+if (existsSync(agentsDir)) {
+  for (const f of readdirSync(agentsDir).filter((x) => x.endsWith(".agent.md"))) {
+    const content = readFileSync(join(agentsDir, f), "utf8");
+    const fm = parseFrontmatter(content);
+    if (!fm) fail(`${f}: missing YAML frontmatter`);
+    else {
+      if (!fm.name) fail(`${f}: frontmatter missing 'name'`);
+      if (!fm.description) fail(`${f}: frontmatter missing 'description'`);
+    }
+  }
+}
+
+// instructions
+const instrDir = join(ROOT, ".github/instructions");
+if (existsSync(instrDir)) {
+  const walk = (dir) => {
+    for (const e of readdirSync(dir)) {
+      const p = join(dir, e);
+      if (statSync(p).isDirectory()) walk(p);
+      else if (e.endsWith(".instructions.md")) {
+        const fm = parseFrontmatter(readFileSync(p, "utf8"));
+        if (!fm?.description) fail(`${relative(ROOT, p)}: missing description in frontmatter`);
+      }
+    }
+  };
+  walk(instrDir);
+}
+
+// labels.yml
+if (existsSync(join(ROOT, ".github/labels.yml"))) {
+  const labels = readFileSync(join(ROOT, ".github/labels.yml"), "utf8");
+  if (!labels.includes("task:")) warn("labels.yml: no task:* labels found");
+}
+
+// stack catalog consistency
+const catalogPath = join(ROOT, "config/stacks.json");
+const harnessCiPath = join(ROOT, ".github/workflows/harness-ci.yml");
+if (existsSync(catalogPath) && existsSync(harnessCiPath)) {
+  const harnessCi = readFileSync(harnessCiPath, "utf8");
+  try {
+    const expected = patchHarnessCi(harnessCi, stacksForHarness());
+    if (harnessCi !== expected) {
+      fail("harness-ci.yml: detect/product jobs are out of sync with config/stacks.json");
+    }
+  } catch (e) {
+    fail(`harness-ci.yml: ${e.message}`);
+  }
+
+  for (const stack of loadStacks()) {
+    const profilePath = join(ROOT, ".github/instructions/profiles", stack.profile);
+    const workflowPath = join(ROOT, ".github/workflows", stack.workflow);
+    const sampleMarkerPath = join(ROOT, stack.sampleMarker);
+
+    if (!existsSync(profilePath)) {
+      fail(`missing profile for stack ${stack.id}: ${stack.profile}`);
+    }
+    if (!existsSync(workflowPath)) {
+      fail(`missing workflow for stack ${stack.id}: ${stack.workflow}`);
+    }
+    if (!existsSync(sampleMarkerPath)) {
+      fail(`missing sample marker for stack ${stack.id}: ${stack.sampleMarker}`);
+    }
+
+    const workflow = readFileSync(workflowPath, "utf8");
+    const sampleDir = `sample/${stack.sampleDir}`;
+    if (!workflow.includes(sampleDir) || !workflow.includes(stack.marker)) {
+      fail(`${stack.workflow}: missing sample/root resolution for ${stack.id}`);
+    }
+  }
+} else {
+  warn("config/stacks.json or harness-ci.yml not found — skipping stack catalog checks");
+}
+
+// script -> lib import resolution (bootstrap copy drift guard)
+for (const [script, libs] of Object.entries(SCRIPT_LIB_IMPORTS)) {
+  const scriptPath = join(ROOT, "scripts", script);
+  if (!existsSync(scriptPath)) {
+    fail(`missing script entrypoint: scripts/${script}`);
+    continue;
+  }
+  for (const lib of libs) {
+    if (!existsSync(join(ROOT, "scripts/lib", lib))) {
+      fail(`scripts/${script} requires scripts/lib/${lib} but file is missing`);
+    }
+  }
+}
+
+for (const lib of BOOTSTRAP_LIB_FILES) {
+  if (!existsSync(join(ROOT, "scripts/lib", lib))) {
+    fail(`bootstrap lib manifest missing in template: scripts/lib/${lib}`);
+  }
+}
+
+for (const script of BOOTSTRAP_SCRIPT_MJS) {
+  if (!existsSync(join(ROOT, "scripts", script))) {
+    fail(`bootstrap script manifest missing in template: scripts/${script}`);
+  }
+}
+
+const bootstrapSh = readFileSync(join(ROOT, "scripts/bootstrap-harness.sh"), "utf8");
+for (const lib of BOOTSTRAP_LIB_FILES) {
+  if (!bootstrapSh.includes(lib)) {
+    fail(`bootstrap-harness.sh does not copy scripts/lib/${lib}`);
+  }
+}
+
+const pkgFilesCheck = validatePackageJsonFiles(ROOT);
+if (!pkgFilesCheck.ok) {
+  fail(pkgFilesCheck.reason);
+}
+
+const npmCoverage = validateNpmSampleCoverage(ROOT);
+for (const entry of npmCoverage.missingOnDisk) {
+  fail(`npm package files entry missing on disk: ${entry}`);
+}
+for (const relPath of npmCoverage.notPacked) {
+  fail(`sample file not covered by npm files (${NPM_PACKAGE_FILES.length} entries): ${relPath}`);
+}
+
+const templateProfile = detectRepoProfile(ROOT);
+if (templateProfile.template) {
+  const codeownersPath = join(ROOT, ".github/CODEOWNERS");
+  if (!existsSync(codeownersPath)) {
+    fail("template repo missing .github/CODEOWNERS");
+  } else {
+    const codeowners = readFileSync(codeownersPath, "utf8");
+    if (!codeowners.includes(CODEOWNERS_PLACEHOLDER)) {
+      fail(
+        `template repo .github/CODEOWNERS must keep placeholder ${CODEOWNERS_PLACEHOLDER} (do not commit personal or org-specific owners)`,
+      );
+    }
+  }
+}
+
+if (errors > 0) {
+  console.error(`\n${errors} validation error(s)`);
+  process.exit(1);
+}
+console.log("Harness validation passed");

package/scripts/validate-telemetry.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/** Validate telemetry payload against docs/telemetry-schema.md required fields */
+import { missingRequiredFields, TELEMETRY_REQUIRED_FIELDS } from "./lib/telemetry-artifact.mjs";
+
+const raw = process.argv[2] || "{}";
+const parsed = JSON.parse(raw);
+const payload = parsed.payload ?? parsed;
+
+const missing = missingRequiredFields(payload);
+if (missing.length) {
+  console.error("Missing telemetry fields:", missing.join(", "));
+  process.exit(1);
+}
+
+if (process.env.HARNESS_STRICT_TELEMETRY === "1" && parsed.placeholders?.length) {
+  console.error("Strict telemetry: unresolved placeholders:", parsed.placeholders.join(", "));
+  process.exit(1);
+}
+
+console.log("Telemetry payload valid");
+console.log(`Required field count: ${TELEMETRY_REQUIRED_FIELDS.length}`);