@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-TDEMDRN2.js

@@ -0,0 +1,1639 @@
+import {
+  resolveSynthesisGateFlag
+} from "./chunk-I6FN3R5D.js";
+import {
+  findLabRun,
+  findLatestLabRun,
+  listLabRuns
+} from "./chunk-FT7SGLXT.js";
+import {
+  readCompetitionState,
+  resolveCliStateRoots
+} from "./chunk-AAAODV76.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  formatVerificationLabel
+} from "./chunk-R2CKS6WT.js";
+import {
+  readVariantVerification
+} from "./chunk-3OPP2OZB.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  resolveRunStateDir
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  resolveCliRepoRoot
+} from "./chunk-7VRJHTGZ.js";
+
+// src/cli/commands/telemetry-reliability.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+import { Command } from "commander";
+import { z } from "zod";
+
+// src/cli/utils/reliability-paths.ts
+import * as path from "path";
+function resolveReliabilityPaths(cwd, labPathResolver) {
+  const buildDir = path.join(cwd, ".build-project");
+  const stateRootDir = labPathResolver.getStateDir(buildDir);
+  const defaultTelemetryStateDir = resolveRunStateDir(buildDir);
+  const unifiedStateDir = stateRootDir === defaultTelemetryStateDir ? resolveCliStateRoots(cwd).unifiedStateDir : stateRootDir;
+  return {
+    stateDir: path.join(stateRootDir, "competitions"),
+    variantDir: path.join(stateRootDir, "variants"),
+    backgroundDir: path.join(stateRootDir, "background"),
+    unifiedStateDir,
+    synthesisDir: path.join(labPathResolver.getTelemetryDir(buildDir), "synthesis")
+  };
+}
+
+// src/cli/commands/telemetry-reliability-gates.ts
+function extractGateFailure(details) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return null;
+  const record = details;
+  const gate = typeof record.gate === "string" && record.gate.length > 0 ? record.gate : "unknown";
+  const status = typeof record.status === "string" && record.status.length > 0 ? record.status : "failed";
+  return { gate, status };
+}
+function isSynthesisGateFailure(synthesis) {
+  return resolveSynthesisGateFlag(synthesis) === "failed";
+}
+function classifySynthesisFailure(synthesis) {
+  if (synthesis.success === false) return "synthesis_failure";
+  if (!isSynthesisGateFailure(synthesis)) return null;
+  const gateFailure = extractGateFailure(synthesis.gateFailureDetails);
+  if (gateFailure?.gate === "patch_apply") return "patch_apply_failure";
+  return "gate_rejection";
+}
+
+// src/cli/commands/telemetry-selection-coverage.ts
+function isVerifiedStatus(status) {
+  return status === "passed" || status === "baseline_clean";
+}
+function isVerifiedDelivery(run) {
+  return run.safeDelivery.safe && isVerifiedStatus(run.safeDelivery.winnerVerificationStatus);
+}
+function calculateVerifiedDeliveryRate(runs) {
+  const deliveryRuns = runs.filter((run) => run.runKind === "delivery");
+  if (deliveryRuns.length === 0) return null;
+  return deliveryRuns.filter(isVerifiedDelivery).length / deliveryRuns.length;
+}
+function summarizeSelectionCoverage(runs) {
+  const deliveryRuns = runs.filter((run) => run.runKind === "delivery");
+  const covered = deliveryRuns.filter((run) => run.verifiedVariants > 0);
+  const gap = covered.filter(
+    (run) => run.winner && !isVerifiedStatus(run.safeDelivery.winnerVerificationStatus)
+  );
+  return {
+    delivery_runs: deliveryRuns.length,
+    verified_delivery_rate: calculateVerifiedDeliveryRate(runs),
+    runs_with_verified_variant: covered.length,
+    verified_coverage_rate: deliveryRuns.length > 0 ? covered.length / deliveryRuns.length : null,
+    winner_unverified_with_verified_alternative: gap.length
+  };
+}
+
+// src/cli/commands/telemetry-reliability.ts
+var RELIABILITY_PROFILES = ["advisory", "strict"];
+var PROVIDER_SPIKE_MIN_TOTAL = 3;
+var PROVIDER_SPIKE_MIN_FAILURES = 2;
+var PROVIDER_SPIKE_FAILURE_RATE = 0.5;
+var FALLBACK_RATE_MIN_ATTEMPTS = 3;
+var FALLBACK_RATE_WARNING = 0.5;
+var DELIVERY_TREND_WINDOW_SIZE = 5;
+var DELIVERY_TREND_WARNING_RATE = 0.9;
+var TelemetryReliabilityOptionsSchema = z.object({
+  campaignLabId: z.string().optional(),
+  campaignRuns: z.string().optional(),
+  includeTestFixtures: z.boolean().optional(),
+  json: z.boolean().optional(),
+  lab: z.union([z.string(), z.boolean()]).optional(),
+  labId: z.string().optional(),
+  limit: z.string().optional(),
+  profile: z.enum(RELIABILITY_PROFILES).optional(),
+  runId: z.string().optional(),
+  since: z.string().optional()
+}).strict();
+function parseLimit(raw) {
+  if (raw === void 0) return 20;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid --limit value "${raw}". Expected a positive integer.`);
+  }
+  return parsed;
+}
+function parseSinceCutoff(raw, nowMs = Date.now()) {
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  const durationMatch = /^(\d+)([smhd])$/.exec(trimmed);
+  if (durationMatch) {
+    const amount = Number.parseInt(durationMatch[1] ?? "0", 10);
+    const unit = durationMatch[2];
+    const multiplier = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 60 * 6e4 : 24 * 60 * 6e4;
+    return nowMs - amount * multiplier;
+  }
+  const timestamp = Date.parse(trimmed);
+  if (Number.isNaN(timestamp)) {
+    throw new Error(`Invalid --since value "${raw}". Expected duration like 2h or ISO timestamp.`);
+  }
+  return timestamp;
+}
+function resolveProfile(raw) {
+  return raw ?? "advisory";
+}
+function readJsonObjectWithDiagnostics(filePath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return {
+      value: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null
+    };
+  } catch (error) {
+    return {
+      value: null,
+      parseError: error instanceof Error ? error.message : String(error),
+      filePath
+    };
+  }
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function synthesisFromRecord(record) {
+  if (!record) return void 0;
+  return {
+    success: optionalBoolean(record.success),
+    prNumber: typeof record.prNumber === "number" ? record.prNumber : void 0,
+    prUrl: optionalString(record.prUrl),
+    error: optionalString(record.error),
+    mergedVariants: Array.isArray(record.mergedVariants) ? record.mergedVariants.filter((value) => typeof value === "string") : [],
+    donorSelectionDecisions: Array.isArray(record.donorSelectionDecisions) ? record.donorSelectionDecisions : void 0,
+    deliverySucceeded: optionalBoolean(record.deliverySucceeded),
+    synthesisApplied: optionalBoolean(record.synthesisApplied),
+    complementaryPatchApplied: optionalBoolean(record.complementaryPatchApplied),
+    applyMode: optionalString(record.applyMode),
+    winnerFallback: optionalBoolean(record.winnerFallback),
+    fallbackReason: optionalString(record.fallbackReason),
+    patchApplyValidated: optionalBoolean(record.patchApplyValidated),
+    gatesPassed: optionalBoolean(record.gatesPassed),
+    gateFailureDetails: record.gateFailureDetails,
+    synthesisOutcomeStatus: optionalString(record.synthesisOutcomeStatus),
+    intentFilteredHunkCount: optionalNumber(record.intentFilteredHunkCount),
+    excludedHunkCount: optionalNumber(record.excludedHunkCount),
+    unknownIncludedHunkCount: optionalNumber(record.unknownIncludedHunkCount),
+    overlapRejectedHunkCount: optionalNumber(record.overlapRejectedHunkCount),
+    aiGuidedFallbackAttempted: optionalBoolean(record.aiGuidedFallbackAttempted),
+    aiGuidedFallbackOutcome: optionalString(record.aiGuidedFallbackOutcome)
+  };
+}
+function incrementProvider(providers, provider, failureType) {
+  const summary = providers[provider] ?? { total: 0, failures: 0, failureTypes: {} };
+  providers[provider] = summary;
+  summary.total += 1;
+  if (failureType) {
+    summary.failures += 1;
+    summary.failureTypes[failureType] = (summary.failureTypes[failureType] ?? 0) + 1;
+  }
+}
+function incrementFailureType(report, failureType) {
+  report.failures.byType[failureType] = (report.failures.byType[failureType] ?? 0) + 1;
+}
+function incrementGateFailure(gateFailures, gate, status) {
+  const summary = gateFailures[gate] ?? { count: 0, statuses: {} };
+  gateFailures[gate] = summary;
+  summary.count += 1;
+  summary.statuses[status] = (summary.statuses[status] ?? 0) + 1;
+}
+function isTestFixtureCompetitionId(id) {
+  return /^test[-_]/.test(id);
+}
+function listRecentCompetitionIds(stateDir, limit, options = {}) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(stateDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => {
+      const filePath = path2.join(stateDir, entry.name);
+      return {
+        id: entry.name.replace(/\.json$/, ""),
+        mtimeMs: fs.statSync(filePath).mtimeMs
+      };
+    });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => options.includeTestFixtures || !isTestFixtureCompetitionId(entry.id)).filter(
+    (entry) => options.sinceMs === null || options.sinceMs === void 0 || entry.mtimeMs >= options.sinceMs
+  ).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit).map((entry) => entry.id);
+}
+function listRecentLabVariantCompetitionIds(variantDir, limit, options = {}) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(variantDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".adaptive-setup.json")).map((entry) => {
+      const filePath = path2.join(variantDir, entry.name);
+      return {
+        id: entry.name.replace(/\.adaptive-setup\.json$/, ""),
+        mtimeMs: fs.statSync(filePath).mtimeMs
+      };
+    });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => options.includeTestFixtures || !isTestFixtureCompetitionId(entry.id)).filter(
+    (entry) => options.sinceMs === null || options.sinceMs === void 0 || entry.mtimeMs >= options.sinceMs
+  ).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit).map((entry) => entry.id);
+}
+function formatObservedAt(ms) {
+  return new Date(ms).toISOString();
+}
+function observedCompetitionBounds(stateDir, competitionIds) {
+  const timestamps = competitionIds.map((id) => {
+    try {
+      return fs.statSync(path2.join(stateDir, `${id}.json`)).mtimeMs;
+    } catch {
+      return null;
+    }
+  }).filter((value) => value !== null);
+  if (timestamps.length === 0) {
+    return { oldestObservedAt: null, newestObservedAt: null };
+  }
+  return {
+    oldestObservedAt: formatObservedAt(Math.min(...timestamps)),
+    newestObservedAt: formatObservedAt(Math.max(...timestamps))
+  };
+}
+function observedLabVariantBounds(variantDir, competitionIds) {
+  const timestamps = competitionIds.map((id) => {
+    try {
+      return fs.statSync(path2.join(variantDir, `${id}.adaptive-setup.json`)).mtimeMs;
+    } catch {
+      return null;
+    }
+  }).filter((value) => value !== null);
+  if (timestamps.length === 0) {
+    return { oldestObservedAt: null, newestObservedAt: null };
+  }
+  return {
+    oldestObservedAt: formatObservedAt(Math.min(...timestamps)),
+    newestObservedAt: formatObservedAt(Math.max(...timestamps))
+  };
+}
+function labVariantFiles(variantDir, competitionId) {
+  try {
+    return fs.readdirSync(variantDir, { withFileTypes: true }).filter(
+      (entry) => entry.isFile() && entry.name.startsWith(`${competitionId}-`) && entry.name.endsWith(".json") && !entry.name.endsWith(".lifecycle.json")
+    ).map((entry) => path2.join(variantDir, entry.name));
+  } catch {
+    return [];
+  }
+}
+function labVariantStateFromRecord(record) {
+  const result = getRecordValue(record, "result");
+  const outcome = getRecordValue(record, "outcome");
+  const verification = getRecordValue(outcome, "verification");
+  return {
+    provider: optionalString(record.provider) ?? "unknown",
+    model: optionalString(record.model),
+    resolvedModel: optionalString(record.resolvedModel),
+    executionMode: optionalString(record.executionMode),
+    success: optionalBoolean(record.success),
+    outcome: verification && typeof verification === "object" && !Array.isArray(verification) ? {
+      verification: {
+        status: optionalString(getRecordValue(verification, "status")),
+        buildStatus: optionalString(getRecordValue(verification, "buildStatus")),
+        testStatus: optionalString(getRecordValue(verification, "testStatus"))
+      }
+    } : void 0,
+    testStatus: optionalString(record.testStatus),
+    testMetrics: typeof record.testMetrics === "object" && record.testMetrics !== null ? record.testMetrics : void 0,
+    testsExecuted: typeof record.testsExecuted === "object" && record.testsExecuted !== null ? record.testsExecuted : void 0,
+    completeness: optionalNumber(record.completeness),
+    duration: optionalNumber(record.duration),
+    errorMessage: optionalString(record.errorMessage) ?? optionalString(getRecordValue(result, "error")) ?? optionalString(getRecordValue(result, "stderr")),
+    timedOut: optionalBoolean(record.timedOut),
+    terminationReason: optionalString(record.terminationReason)
+  };
+}
+function readLabVariantCompetitionState(competitionId, variantDir) {
+  const records = labVariantFiles(variantDir, competitionId).map((filePath) => readJsonObjectWithDiagnostics(filePath).value).filter((record) => record !== null);
+  const variants = records.map(labVariantStateFromRecord);
+  if (variants.length === 0) return null;
+  const winner = variants.find((variant) => variant.success === true) ?? null;
+  const allAnalysis = records.every(
+    (record) => getRecordValue(record, "executionIntent") === "analysis"
+  );
+  return {
+    taskId: competitionId,
+    primarySource: "competition_handle",
+    status: variants.every((variant) => variant.success === false) ? "failed" : "completed",
+    outcome: winner ? "winner_selected" : "all_failed",
+    winner: winner ? {
+      provider: winner.provider,
+      model: winner.model,
+      resolvedModel: winner.resolvedModel,
+      executionMode: winner.executionMode
+    } : null,
+    variants,
+    sources: {
+      competitionHandle: {
+        path: variantDir,
+        readAt: (/* @__PURE__ */ new Date()).toISOString(),
+        exists: true
+      },
+      backgroundHandle: {
+        path: "",
+        readAt: (/* @__PURE__ */ new Date()).toISOString(),
+        exists: false
+      },
+      unifiedState: {
+        path: "",
+        readAt: (/* @__PURE__ */ new Date()).toISOString(),
+        exists: false
+      }
+    },
+    rawHandle: allAnalysis ? { deliverableContract: { editsExpected: false, executionIntentEffective: "analysis" } } : void 0
+  };
+}
+function classifyVariantFailure(variant) {
+  if (variant.success !== false) return null;
+  const terminationReason = variant.terminationReason?.toLowerCase() ?? "";
+  const message = variant.errorMessage?.toLowerCase() ?? "";
+  const crashSignalPattern = /\b(sigkill|sigsegv|sigabrt|sigbus|sigill|sigquit)\b/;
+  if (variant.timedOut === true || terminationReason.includes("timeout") || message.includes("timeout") || message.includes("timed out") || message.includes("sigterm")) {
+    return "timeout";
+  }
+  if (message.includes("invalid json") || message.includes("not valid json") || message.includes("malformed json") || message.includes("unexpected token")) {
+    return "malformed_json";
+  }
+  if (terminationReason.includes("crash")) {
+    return "process_crash";
+  }
+  if (crashSignalPattern.test(terminationReason) || crashSignalPattern.test(message) || message.includes("segmentation fault") || message.includes("killed by signal") || message.includes("exited with code 137")) {
+    return "process_crash";
+  }
+  if (terminationReason.includes("failed_error") || message.length > 0) {
+    return "provider_error";
+  }
+  return "unknown_provider_failure";
+}
+function readRecordedVerification(variant) {
+  const hasRecord = typeof variant.outcome?.verification?.status === "string" || variant.testStatus !== void 0 || typeof variant.testsExecuted?.exitCode === "number" || typeof variant.testMetrics?.failedTests === "number";
+  return hasRecord ? readVariantVerification(variant) : null;
+}
+function getVerificationStatus(variant) {
+  const verification = readRecordedVerification(variant);
+  return verification ? formatVerificationLabel(verification) : null;
+}
+function getVerificationFailure(variant) {
+  const verification = readRecordedVerification(variant);
+  if (verification?.status !== "failed") return null;
+  return {
+    provider: variant.provider,
+    model: variant.resolvedModel ?? variant.model ?? null,
+    executionMode: variant.executionMode ?? null,
+    status: formatVerificationLabel(verification),
+    buildStatus: verification.gates.build.status,
+    testStatus: verification.gates.test.status
+  };
+}
+function variantMatchesWinner(variant, winner) {
+  if (!winner) return false;
+  if (variant.provider !== winner.provider) return false;
+  if (winner.executionMode && variant.executionMode && variant.executionMode !== winner.executionMode) {
+    return false;
+  }
+  const winnerModels = [winner.resolvedModel, winner.model].filter(
+    (model) => typeof model === "string" && model.length > 0
+  );
+  const variantModels = [variant.resolvedModel, variant.model].filter(
+    (model) => typeof model === "string" && model.length > 0
+  );
+  if (winnerModels.length === 0 || variantModels.length === 0) return true;
+  return winnerModels.some((model) => variantModels.includes(model));
+}
+function getWinnerVerificationFailure(state) {
+  if (!state.winner) return null;
+  const winnerVariant = state.variants.find(
+    (variant) => variantMatchesWinner(variant, state.winner)
+  );
+  return winnerVariant ? getVerificationFailure(winnerVariant) : null;
+}
+function getWinnerVerificationStatus(state) {
+  if (!state.winner) return null;
+  const winnerVariant = state.variants.find(
+    (variant) => variantMatchesWinner(variant, state.winner)
+  );
+  return winnerVariant ? getVerificationStatus(winnerVariant) : null;
+}
+function incrementVerificationSummary(summary, status) {
+  if (status === "passed") summary.passed += 1;
+  else if (status === "failed" || status === "timeout") summary.failed += 1;
+  else if (status === "baseline_clean") summary.baselineClean += 1;
+  else if (status === "not_run" || status === "unavailable") summary.notRun += 1;
+}
+function summarizeRunSynthesis(synthesis) {
+  return {
+    attempted: Boolean(synthesis),
+    applied: synthesis?.synthesisApplied ?? null,
+    complementaryPatchApplied: synthesis?.complementaryPatchApplied ?? null,
+    applyMode: synthesis?.applyMode ?? null,
+    winnerFallback: synthesis?.winnerFallback ?? null,
+    deliverySucceeded: synthesis?.deliverySucceeded ?? null,
+    gatesPassed: synthesis?.gatesPassed ?? null,
+    fallbackReason: synthesis?.fallbackReason ?? null,
+    error: synthesis?.error ?? null,
+    gateFailure: extractGateFailure(synthesis?.gateFailureDetails),
+    donorSelectionDecisions: synthesis?.donorSelectionDecisions ?? null,
+    intentFilteredHunkCount: synthesis?.intentFilteredHunkCount ?? null,
+    excludedHunkCount: synthesis?.excludedHunkCount ?? null,
+    unknownIncludedHunkCount: synthesis?.unknownIncludedHunkCount ?? null,
+    overlapRejectedHunkCount: synthesis?.overlapRejectedHunkCount ?? null,
+    aiGuidedFallbackAttempted: synthesis?.aiGuidedFallbackAttempted ?? null,
+    aiGuidedFallbackOutcome: synthesis?.aiGuidedFallbackOutcome ?? null
+  };
+}
+function summarizeSafeDelivery(state, synthesis, runKind) {
+  const winnerVerificationStatus = getWinnerVerificationStatus(state);
+  if (state.winner && (state.outcome === "winner_selected" || state.status === "completed")) {
+    return { safe: true, basis: "winner_selected", reason: null, winnerVerificationStatus };
+  }
+  if (synthesis?.deliverySucceeded === true) {
+    return { safe: true, basis: "synthesis_delivery", reason: null, winnerVerificationStatus };
+  }
+  if (runKind === "analysis") {
+    const hasSuccessfulAnalysisOutput = state.status === "completed" && state.variants.some(
+      (variant) => variant.success === true && !variant.errorMessage && variant.timedOut !== true && variant.terminationReason !== "timeout"
+    );
+    return {
+      safe: hasSuccessfulAnalysisOutput,
+      basis: hasSuccessfulAnalysisOutput ? "analysis_result" : "analysis_no_result",
+      reason: hasSuccessfulAnalysisOutput ? null : state.errorMessage ?? synthesis?.error ?? "No successful analysis output preserved",
+      winnerVerificationStatus
+    };
+  }
+  const reason = state.errorMessage ?? synthesis?.error ?? synthesis?.fallbackReason ?? "No winner preserved";
+  return {
+    safe: false,
+    basis: state.winner ? "delivery_failed" : "no_winner",
+    reason,
+    winnerVerificationStatus
+  };
+}
+function getRecordValue(value, key) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
+}
+function classifyRunKind(state) {
+  const deliverableContract = getRecordValue(state.rawHandle, "deliverableContract");
+  const editsExpected = getRecordValue(deliverableContract, "editsExpected");
+  const executionIntentEffective = getRecordValue(deliverableContract, "executionIntentEffective");
+  if (editsExpected === false && executionIntentEffective === "analysis") {
+    return "analysis";
+  }
+  return "delivery";
+}
+function summarizeRun(taskId, state, synthesis, providerFailures, verificationFailures, incompleteSpecInputs, verifiedVariants, observedAt) {
+  const winner = state.winner ? {
+    provider: state.winner.provider ?? null,
+    model: state.winner.resolvedModel ?? state.winner.model ?? null,
+    variant: state.winner.variant ?? null
+  } : null;
+  const runKind = classifyRunKind(state);
+  return {
+    taskId,
+    runKind,
+    observedAt,
+    status: state.status ?? null,
+    outcome: state.outcome ?? null,
+    winner,
+    safeDelivery: summarizeSafeDelivery(state, synthesis, runKind),
+    providerFailures,
+    verificationFailures,
+    incompleteSpecInputs,
+    verifiedVariants,
+    synthesis: summarizeRunSynthesis(synthesis)
+  };
+}
+function observedCompetitionAt(stateDir, competitionId) {
+  try {
+    return formatObservedAt(fs.statSync(path2.join(stateDir, `${competitionId}.json`)).mtimeMs);
+  } catch {
+    return null;
+  }
+}
+function readSynthesisArtifactRecord(synthesisDirs, taskId) {
+  for (const synthesisDir of synthesisDirs) {
+    const artifactPath = path2.join(synthesisDir, `${taskId}.json`);
+    if (fs.existsSync(artifactPath)) {
+      return readJsonObjectWithDiagnostics(artifactPath);
+    }
+  }
+  return { value: null };
+}
+function addAdvisorySignal(report, signal) {
+  report.advisory.signals.push(signal);
+}
+function calculateSafeDeliveryRate(runs) {
+  const deliveryRuns = runs.filter((run) => run.runKind === "delivery");
+  if (deliveryRuns.length === 0) return null;
+  return deliveryRuns.filter((run) => run.safeDelivery.safe).length / deliveryRuns.length;
+}
+function calculateDeliveryTrend(runs) {
+  const deliveryRuns = runs.filter((run) => run.runKind === "delivery");
+  const recentRuns = deliveryRuns.slice(0, DELIVERY_TREND_WINDOW_SIZE);
+  const previousRuns = deliveryRuns.slice(
+    DELIVERY_TREND_WINDOW_SIZE,
+    DELIVERY_TREND_WINDOW_SIZE * 2
+  );
+  const recentRate = calculateSafeDeliveryRate(recentRuns);
+  const previousRate = previousRuns.length === DELIVERY_TREND_WINDOW_SIZE ? calculateSafeDeliveryRate(previousRuns) : null;
+  return {
+    windowSize: DELIVERY_TREND_WINDOW_SIZE,
+    sampleSize: recentRuns.length + previousRuns.length,
+    recentRate,
+    previousRate,
+    delta: recentRate !== null && previousRate !== null ? recentRate - previousRate : null,
+    threshold: DELIVERY_TREND_WARNING_RATE,
+    status: recentRuns.length < DELIVERY_TREND_WINDOW_SIZE ? "insufficient_data" : recentRate !== null && recentRate < DELIVERY_TREND_WARNING_RATE ? "warning" : "ok"
+  };
+}
+function hasIncompleteInputSpec(variant) {
+  const warning = variant.inputSpecWarning;
+  if (!warning) return false;
+  return warning.hasFillPlaceholders === true || (warning.missingFields?.length ?? 0) > 0;
+}
+function populateReliabilityAdvisory(report) {
+  const deliveryRuns = report.runs.filter((run) => run.runKind === "delivery");
+  const unsafeRuns = deliveryRuns.filter((run) => !run.safeDelivery.safe);
+  const fallbackRuns = report.runs.filter((run) => run.synthesis.winnerFallback === true);
+  const incompleteSpecRuns = report.runs.filter((run) => run.incompleteSpecInputs > 0);
+  const verificationFailedRuns = report.runs.filter((run) => run.verificationFailures.length > 0);
+  report.advisory.unsafeRuns = unsafeRuns.length;
+  report.advisory.fallbackRuns = fallbackRuns.length;
+  report.advisory.fallbackRate = report.synthesis.attempted > 0 ? fallbackRuns.length / report.synthesis.attempted : null;
+  report.advisory.deliveryTrend = calculateDeliveryTrend(report.runs);
+  for (const [provider, summary] of Object.entries(report.providers)) {
+    const rate = summary.total > 0 ? summary.failures / summary.total : null;
+    report.advisory.providerFailureRates[provider] = {
+      total: summary.total,
+      failures: summary.failures,
+      rate
+    };
+    if (summary.total >= PROVIDER_SPIKE_MIN_TOTAL && summary.failures >= PROVIDER_SPIKE_MIN_FAILURES && rate !== null && rate >= PROVIDER_SPIKE_FAILURE_RATE) {
+      addAdvisorySignal(report, {
+        code: "provider_failure_spike",
+        severity: "warning",
+        message: `${provider} failed ${summary.failures}/${summary.total} recent variants.`,
+        value: rate,
+        threshold: PROVIDER_SPIKE_FAILURE_RATE,
+        provider,
+        taskIds: report.runs.filter((run) => run.providerFailures.some((failure) => failure.provider === provider)).map((run) => run.taskId)
+      });
+    }
+  }
+  if (unsafeRuns.length > 0) {
+    addAdvisorySignal(report, {
+      code: "unsafe_runs_observed",
+      severity: "warning",
+      message: `${unsafeRuns.length} recent competition(s) did not preserve safe delivery.`,
+      value: unsafeRuns.length,
+      threshold: 0,
+      provider: null,
+      taskIds: unsafeRuns.map((run) => run.taskId)
+    });
+  }
+  if (incompleteSpecRuns.length > 0) {
+    addAdvisorySignal(report, {
+      code: "incomplete_spec_inputs_observed",
+      severity: "warning",
+      message: `${report.inputQuality.incompleteVariants} recent variant(s) used incomplete input specs.`,
+      value: report.inputQuality.incompleteVariants,
+      threshold: 0,
+      provider: null,
+      taskIds: incompleteSpecRuns.map((run) => run.taskId)
+    });
+  }
+  if (verificationFailedRuns.length > 0) {
+    addAdvisorySignal(report, {
+      code: "verification_failures_observed",
+      severity: "warning",
+      message: `${report.verification.failed} recent variant(s) failed deterministic verification.`,
+      value: report.verification.failed,
+      threshold: 0,
+      provider: null,
+      taskIds: verificationFailedRuns.map((run) => run.taskId)
+    });
+  }
+  if (report.advisory.deliveryTrend.status === "warning") {
+    const recentRate = report.advisory.deliveryTrend.recentRate ?? 0;
+    const recentDeliveryRuns = deliveryRuns.slice(0, DELIVERY_TREND_WINDOW_SIZE);
+    addAdvisorySignal(report, {
+      code: "safe_delivery_trend_degraded",
+      severity: "warning",
+      message: `Recent safe-delivery rate is ${formatPercent(recentRate)} across the last ${report.advisory.deliveryTrend.windowSize} competition(s).`,
+      value: recentRate,
+      threshold: DELIVERY_TREND_WARNING_RATE,
+      provider: null,
+      taskIds: recentDeliveryRuns.filter((run) => !run.safeDelivery.safe).map((run) => run.taskId)
+    });
+  }
+  if (report.synthesis.attempted >= FALLBACK_RATE_MIN_ATTEMPTS && report.advisory.fallbackRate !== null && report.advisory.fallbackRate >= FALLBACK_RATE_WARNING) {
+    addAdvisorySignal(report, {
+      code: "fallback_rate_elevated",
+      severity: "info",
+      message: `${fallbackRuns.length}/${report.synthesis.attempted} recent synthesis attempts fell back to the winner.`,
+      value: report.advisory.fallbackRate,
+      threshold: FALLBACK_RATE_WARNING,
+      provider: null,
+      taskIds: fallbackRuns.map((run) => run.taskId)
+    });
+  }
+}
+function hasCompleteGateFailureDetails(synthesis) {
+  if (synthesis.gatesPassed !== false) return true;
+  if (!synthesis.gateFailureDetails || typeof synthesis.gateFailureDetails !== "object" || Array.isArray(synthesis.gateFailureDetails)) {
+    return false;
+  }
+  const details = synthesis.gateFailureDetails;
+  return typeof details.gate === "string" && details.gate.length > 0 && typeof details.status === "string" && details.status.length > 0;
+}
+function addGuardrailFinding(report, finding) {
+  if (finding.severity === "hard") {
+    report.guardrails.hardFailures.push(finding);
+    return;
+  }
+  report.guardrails.warnings.push(finding);
+}
+function addCorruptSourceWarning(report, taskId, code, sourceLabel, parseError, filePath) {
+  if (!parseError) return;
+  if (filePath) {
+    console.error(`Warning: ${filePath}: ${parseError}`);
+  }
+  report.inputQuality.corruptedFiles += 1;
+  addGuardrailFinding(report, {
+    code,
+    severity: "warning",
+    taskId,
+    message: `${sourceLabel} could not be read: ${parseError}`
+  });
+  incrementFailureType(report, code);
+}
+function evaluateCompetitionGuardrails(report, taskId, state, synthesis) {
+  addCorruptSourceWarning(
+    report,
+    taskId,
+    "competition_state_corrupt",
+    "Competition state",
+    state.sources.competitionHandle.parseError,
+    state.sources.competitionHandle.path || void 0
+  );
+  addCorruptSourceWarning(
+    report,
+    taskId,
+    "background_state_corrupt",
+    "Background state",
+    state.sources.backgroundHandle.parseError,
+    state.sources.backgroundHandle.path || void 0
+  );
+  addCorruptSourceWarning(
+    report,
+    taskId,
+    "unified_state_corrupt",
+    "Unified state",
+    state.sources.unifiedState.parseError,
+    state.sources.unifiedState.path || void 0
+  );
+  if (state.status === "completed" && state.outcome === "winner_selected" && !state.winner) {
+    addGuardrailFinding(report, {
+      code: "winner_selected_without_winner",
+      severity: "hard",
+      taskId,
+      message: "Competition reports winner_selected but has no winner payload."
+    });
+  }
+  const winnerVerificationFailure = getWinnerVerificationFailure(state);
+  if (winnerVerificationFailure) {
+    addGuardrailFinding(report, {
+      code: "winner_failed_verification",
+      severity: "warning",
+      taskId,
+      message: `Judged winner ${winnerVerificationFailure.provider}:${winnerVerificationFailure.model ?? "unknown"} failed deterministic verification; delivery remains based on the judge-selected winner.`
+    });
+  }
+  if (synthesis?.synthesisApplied === true && (synthesis.deliverySucceeded !== true || synthesis.gatesPassed !== true || synthesis.patchApplyValidated !== true || synthesis.winnerFallback === true || synthesis.mergedVariants.length === 0)) {
+    addGuardrailFinding(report, {
+      code: "applied_synthesis_incoherent",
+      severity: "hard",
+      taskId,
+      message: "Applied synthesis must have deliverySucceeded=true, gatesPassed=true, patchApplyValidated=true, no winner fallback, and at least one merged variant."
+    });
+  }
+  if (synthesis?.winnerFallback === true && (synthesis.synthesisApplied === true || synthesis.deliverySucceeded !== true)) {
+    addGuardrailFinding(report, {
+      code: "winner_fallback_incoherent",
+      severity: "hard",
+      taskId,
+      message: "Winner fallback must preserve delivery and must not also report synthesisApplied=true."
+    });
+  }
+  if (synthesis && !hasCompleteGateFailureDetails(synthesis)) {
+    addGuardrailFinding(report, {
+      code: "gate_failure_details_missing",
+      severity: state.winner && synthesis.winnerFallback === true && synthesis.deliverySucceeded === true ? "warning" : "hard",
+      taskId,
+      message: "gatesPassed=false requires gateFailureDetails.gate and gateFailureDetails.status."
+    });
+  }
+  const rejectedOrFailedSynthesis = synthesis?.success === false || synthesis?.gatesPassed === false;
+  if (rejectedOrFailedSynthesis && synthesis?.deliverySucceeded !== true && synthesis?.winnerFallback !== true && !state.winner) {
+    addGuardrailFinding(report, {
+      code: "synthesis_failure_without_winner_preservation",
+      severity: "hard",
+      taskId,
+      message: "Synthesis failed or was rejected without explicit fallback or a preserved judged winner."
+    });
+  }
+  if ((synthesis?.gatesPassed === false || synthesis?.winnerFallback === true) && state.winner) {
+    addGuardrailFinding(report, {
+      code: "synthesis_rejected_winner_preserved",
+      severity: "warning",
+      taskId,
+      message: "Synthesis did not apply, but the judged winner remains available."
+    });
+  }
+}
+function buildTelemetryReliabilityReport(options) {
+  const cwd = options.cwd ?? resolveCliRepoRoot(process.cwd());
+  const limit = options.limit ?? 20;
+  const profile = resolveProfile(options.profile);
+  const sinceMs = parseSinceCutoff(options.since);
+  const paths = resolveReliabilityPaths(
+    cwd,
+    options.labPathResolver ?? LabPathResolver.getInstance()
+  );
+  const { stateDir, synthesisDir } = paths;
+  const synthesisDirs = options.synthesisDirs?.length ? options.synthesisDirs : [synthesisDir];
+  let competitionIds = listRecentCompetitionIds(stateDir, limit, {
+    includeTestFixtures: options.includeTestFixtures,
+    sinceMs
+  });
+  const useLabVariantFallback = competitionIds.length === 0 && fs.existsSync(paths.variantDir);
+  if (useLabVariantFallback) {
+    competitionIds = listRecentLabVariantCompetitionIds(paths.variantDir, limit, {
+      includeTestFixtures: options.includeTestFixtures,
+      sinceMs
+    });
+  }
+  const observedBounds = useLabVariantFallback ? observedLabVariantBounds(paths.variantDir, competitionIds) : observedCompetitionBounds(stateDir, competitionIds);
+  const report = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profile,
+    scanned: {
+      stateDir,
+      synthesisDir,
+      competitions: competitionIds.length,
+      limit,
+      since: options.since ?? null,
+      oldestObservedAt: observedBounds.oldestObservedAt,
+      newestObservedAt: observedBounds.newestObservedAt
+    },
+    delivery: {
+      completed: 0,
+      winnerSelected: 0,
+      failed: 0,
+      deliveryRate: null,
+      verifiedDeliveryRate: null
+    },
+    synthesis: {
+      attempted: 0,
+      applied: 0,
+      winnerFallback: 0,
+      deliverySucceeded: 0,
+      gatesFailed: 0,
+      gateFailures: {}
+    },
+    verification: {
+      passed: 0,
+      failed: 0,
+      baselineClean: 0,
+      notRun: 0
+    },
+    providers: {},
+    failures: {
+      byType: {}
+    },
+    inputQuality: {
+      incompleteRuns: 0,
+      incompleteVariants: 0,
+      corruptedFiles: 0
+    },
+    guardrails: {
+      hardFailures: [],
+      warnings: []
+    },
+    runs: [],
+    advisory: {
+      unsafeRuns: 0,
+      fallbackRuns: 0,
+      fallbackRate: null,
+      deliveryTrend: {
+        windowSize: DELIVERY_TREND_WINDOW_SIZE,
+        sampleSize: 0,
+        recentRate: null,
+        previousRate: null,
+        delta: null,
+        threshold: DELIVERY_TREND_WARNING_RATE,
+        status: "insufficient_data"
+      },
+      providerFailureRates: {},
+      signals: []
+    }
+  };
+  for (const id of competitionIds) {
+    const state = useLabVariantFallback ? readLabVariantCompetitionState(id, paths.variantDir) : readCompetitionState(id, {
+      cwd,
+      stateDir: paths.stateDir,
+      backgroundDir: paths.backgroundDir,
+      backgroundDirs: options.backgroundDirs,
+      unifiedStateDir: paths.unifiedStateDir
+    });
+    if (!state) continue;
+    const runKind = classifyRunKind(state);
+    if (runKind === "delivery") {
+      if (state.status === "completed") report.delivery.completed += 1;
+      if (state.outcome === "winner_selected" || state.winner) report.delivery.winnerSelected += 1;
+      if (state.status === "failed" || state.outcome === "failed") report.delivery.failed += 1;
+    }
+    const providerFailures = [];
+    const verificationFailures = [];
+    let incompleteSpecInputs = 0;
+    let verifiedVariants = 0;
+    for (const variant of state.variants) {
+      if (hasIncompleteInputSpec(variant)) incompleteSpecInputs += 1;
+      const verificationStatus = getVerificationStatus(variant);
+      incrementVerificationSummary(report.verification, verificationStatus);
+      if (isVerifiedStatus(verificationStatus)) verifiedVariants += 1;
+      const verificationFailure = getVerificationFailure(variant);
+      if (verificationFailure) {
+        verificationFailures.push(verificationFailure);
+        incrementFailureType(report, "verification_failed");
+      }
+      const failureType = classifyVariantFailure(variant);
+      incrementProvider(report.providers, variant.provider, failureType);
+      if (failureType) {
+        incrementFailureType(report, failureType);
+        providerFailures.push({
+          provider: variant.provider,
+          model: variant.resolvedModel ?? variant.model ?? null,
+          executionMode: variant.executionMode ?? null,
+          type: failureType,
+          errorMessage: variant.errorMessage ?? null,
+          terminationReason: variant.terminationReason ?? null,
+          timedOut: variant.timedOut ?? null
+        });
+      }
+    }
+    if (incompleteSpecInputs > 0) {
+      report.inputQuality.incompleteRuns += 1;
+      report.inputQuality.incompleteVariants += incompleteSpecInputs;
+    }
+    const artifactRecord = readSynthesisArtifactRecord(synthesisDirs, id);
+    addCorruptSourceWarning(
+      report,
+      id,
+      "synthesis_artifact_corrupt",
+      "Synthesis artifact",
+      artifactRecord.parseError,
+      artifactRecord.filePath
+    );
+    const artifact = synthesisFromRecord(artifactRecord.value);
+    const synthesis = artifact ?? state.synthesis;
+    evaluateCompetitionGuardrails(report, id, state, synthesis);
+    report.runs.push(
+      summarizeRun(
+        id,
+        state,
+        synthesis,
+        providerFailures,
+        verificationFailures,
+        incompleteSpecInputs,
+        verifiedVariants,
+        useLabVariantFallback ? observedLabVariantBounds(paths.variantDir, [id]).newestObservedAt : observedCompetitionAt(paths.stateDir, id)
+      )
+    );
+    if (!synthesis) continue;
+    report.synthesis.attempted += 1;
+    if (synthesis.synthesisApplied === true) report.synthesis.applied += 1;
+    if (synthesis.winnerFallback === true) report.synthesis.winnerFallback += 1;
+    if (synthesis.deliverySucceeded === true) report.synthesis.deliverySucceeded += 1;
+    if (isSynthesisGateFailure(synthesis)) {
+      report.synthesis.gatesFailed += 1;
+    }
+    const synthesisFailureType = classifySynthesisFailure(synthesis);
+    if (synthesisFailureType) incrementFailureType(report, synthesisFailureType);
+    const gateFailure = extractGateFailure(synthesis.gateFailureDetails);
+    if (gateFailure) {
+      incrementGateFailure(report.synthesis.gateFailures, gateFailure.gate, gateFailure.status);
+    }
+  }
+  const hasDeliveryRuns = report.runs.some((run) => run.runKind === "delivery");
+  report.delivery.deliveryRate = hasDeliveryRuns ? calculateSafeDeliveryRate(report.runs) : null;
+  report.delivery.verifiedDeliveryRate = hasDeliveryRuns ? calculateVerifiedDeliveryRate(report.runs) : null;
+  populateReliabilityAdvisory(report);
+  return report;
+}
+function resolveCampaignRuns(params) {
+  const selection = params.selection ?? "latest:5";
+  const buildDir = path2.join(params.cwd, ".build-project");
+  const labRuns = listLabRuns(buildDir).filter((run) => run.labId === params.labId).sort((a, b) => b.runId.localeCompare(a.runId));
+  const warnings = [];
+  if (labRuns.length === 0) {
+    warnings.push(`No lab runs found for lab id "${params.labId}".`);
+    return { runs: [], selection, warnings };
+  }
+  if (selection === "all") {
+    return { runs: labRuns, selection, warnings };
+  }
+  const latestMatch = /^latest:(\d+)$/.exec(selection);
+  if (latestMatch) {
+    const count = Number.parseInt(latestMatch[1] ?? "0", 10);
+    if (!Number.isFinite(count) || count <= 0) {
+      throw new Error(
+        `Invalid --campaign-runs value "${selection}". Expected latest:<positive n>.`
+      );
+    }
+    return { runs: labRuns.slice(0, count), selection, warnings };
+  }
+  const requestedIds = selection.split(",").map((runId) => runId.trim()).filter(Boolean);
+  if (requestedIds.length === 0) {
+    throw new Error(
+      `Invalid --campaign-runs value "${selection}". Use all, latest:<n>, or comma-separated run ids.`
+    );
+  }
+  const byRunId = new Map(labRuns.map((run) => [run.runId, run]));
+  const selectedRuns = [];
+  for (const runId of requestedIds) {
+    const run = byRunId.get(runId);
+    if (run) {
+      selectedRuns.push(run);
+    } else {
+      warnings.push(`Run "${runId}" was not found under lab "${params.labId}".`);
+    }
+  }
+  return { runs: selectedRuns, selection, warnings };
+}
+function failReliabilityLabOptions(message) {
+  throw new Error(`${message}. Run \`build lab list\` to browse available lab runs.`);
+}
+function resolveReliabilityLabRun(params) {
+  if (params.lab && (params.labId || params.runId)) {
+    failReliabilityLabOptions("--lab cannot be combined with --lab-id/--run-id");
+  }
+  if (params.labId && !params.runId) {
+    failReliabilityLabOptions("--lab-id requires --run-id");
+  }
+  if (params.runId && !params.labId) {
+    failReliabilityLabOptions("--run-id requires --lab-id");
+  }
+  const buildDir = path2.join(params.cwd, ".build-project");
+  if (params.lab) {
+    const selector = typeof params.lab === "string" ? params.lab.trim().toLowerCase() : params.lab === true ? "latest" : null;
+    if (!selector || selector === "latest") {
+      const latest = findLatestLabRun(buildDir);
+      if (!latest) {
+        failReliabilityLabOptions(
+          "No lab runs found. Start a lab run with `build run competition --lab` before querying telemetry"
+        );
+      }
+      return latest;
+    }
+    failReliabilityLabOptions("Unsupported --lab value. Supported value: latest");
+  }
+  if (params.labId && params.runId) {
+    const run = findLabRun(params.labId, params.runId, buildDir);
+    if (!run) {
+      failReliabilityLabOptions(`Lab run not found: ${params.labId}/${params.runId}`);
+    }
+    return run;
+  }
+  return null;
+}
+function labRunPathResolver(run) {
+  return {
+    getStateDir: () => path2.join(run.runPath, "state"),
+    getTelemetryDir: () => path2.join(run.runPath, "telemetry")
+  };
+}
+function labRunSynthesisDirs(cwd, run) {
+  return [
+    path2.join(run.runPath, "telemetry", "synthesis"),
+    path2.join(cwd, ".build-project", "telemetry", "synthesis")
+  ];
+}
+function labRunBackgroundDirs(cwd, run) {
+  return [
+    path2.join(run.runPath, "state", "background"),
+    path2.join(resolveRunStateDir(path2.join(cwd, ".build-project")), "background")
+  ];
+}
+function addLabNoDataAdvisory(report, run) {
+  if (report.scanned.competitions > 0) return;
+  addAdvisorySignal(report, {
+    code: "lab_reliability_no_competitions",
+    severity: "info",
+    message: `Lab run ${run.labId}/${run.runId} has no persisted competition records for reliability analysis.`,
+    value: 0,
+    threshold: null,
+    provider: null,
+    taskIds: []
+  });
+}
+function createEmptyCampaignAggregate(params) {
+  return {
+    generatedAt: params.generatedAt,
+    profile: params.profile,
+    scanned: {
+      stateDir: params.stateDir,
+      synthesisDir: params.synthesisDir,
+      competitions: 0,
+      limit: params.limit,
+      since: params.since ?? null,
+      oldestObservedAt: null,
+      newestObservedAt: null
+    },
+    delivery: {
+      completed: 0,
+      winnerSelected: 0,
+      failed: 0,
+      deliveryRate: null,
+      verifiedDeliveryRate: null
+    },
+    synthesis: {
+      attempted: 0,
+      applied: 0,
+      winnerFallback: 0,
+      deliverySucceeded: 0,
+      gatesFailed: 0,
+      gateFailures: {}
+    },
+    verification: {
+      passed: 0,
+      failed: 0,
+      baselineClean: 0,
+      notRun: 0
+    },
+    providers: {},
+    failures: { byType: {} },
+    inputQuality: {
+      incompleteRuns: 0,
+      incompleteVariants: 0,
+      corruptedFiles: 0
+    },
+    guardrails: {
+      hardFailures: [],
+      warnings: []
+    },
+    runs: [],
+    advisory: {
+      unsafeRuns: 0,
+      fallbackRuns: 0,
+      fallbackRate: null,
+      deliveryTrend: {
+        windowSize: DELIVERY_TREND_WINDOW_SIZE,
+        sampleSize: 0,
+        recentRate: null,
+        previousRate: null,
+        delta: null,
+        threshold: DELIVERY_TREND_WARNING_RATE,
+        status: "insufficient_data"
+      },
+      providerFailureRates: {},
+      signals: []
+    }
+  };
+}
+function mergeProviderSummaries(target, source) {
+  for (const [provider, summary] of Object.entries(source)) {
+    const targetSummary = target[provider] ?? { total: 0, failures: 0, failureTypes: {} };
+    target[provider] = targetSummary;
+    targetSummary.total += summary.total;
+    targetSummary.failures += summary.failures;
+    for (const [type, count] of Object.entries(summary.failureTypes)) {
+      targetSummary.failureTypes[type] = (targetSummary.failureTypes[type] ?? 0) + count;
+    }
+  }
+}
+function mergeGateFailureSummaries(target, source) {
+  for (const [gate, summary] of Object.entries(source)) {
+    const targetSummary = target[gate] ?? { count: 0, statuses: {} };
+    target[gate] = targetSummary;
+    targetSummary.count += summary.count;
+    for (const [status, count] of Object.entries(summary.statuses)) {
+      targetSummary.statuses[status] = (targetSummary.statuses[status] ?? 0) + count;
+    }
+  }
+}
+function mergeFailureTypes(target, source) {
+  for (const [type, count] of Object.entries(source)) {
+    target[type] = (target[type] ?? 0) + count;
+  }
+}
+function mergeObservedBounds(aggregate, report) {
+  const oldest = report.scanned.oldestObservedAt;
+  const newest = report.scanned.newestObservedAt;
+  if (oldest && (!aggregate.scanned.oldestObservedAt || oldest < aggregate.scanned.oldestObservedAt)) {
+    aggregate.scanned.oldestObservedAt = oldest;
+  }
+  if (newest && (!aggregate.scanned.newestObservedAt || newest > aggregate.scanned.newestObservedAt)) {
+    aggregate.scanned.newestObservedAt = newest;
+  }
+}
+function mergeReliabilityReport(aggregate, report) {
+  aggregate.scanned.competitions += report.scanned.competitions;
+  mergeObservedBounds(aggregate, report);
+  aggregate.delivery.completed += report.delivery.completed;
+  aggregate.delivery.winnerSelected += report.delivery.winnerSelected;
+  aggregate.delivery.failed += report.delivery.failed;
+  aggregate.synthesis.attempted += report.synthesis.attempted;
+  aggregate.synthesis.applied += report.synthesis.applied;
+  aggregate.synthesis.winnerFallback += report.synthesis.winnerFallback;
+  aggregate.synthesis.deliverySucceeded += report.synthesis.deliverySucceeded;
+  aggregate.synthesis.gatesFailed += report.synthesis.gatesFailed;
+  mergeGateFailureSummaries(aggregate.synthesis.gateFailures, report.synthesis.gateFailures);
+  aggregate.verification.passed += report.verification.passed;
+  aggregate.verification.failed += report.verification.failed;
+  aggregate.verification.baselineClean += report.verification.baselineClean;
+  aggregate.verification.notRun += report.verification.notRun;
+  mergeProviderSummaries(aggregate.providers, report.providers);
+  mergeFailureTypes(aggregate.failures.byType, report.failures.byType);
+  aggregate.inputQuality.incompleteRuns += report.inputQuality.incompleteRuns;
+  aggregate.inputQuality.incompleteVariants += report.inputQuality.incompleteVariants;
+  aggregate.inputQuality.corruptedFiles += report.inputQuality.corruptedFiles;
+  aggregate.guardrails.hardFailures.push(...report.guardrails.hardFailures);
+  aggregate.guardrails.warnings.push(...report.guardrails.warnings);
+  aggregate.runs.push(...report.runs);
+}
+function buildCampaignReliabilityReport(options) {
+  const cwd = options.cwd ?? resolveCliRepoRoot(process.cwd());
+  const limit = options.limit ?? 20;
+  const profile = resolveProfile(options.profile);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const selection = resolveCampaignRuns({
+    cwd,
+    labId: options.campaignLabId,
+    selection: options.campaignRuns
+  });
+  const aggregate = createEmptyCampaignAggregate({
+    generatedAt,
+    profile,
+    limit,
+    since: options.since,
+    stateDir: `campaign:${options.campaignLabId}`,
+    synthesisDir: `campaign:${options.campaignLabId}`
+  });
+  const reports = selection.runs.map((run) => {
+    const report = buildTelemetryReliabilityReport({
+      backgroundDirs: labRunBackgroundDirs(cwd, run),
+      cwd,
+      includeTestFixtures: options.includeTestFixtures,
+      limit,
+      labPathResolver: labRunPathResolver(run),
+      profile,
+      since: options.since,
+      synthesisDirs: labRunSynthesisDirs(cwd, run)
+    });
+    if (report.scanned.competitions === 0) {
+      selection.warnings.push(`Run "${run.runId}" has no competition records.`);
+    }
+    mergeReliabilityReport(aggregate, report);
+    return {
+      labId: run.labId,
+      runId: run.runId,
+      taskSummary: run.taskSummary,
+      report
+    };
+  });
+  aggregate.scanned.limit = limit * selection.runs.length;
+  aggregate.runs.sort((a, b) => {
+    if (a.observedAt && b.observedAt) return b.observedAt.localeCompare(a.observedAt);
+    if (a.observedAt) return -1;
+    if (b.observedAt) return 1;
+    return a.taskId.localeCompare(b.taskId);
+  });
+  aggregate.delivery.deliveryRate = aggregate.scanned.competitions > 0 ? calculateSafeDeliveryRate(aggregate.runs) : null;
+  aggregate.delivery.verifiedDeliveryRate = aggregate.scanned.competitions > 0 ? calculateVerifiedDeliveryRate(aggregate.runs) : null;
+  populateReliabilityAdvisory(aggregate);
+  if (aggregate.runs.length < DELIVERY_TREND_WINDOW_SIZE) {
+    selection.warnings.push(
+      `Campaign has ${aggregate.runs.length} competition sample(s); delivery trend requires ${DELIVERY_TREND_WINDOW_SIZE}.`
+    );
+  }
+  return {
+    generatedAt,
+    profile,
+    campaign: {
+      labId: options.campaignLabId,
+      runs: reports.length,
+      runIds: reports.map((entry) => entry.runId),
+      selection: selection.selection,
+      warnings: selection.warnings
+    },
+    aggregate,
+    reports
+  };
+}
+function formatPercent(value) {
+  return value === null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+}
+function formatPercentagePointDelta(value) {
+  if (value === null) return "n/a";
+  const sign = value > 0 ? "+" : "";
+  return `${sign}${(value * 100).toFixed(1)}pp`;
+}
+function isExpectedFallbackFinding(finding) {
+  return finding.code === "synthesis_rejected_winner_preserved";
+}
+function formatRunWinner(winner) {
+  if (!winner) return "none";
+  if (winner.variant) return winner.variant;
+  return [winner.provider, winner.model].filter(Boolean).join(":") || "unknown";
+}
+function classifyDonorMaterial(synthesis) {
+  const matched = synthesis.intentFilteredHunkCount;
+  const excluded = synthesis.excludedHunkCount;
+  const unknownIncluded = synthesis.unknownIncludedHunkCount;
+  const overlapRejected = synthesis.overlapRejectedHunkCount;
+  const hasAnyCount = typeof matched === "number" || typeof excluded === "number" || typeof unknownIncluded === "number" || typeof overlapRejected === "number";
+  if (!hasAnyCount) {
+    const thresholdMissCount = countSemanticThresholdMissDonors(synthesis.donorSelectionDecisions);
+    if (thresholdMissCount > 0) {
+      return `semantic-threshold-miss (${thresholdMissCount} donor${thresholdMissCount === 1 ? "" : "s"} below threshold)`;
+    }
+    return null;
+  }
+  const matchedCount = matched ?? 0;
+  const excludedCount = excluded ?? 0;
+  const unknownIncludedCount = unknownIncluded ?? 0;
+  const overlapRejectedCount = overlapRejected ?? 0;
+  const details = [`matched=${matchedCount}`, `excluded=${excludedCount}`];
+  if (unknownIncludedCount > 0) details.push(`unknownIncluded=${unknownIncludedCount}`);
+  if (overlapRejectedCount > 0) details.push(`overlapRejected=${overlapRejectedCount}`);
+  if (matchedCount === 0 && excludedCount === 0) {
+    return `no-donor-material (${details.join(", ")})`;
+  }
+  if (matchedCount === 0 && excludedCount > 0) {
+    return `donor-rejected-by-intent-filter (${details.join(", ")})`;
+  }
+  const applied = synthesis.complementaryPatchApplied ?? synthesis.applied;
+  if (applied === true) {
+    const modeSuffix = synthesis.applyMode ? `; applyMode=${synthesis.applyMode}` : "";
+    return `donor-applied (${details.join(", ")}${modeSuffix})`;
+  }
+  if (applied === false) {
+    const modeSuffix = synthesis.applyMode ? `; applyMode=${synthesis.applyMode}` : "";
+    return `donor-attempted-not-applied (${details.join(", ")}${modeSuffix})`;
+  }
+  return `donor-attempted (${details.join(", ")})`;
+}
+function countSemanticThresholdMissDonors(decisions) {
+  if (!Array.isArray(decisions)) return 0;
+  return decisions.filter((entry) => {
+    if (typeof entry !== "object" || entry === null) return false;
+    const decision = entry;
+    if (decision.winner === true || decision.selected === true) return false;
+    const reasons = Array.isArray(decision.reasons) ? decision.reasons.filter((reason) => typeof reason === "string") : [];
+    return reasons.some((reason) => {
+      const normalized = reason.toLowerCase();
+      return normalized.includes("semantic donor rejected") && normalized.includes("threshold");
+    });
+  }).length;
+}
+function formatAiGuidedFallbackClass(synthesis) {
+  if (synthesis.aiGuidedFallbackAttempted !== true) return null;
+  switch (synthesis.aiGuidedFallbackOutcome) {
+    case "donor_augmented":
+      return "agentic-fallback-applied";
+    case "winner_equivalent":
+      return "agentic-fallback-winner-equivalent";
+    case "candidate_rejected":
+      return "agentic-fallback-rejected-by-apply-or-gates";
+    case "generation_failed":
+      return "agentic-fallback-generation-failed";
+    default:
+      return "agentic-fallback-attempted";
+  }
+}
+function formatGateFailure(gateFailure) {
+  if (!gateFailure) return null;
+  return `${gateFailure.gate} ${gateFailure.status}`;
+}
+function formatRunSynthesis(synthesis) {
+  if (!synthesis.attempted) return "not attempted";
+  const aiGuidedClass = formatAiGuidedFallbackClass(synthesis);
+  if (synthesis.applied === true) {
+    const donorClass = classifyDonorMaterial(synthesis);
+    const details = [aiGuidedClass, donorClass].filter(
+      (value) => typeof value === "string" && value.length > 0
+    );
+    if (details.length > 0) return `applied (${details.join("; ")})`;
+    return "applied";
+  }
+  if (synthesis.winnerFallback === true) {
+    const reason = synthesis.fallbackReason ?? "winner preserved";
+    const gateFailure = formatGateFailure(synthesis.gateFailure);
+    const donorClass = classifyDonorMaterial(synthesis);
+    const details = [reason, gateFailure, aiGuidedClass, donorClass].filter(
+      (value) => typeof value === "string" && value.length > 0
+    );
+    if (details.length > 0) return `winner fallback (${details.join("; ")})`;
+    return `winner fallback (${reason})`;
+  }
+  if (synthesis.gatesPassed === false) {
+    const gateFailure = formatGateFailure(synthesis.gateFailure) ?? "gate failed";
+    const donorClass = classifyDonorMaterial(synthesis);
+    const details = [gateFailure, aiGuidedClass, donorClass].filter(
+      (value) => typeof value === "string" && value.length > 0
+    );
+    if (details.length > 0) return `rejected (${details.join("; ")})`;
+    return `rejected (${gateFailure})`;
+  }
+  if (synthesis.error) return `failed (${synthesis.error})`;
+  return "attempted";
+}
+function isNotableRun(run) {
+  return !run.safeDelivery.safe || run.providerFailures.length > 0 || run.verificationFailures.length > 0 || run.incompleteSpecInputs > 0 || run.synthesis.winnerFallback === true || run.synthesis.gatesPassed === false || run.synthesis.error !== null;
+}
+function formatRunProviderFailures(providerFailures) {
+  if (providerFailures.length === 0) return "none";
+  return providerFailures.map((failure) => `${failure.provider}:${failure.type}`).join(", ");
+}
+function formatRunVerificationFailures(verificationFailures) {
+  if (verificationFailures.length === 0) return "none";
+  return verificationFailures.map((failure) => {
+    const variant = [failure.provider, failure.model, failure.executionMode].filter((value) => typeof value === "string" && value.length > 0).join(":");
+    const details = [
+      failure.buildStatus ? `build=${failure.buildStatus}` : null,
+      failure.testStatus ? `test=${failure.testStatus}` : null,
+      `status=${failure.status}`
+    ].filter((value) => value !== null);
+    return `${variant || "unknown"} (${details.join(", ")})`;
+  }).join(", ");
+}
+function formatRunDeliveryStatus(run) {
+  if (run.runKind === "analysis") {
+    return run.safeDelivery.safe ? "analysis-complete" : "analysis-incomplete";
+  }
+  if (!run.safeDelivery.safe) return "unsafe";
+  return isVerifiedDelivery(run) ? "verified-safe" : "safe-unverified";
+}
+function renderHumanReport(report) {
+  console.log(chalk.bold.cyan("\nReliability Report\n"));
+  console.log(chalk.gray(`Profile: ${report.profile}`));
+  console.log(chalk.gray(`Scanned: ${report.scanned.competitions} competitions`));
+  console.log(chalk.gray(`Limit: ${report.scanned.limit}`));
+  if (report.scanned.since) {
+    console.log(chalk.gray(`Since: ${report.scanned.since}`));
+  }
+  if (report.scanned.newestObservedAt) {
+    console.log(
+      chalk.gray(
+        `Observed: ${report.scanned.oldestObservedAt ?? "n/a"} to ${report.scanned.newestObservedAt}`
+      )
+    );
+  }
+  console.log(chalk.bold("\nDelivery"));
+  console.log(`  Winner Selected: ${report.delivery.winnerSelected}`);
+  console.log(`  Completed: ${report.delivery.completed}`);
+  console.log(`  Failed: ${report.delivery.failed}`);
+  console.log(`  Delivery Rate: ${formatPercent(report.delivery.deliveryRate)}`);
+  console.log(`  Verified Delivery Rate: ${formatPercent(report.delivery.verifiedDeliveryRate)}`);
+  console.log(chalk.bold("\nSynthesis"));
+  console.log(`  Attempted: ${report.synthesis.attempted}`);
+  console.log(`  Applied: ${report.synthesis.applied}`);
+  console.log(`  Winner Fallback: ${report.synthesis.winnerFallback}`);
+  console.log(`  Delivery Succeeded: ${report.synthesis.deliverySucceeded}`);
+  console.log(`  Gates Failed: ${report.synthesis.gatesFailed}`);
+  console.log(chalk.bold("\nVerification"));
+  console.log(`  Passed: ${report.verification.passed}`);
+  console.log(`  Failed: ${report.verification.failed}`);
+  console.log(`  Baseline Clean: ${report.verification.baselineClean}`);
+  console.log(`  Not Run: ${report.verification.notRun}`);
+  const gateEntries = Object.entries(report.synthesis.gateFailures);
+  if (gateEntries.length > 0) {
+    console.log(chalk.bold("\nGate Failures"));
+    for (const [gate, summary] of gateEntries) {
+      const statuses = Object.entries(summary.statuses).map(([status, count]) => `${status}=${count}`).join(", ");
+      console.log(`  ${gate}: ${summary.count}${statuses ? ` (${statuses})` : ""}`);
+    }
+  }
+  const providerEntries = Object.entries(report.providers).sort((a, b) => a[0].localeCompare(b[0]));
+  if (providerEntries.length > 0) {
+    console.log(chalk.bold("\nProvider Failures"));
+    for (const [provider, summary] of providerEntries) {
+      const failureTypes = Object.entries(summary.failureTypes).map(([type, count]) => `${type}=${count}`).join(", ");
+      console.log(`  ${provider}: ${summary.failures}/${summary.total}`);
+      if (failureTypes) {
+        console.log(chalk.gray(`    ${failureTypes}`));
+      }
+    }
+  }
+  const failureTypeEntries = Object.entries(report.failures.byType).sort(
+    (a, b) => a[0].localeCompare(b[0])
+  );
+  if (failureTypeEntries.length > 0) {
+    console.log(chalk.bold("\nFailure Types"));
+    for (const [type, count] of failureTypeEntries) {
+      console.log(`  ${type}: ${count}`);
+    }
+  }
+  if (report.inputQuality.incompleteVariants > 0 || report.inputQuality.corruptedFiles > 0) {
+    console.log(chalk.bold("\nInput Quality"));
+    console.log(`  Incomplete Runs: ${report.inputQuality.incompleteRuns}`);
+    console.log(`  Incomplete Variants: ${report.inputQuality.incompleteVariants}`);
+    console.log(`  Corrupted Files: ${report.inputQuality.corruptedFiles}`);
+  }
+  const notableRuns = report.runs.filter(isNotableRun);
+  if (notableRuns.length > 0) {
+    console.log(chalk.bold("\nRuns"));
+    for (const run of notableRuns) {
+      const status = formatRunDeliveryStatus(run);
+      console.log(
+        `  ${run.taskId}: ${status} (${run.safeDelivery.basis}) | winner=${formatRunWinner(
+          run.winner
+        )} | synthesis=${formatRunSynthesis(run.synthesis)} | failures=${formatRunProviderFailures(
+          run.providerFailures
+        )} | candidateVerificationFailures=${formatRunVerificationFailures(
+          run.verificationFailures
+        )} | incompleteSpecInputs=${run.incompleteSpecInputs}`
+      );
+    }
+  }
+  if (report.advisory.signals.length > 0) {
+    console.log(chalk.bold("\nAdvisory Signals"));
+    console.log(`  Unsafe Runs: ${report.advisory.unsafeRuns}`);
+    console.log(`  Winner Fallback Rate: ${formatPercent(report.advisory.fallbackRate)}`);
+    console.log(
+      `  Safe Delivery Trend: recent=${formatPercent(
+        report.advisory.deliveryTrend.recentRate
+      )}, previous=${formatPercent(
+        report.advisory.deliveryTrend.previousRate
+      )}, delta=${formatPercentagePointDelta(
+        report.advisory.deliveryTrend.delta
+      )}, threshold=${formatPercent(report.advisory.deliveryTrend.threshold)}`
+    );
+    for (const signal of report.advisory.signals) {
+      const taskIds = signal.taskIds.length > 0 ? ` (${signal.taskIds.join(", ")})` : "";
+      const color = signal.severity === "warning" ? chalk.yellow : chalk.gray;
+      console.log(color(`  ${signal.code}: ${signal.message}${taskIds}`));
+    }
+  }
+  const expectedFallbacks = report.guardrails.warnings.filter(isExpectedFallbackFinding);
+  const warnings = report.guardrails.warnings.filter(
+    (finding) => !isExpectedFallbackFinding(finding)
+  );
+  if (report.guardrails.hardFailures.length > 0 || expectedFallbacks.length > 0 || warnings.length > 0) {
+    console.log(chalk.bold("\nGuardrails"));
+    if (report.guardrails.hardFailures.length > 0) {
+      console.log(chalk.red(`  Hard Failures: ${report.guardrails.hardFailures.length}`));
+      for (const finding of report.guardrails.hardFailures) {
+        console.log(chalk.red(`    ${finding.taskId}: ${finding.code} - ${finding.message}`));
+      }
+    }
+    if (expectedFallbacks.length > 0) {
+      console.log(chalk.green(`  Expected Fallbacks: ${expectedFallbacks.length}`));
+      for (const finding of expectedFallbacks) {
+        console.log(chalk.green(`    ${finding.taskId}: ${finding.code} - ${finding.message}`));
+      }
+    }
+    if (warnings.length > 0) {
+      console.log(chalk.yellow(`  Warnings: ${warnings.length}`));
+      for (const finding of warnings) {
+        console.log(chalk.yellow(`    ${finding.taskId}: ${finding.code} - ${finding.message}`));
+      }
+    }
+  }
+  console.log(chalk.gray(`
+Generated: ${report.generatedAt}`));
+}
+function renderHumanCampaignReport(report) {
+  console.log(chalk.bold.cyan("\nCampaign Reliability Report\n"));
+  console.log(chalk.gray(`Profile: ${report.profile}`));
+  console.log(chalk.gray(`Lab: ${report.campaign.labId}`));
+  console.log(chalk.gray(`Selection: ${report.campaign.selection}`));
+  console.log(chalk.gray(`Runs: ${report.campaign.runs}`));
+  if (report.campaign.runIds.length > 0) {
+    console.log(chalk.gray(`Run IDs: ${report.campaign.runIds.join(", ")}`));
+  }
+  if (report.campaign.warnings.length > 0) {
+    console.log(chalk.yellow("\nCampaign Warnings"));
+    for (const warning of report.campaign.warnings) {
+      console.log(chalk.yellow(`  ${warning}`));
+    }
+  }
+  renderHumanReport(report.aggregate);
+}
+function createTelemetryReliabilityCommand(deps = {}) {
+  const command = new Command("reliability");
+  command.description("Summarize recent competition reliability from local persisted state").addHelpText(
+    "after",
+    [
+      "",
+      "Lab examples:",
+      "  $ build telemetry reliability --lab latest --since 2h --limit 50",
+      "  $ build telemetry --lab latest reliability --since 2h --limit 50",
+      "  $ build telemetry --lab-id <lab-id> --run-id <run-id> reliability --json",
+      "  $ build telemetry reliability --lab-id <lab-id> --run-id <run-id> --json",
+      "  $ build telemetry reliability --campaign-lab-id <lab-id> --campaign-runs latest:5",
+      ""
+    ].join("\n")
+  ).option("--campaign-lab-id <id>", "Aggregate reliability across runs in a lab id").option(
+    "--campaign-runs <selection>",
+    "Campaign run selection: latest:<n>, all, or comma-separated run ids",
+    "latest:5"
+  ).option("--include-test-fixtures", "Include persisted test fixture competitions").option("--json", "Output as JSON").option("--lab [selector]", "Use lab telemetry data (value: latest)").option("--lab-id <labId>", "(OPTIONAL) Specify lab ID (requires --run-id)").option("--limit <n>", "Maximum number of recent competitions to scan", "20").option("--profile <profile>", "Guardrail profile: advisory|strict", "advisory").option("--run-id <runId>", "(OPTIONAL) Specify run ID (requires --lab-id)").option(
+    "--since <duration|iso>",
+    "Only scan competitions observed since a duration (2h) or ISO timestamp"
+  ).action((options) => {
+    const parsed = TelemetryReliabilityOptionsSchema.parse(options);
+    const limit = parseLimit(parsed.limit);
+    const profile = resolveProfile(parsed.profile);
+    const cwd = deps.cwd ?? resolveCliRepoRoot(process.cwd());
+    if (parsed.campaignRuns && !parsed.campaignLabId && parsed.campaignRuns !== "latest:5") {
+      throw new Error("--campaign-runs requires --campaign-lab-id.");
+    }
+    if (parsed.campaignLabId && (parsed.lab || parsed.labId || parsed.runId)) {
+      throw new Error("--campaign-lab-id cannot be combined with --lab/--lab-id/--run-id.");
+    }
+    if (parsed.campaignLabId) {
+      const campaignReport = buildCampaignReliabilityReport({
+        cwd,
+        campaignLabId: parsed.campaignLabId,
+        campaignRuns: parsed.campaignRuns,
+        includeTestFixtures: parsed.includeTestFixtures,
+        limit,
+        profile,
+        since: parsed.since
+      });
+      if (parsed.json) {
+        console.log(JSON.stringify(campaignReport, null, 2));
+      } else {
+        renderHumanCampaignReport(campaignReport);
+      }
+      if (profile === "strict" && campaignReport.aggregate.guardrails.hardFailures.length > 0) {
+        throw ExitCodeError.reported(
+          1,
+          `${campaignReport.aggregate.guardrails.hardFailures.length} reliability guardrail failure(s)`
+        );
+      }
+      return;
+    }
+    const labRun = resolveReliabilityLabRun({
+      cwd,
+      lab: parsed.lab,
+      labId: parsed.labId,
+      runId: parsed.runId
+    });
+    const report = buildTelemetryReliabilityReport({
+      backgroundDirs: labRun ? labRunBackgroundDirs(cwd, labRun) : void 0,
+      cwd,
+      includeTestFixtures: parsed.includeTestFixtures,
+      limit,
+      labPathResolver: labRun ? labRunPathResolver(labRun) : deps.labPathResolver,
+      profile,
+      since: parsed.since,
+      synthesisDirs: labRun ? labRunSynthesisDirs(cwd, labRun) : void 0
+    });
+    if (labRun) {
+      addLabNoDataAdvisory(report, labRun);
+    }
+    if (parsed.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      renderHumanReport(report);
+    }
+    if (profile === "strict" && report.guardrails.hardFailures.length > 0) {
+      throw ExitCodeError.reported(
+        1,
+        `${report.guardrails.hardFailures.length} reliability guardrail failure(s)`
+      );
+    }
+  });
+  return command;
+}
+
+export {
+  resolveReliabilityPaths,
+  summarizeSelectionCoverage,
+  buildTelemetryReliabilityReport,
+  buildCampaignReliabilityReport,
+  formatRunSynthesis,
+  createTelemetryReliabilityCommand
+};
+//# sourceMappingURL=chunk-TDEMDRN2.js.map