@poetic-ai/poetic 1.42.0

package/dist/chunk-5LAMRH4X.js

@@ -0,0 +1,969 @@
+import {
+  extractBalancedJson,
+  parseJsonCandidate,
+  stripMarkdownCodeFences
+} from "./chunk-VVGEPBPS.js";
+
+// src/core/judge/matrix-result-parser.ts
+import { z } from "zod";
+var RISK_LEVEL_VALUES = ["low", "medium", "high", "critical", "unknown"];
+var SCOPE_HYGIENE_RISK_VALUES = ["low", "medium", "high", "unknown"];
+var FOLLOW_UP_COST_VALUES = [
+  "none",
+  "mechanical",
+  "localized",
+  "moderate",
+  "structural",
+  "unknown"
+];
+var LEGACY_FOLLOW_UP_COST_ALIASES = {
+  architectural: "structural"
+};
+var VERIFICATION_STATE_VALUES = [
+  "all-pass",
+  "partial-fail",
+  "all-fail",
+  "not-run",
+  "mixed",
+  "unknown"
+];
+var SCOPE_HYGIENE_VALUES = [
+  "clean",
+  "minor-issues",
+  "significant-churn",
+  "unknown"
+];
+var REQUIRED_PROFILES = [
+  "acceptance-ready",
+  "best-as-delivered",
+  "best-foundation"
+];
+var MATRIX_INCONCLUSIVE_CONFIDENCE_THRESHOLD = 0.6;
+var MATRIX_HIGH_CONFIDENCE_DEGRADED_THRESHOLD = 0.8;
+var KNOWN_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+  "mode",
+  "evidenceLedger",
+  "baseAssessments",
+  "profileVerdicts",
+  "diagnostics",
+  "disagreements",
+  "synthesisOpportunities",
+  "criterionAssessments",
+  "runnerUpAdvantages",
+  "calibrationStatus"
+]);
+var MATRIX_CRITERION_STATUS_VALUES = ["delivered", "partial", "missing", "unverified"];
+var MATRIX_EVIDENCE_KIND_VALUES = [
+  "outcome",
+  "direct",
+  "proxy",
+  "negative",
+  "missing",
+  "unverifiable"
+];
+var MatrixSchemaError = class extends Error {
+};
+function fail(message) {
+  throw new MatrixSchemaError(message);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractToolParameterBodies(text) {
+  const bodies = [];
+  for (const match of text.matchAll(
+    /<parameter\s+name=["'](?:response|result|output)["']\s*>([\s\S]*?)<\/parameter>/gi
+  )) {
+    const body = match[1]?.trim();
+    if (body) bodies.push(body);
+  }
+  return bodies;
+}
+function fencedBlockContents(text) {
+  const contents = [];
+  for (const match of text.matchAll(/```(?:json)?\s*\n?([\s\S]*?)\n?```/gi)) {
+    if (match[1] !== void 0) contents.push(match[1]);
+  }
+  return contents;
+}
+function tryParseCandidate(candidate) {
+  const direct = parseJsonCandidate(candidate);
+  if (direct !== null) return direct;
+  const inner = extractBalancedJson(candidate);
+  if (inner !== null && inner !== candidate) {
+    const innerParsed = parseJsonCandidate(inner);
+    if (innerParsed !== null) return innerParsed;
+  }
+  if (candidate.includes("\r")) {
+    return tryParseCandidate(candidate.replace(/\r\n?/g, "\n"));
+  }
+  return null;
+}
+function extractJsonFromOutput(raw) {
+  const stripped = stripMarkdownCodeFences(raw).trim();
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const enqueue = (s) => {
+    const trimmed = s?.trim();
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed);
+      candidates.push(trimmed);
+    }
+  };
+  enqueue(raw.trim());
+  for (const body of extractToolParameterBodies(raw)) {
+    enqueue(body);
+    enqueue(stripMarkdownCodeFences(body));
+    for (const content of fencedBlockContents(body)) enqueue(content);
+    enqueue(extractBalancedJson(body));
+  }
+  for (const content of fencedBlockContents(raw)) enqueue(content);
+  enqueue(stripped);
+  enqueue(extractBalancedJson(raw));
+  enqueue(extractBalancedJson(stripped));
+  const parsedCandidates = [];
+  for (const candidate of candidates) {
+    const parsed = tryParseCandidate(candidate);
+    if (parsed !== null) parsedCandidates.push(parsed);
+  }
+  for (const candidate of parsedCandidates) {
+    if (isRecord(candidate) && candidate.mode === "profile-matrix") return candidate;
+  }
+  const firstRecord = parsedCandidates.find(isRecord);
+  if (firstRecord !== void 0) return firstRecord;
+  return parsedCandidates.length > 0 ? parsedCandidates[0] : null;
+}
+var VARIANT_ANNOTATION_SEPARATORS = [" (", " - ", " \u2014 "];
+function resolveVariantRef(raw, expectedSet) {
+  if (typeof raw !== "string") {
+    return { id: null, warning: `variant reference ${JSON.stringify(raw)} is not a string` };
+  }
+  let value = raw.trim();
+  const quoted = /^(["'`])([\s\S]*)\1$/.exec(value);
+  if (quoted?.[2] !== void 0) {
+    value = quoted[2].trim();
+  }
+  if (expectedSet.has(value)) {
+    return { id: value };
+  }
+  const matches = [];
+  for (const expected of expectedSet) {
+    if (!value.startsWith(expected)) continue;
+    const remainder = value.slice(expected.length);
+    if (remainder.length === 0) {
+      matches.push(expected);
+      continue;
+    }
+    if (VARIANT_ANNOTATION_SEPARATORS.some((sep) => remainder.startsWith(sep))) {
+      matches.push(expected);
+    }
+  }
+  if (matches.length === 1) {
+    const resolved = matches[0];
+    return {
+      id: resolved,
+      warning: `variant reference ${JSON.stringify(raw)} normalized to "${resolved}" (inline commentary stripped)`
+    };
+  }
+  if (matches.length > 1) {
+    return {
+      id: null,
+      warning: `variant reference ${JSON.stringify(raw)} is ambiguous (matches ${matches.length} expected IDs as a leading token) \u2014 dropped`
+    };
+  }
+  return {
+    id: null,
+    warning: `variant reference ${JSON.stringify(raw)} did not match any expected variant \u2014 dropped`
+  };
+}
+function resolveWinnerRef(raw, expectedSet, fieldPath, warnings, errorMessage) {
+  const resolution = resolveVariantRef(raw, expectedSet);
+  if (resolution.id === null) fail(errorMessage);
+  if (resolution.warning) warnings.push(`${fieldPath}: ${resolution.warning}`);
+  return resolution.id;
+}
+var looseString = z.preprocess((v) => typeof v === "string" ? v : "", z.string());
+var looseNumber = z.preprocess(
+  (v) => typeof v === "number" && Number.isFinite(v) ? v : 0,
+  z.number()
+);
+var looseBoolean = z.preprocess((v) => typeof v === "boolean" ? v : false, z.boolean());
+var looseStringArray = z.preprocess(
+  (v) => Array.isArray(v) ? v.filter((entry) => typeof entry === "string") : [],
+  z.array(z.string())
+);
+function lenientEnum(values, label, fieldPath, warnings, aliases) {
+  return z.preprocess(
+    (value) => {
+      if (typeof value === "string") {
+        if (values.includes(value)) return value;
+        const alias = aliases?.[value];
+        if (alias !== void 0) return alias;
+      }
+      if (value !== void 0 && value !== null) {
+        warnings.push(
+          `Unexpected ${label} at ${fieldPath}: ${JSON.stringify(value)}, coerced to 'unknown'`
+        );
+      }
+      return "unknown";
+    },
+    z.enum(values)
+  );
+}
+function score100(fieldPath, warnings) {
+  return z.unknown().transform((value) => {
+    const score = typeof value === "number" && Number.isFinite(value) ? value : null;
+    if (score === null || score < 0 || score > 100) {
+      fail(`${fieldPath}=${score} is outside [0,100]`);
+    }
+    if (warnings && score > 0 && score <= 1) {
+      warnings.push(`${fieldPath}=${score} looks like a 0-1 value; expected 0-100`);
+    }
+    return score;
+  });
+}
+function evidenceLedgerSchema(warnings) {
+  const entrySchema = (idx) => z.preprocess(
+    (value) => {
+      if (!isRecord(value)) {
+        warnings.push(`evidenceLedger.variants[${idx}] is not an object \u2014 using empty entry`);
+        return {};
+      }
+      return {
+        variant: value.variant,
+        artifactsChanged: value.artifactsChanged ?? value.filesChanged,
+        artifactList: value.artifactList ?? value.fileList,
+        suspiciousArtifacts: value.suspiciousArtifacts ?? value.suspiciousFiles,
+        scopeHygieneRisk: value.scopeHygieneRisk ?? value.repoHygieneRisk,
+        linesAdded: value.linesAdded,
+        linesRemoved: value.linesRemoved,
+        testStatus: value.testStatus,
+        buildStatus: value.buildStatus,
+        keyFindings: value.keyFindings
+      };
+    },
+    z.object({
+      variant: looseString,
+      artifactsChanged: looseNumber,
+      artifactList: looseStringArray,
+      suspiciousArtifacts: looseStringArray,
+      scopeHygieneRisk: z.enum(SCOPE_HYGIENE_RISK_VALUES).catch("unknown"),
+      linesAdded: looseNumber,
+      linesRemoved: looseNumber,
+      testStatus: looseString,
+      buildStatus: looseString,
+      keyFindings: looseStringArray
+    })
+  ).transform((entry) => ({
+    ...entry,
+    filesChanged: entry.artifactsChanged,
+    fileList: entry.artifactList,
+    suspiciousFiles: entry.suspiciousArtifacts,
+    repoHygieneRisk: entry.scopeHygieneRisk
+  }));
+  const verificationSummarySchema = z.object({
+    allPassed: looseStringArray,
+    partialFailures: looseStringArray,
+    allFailed: looseStringArray,
+    notRun: looseStringArray,
+    decisiveVerificationSignals: looseStringArray
+  });
+  return z.unknown().transform((raw) => {
+    if (!isRecord(raw)) fail("evidenceLedger must be an object");
+    const taskSummary = typeof raw.taskSummary === "string" ? raw.taskSummary : "";
+    if (!taskSummary) fail("evidenceLedger.taskSummary is required and must be a string");
+    if (!Array.isArray(raw.variants)) fail("evidenceLedger.variants must be an array");
+    const variants = raw.variants.map((value, idx) => entrySchema(idx).parse(value));
+    if (!isRecord(raw.verificationSummary)) {
+      fail("evidenceLedger.verificationSummary must be an object");
+    }
+    return {
+      taskSummary,
+      acceptanceCriteria: looseStringArray.parse(raw.acceptanceCriteria),
+      variants,
+      crossVariantFindings: looseStringArray.parse(raw.crossVariantFindings),
+      verificationSummary: verificationSummarySchema.parse(raw.verificationSummary)
+    };
+  });
+}
+function baseAssessmentsSchema(expectedVariants, warnings) {
+  const expectedSet = new Set(expectedVariants);
+  const itemSchema = (i) => {
+    const p = `baseAssessments[${i}]`;
+    return z.preprocess(
+      (value) => {
+        const v = isRecord(value) ? value : {};
+        return {
+          correctness: v.correctness,
+          completeness: v.completeness,
+          codeQuality: v.codeQuality,
+          architecture: v.architecture,
+          verificationConfidence: v.verificationConfidence,
+          scopeHygiene: v.scopeHygiene ?? v.repoHygiene,
+          acceptanceRisk: v.shippingRisk ?? v.acceptanceRisk,
+          followUpCost: v.fixupCost ?? v.followUpCost,
+          rationale: v.rationale
+        };
+      },
+      z.object({
+        correctness: score100(`${p}.correctness`),
+        completeness: score100(`${p}.completeness`),
+        codeQuality: score100(`${p}.codeQuality`),
+        architecture: score100(`${p}.architecture`),
+        verificationConfidence: score100(`${p}.verificationConfidence`, warnings),
+        scopeHygiene: lenientEnum(
+          SCOPE_HYGIENE_VALUES,
+          "ScopeHygiene",
+          `${p}.scopeHygiene`,
+          warnings
+        ),
+        acceptanceRisk: lenientEnum(
+          RISK_LEVEL_VALUES,
+          "RiskLevel",
+          `${p}.acceptanceRisk`,
+          warnings
+        ),
+        followUpCost: lenientEnum(
+          FOLLOW_UP_COST_VALUES,
+          "FollowUpCost",
+          `${p}.followUpCost`,
+          warnings,
+          LEGACY_FOLLOW_UP_COST_ALIASES
+        ),
+        rationale: looseString
+      })
+    );
+  };
+  return z.unknown().transform((raw) => {
+    if (!Array.isArray(raw)) fail("baseAssessments must be an array");
+    if (raw.length === 0) {
+      fail(
+        expectedVariants.length === 0 ? "baseAssessments must not be empty" : `baseAssessments is empty but ${expectedVariants.length} variant(s) were expected \u2014 treating as malformed output`
+      );
+    }
+    const seenVariants = /* @__PURE__ */ new Set();
+    const assessments = [];
+    for (let i = 0; i < raw.length; i++) {
+      const item = raw[i];
+      if (!isRecord(item)) {
+        warnings.push(`baseAssessments[${i}] is not an object \u2014 skipping`);
+        continue;
+      }
+      const variantId = typeof item.variant === "string" ? item.variant : "";
+      if (!variantId) fail(`baseAssessments[${i}].variant is required`);
+      if (!expectedSet.has(variantId)) {
+        fail(
+          `baseAssessments[${i}].variant "${variantId}" is not in expectedVariants [${expectedVariants.join(", ")}]`
+        );
+      }
+      if (seenVariants.has(variantId)) {
+        fail(`baseAssessments contains duplicate entry for variant "${variantId}"`);
+      }
+      seenVariants.add(variantId);
+      const parsedItem = itemSchema(i).parse(item);
+      assessments.push({ variant: variantId, ...parsedItem, repoHygiene: parsedItem.scopeHygiene });
+    }
+    for (const expected of expectedVariants) {
+      if (!seenVariants.has(expected)) {
+        warnings.push(
+          `baseAssessments is missing variant "${expected}" \u2014 inserted no-deliverable sentinel`
+        );
+        assessments.push({
+          variant: expected,
+          correctness: 0,
+          completeness: 0,
+          codeQuality: 0,
+          architecture: 0,
+          verificationConfidence: 0,
+          acceptanceRisk: "critical",
+          followUpCost: "structural",
+          scopeHygiene: "unknown",
+          repoHygiene: "unknown",
+          rationale: "Matrix judge omitted this variant; host inserted a no-deliverable sentinel so escalation can continue."
+        });
+      }
+    }
+    return assessments;
+  });
+}
+function profileVerdictsSchema(expectedVariants, warnings) {
+  const expectedSet = new Set(expectedVariants);
+  return z.unknown().transform((raw) => {
+    if (!Array.isArray(raw)) fail("profileVerdicts must be an array");
+    if (raw.length !== 3) {
+      fail(`profileVerdicts must have exactly 3 entries (one per profile), got ${raw.length}`);
+    }
+    const seenProfiles = /* @__PURE__ */ new Set();
+    const verdicts = [];
+    for (let i = 0; i < raw.length; i++) {
+      const item = raw[i];
+      if (!isRecord(item)) fail(`profileVerdicts[${i}] must be an object`);
+      let profileRaw = typeof item.profile === "string" ? item.profile : "";
+      if (profileRaw === "merge-ready") profileRaw = "acceptance-ready";
+      if (!REQUIRED_PROFILES.includes(profileRaw)) {
+        fail(`profileVerdicts[${i}].profile "${profileRaw}" is not a valid JudgeProfile`);
+      }
+      const profile = profileRaw;
+      if (seenProfiles.has(profile)) {
+        fail(`profileVerdicts contains duplicate entry for profile "${profile}"`);
+      }
+      seenProfiles.add(profile);
+      const rawWinner = typeof item.winner === "string" ? item.winner : "";
+      if (!rawWinner) fail(`profileVerdicts[${i}].winner is required`);
+      const winner = resolveWinnerRef(
+        rawWinner,
+        expectedSet,
+        `profileVerdicts[${i}].winner`,
+        warnings,
+        `profileVerdicts[${i}].winner "${rawWinner}" is not in expectedVariants [${expectedVariants.join(", ")}]`
+      );
+      const ranking = looseStringArray.parse(item.ranking);
+      if (ranking.length === 0) fail(`profileVerdicts[${i}].ranking must not be empty`);
+      const seenRanking = /* @__PURE__ */ new Set();
+      const normalizedRanking = [];
+      for (const r of ranking) {
+        const resolvedRank = resolveWinnerRef(
+          r,
+          expectedSet,
+          `profileVerdicts[${i}].ranking`,
+          warnings,
+          `profileVerdicts[${i}].ranking contains unknown variant "${r}"`
+        );
+        if (seenRanking.has(resolvedRank)) {
+          fail(`profileVerdicts[${i}].ranking contains duplicate variant "${resolvedRank}"`);
+        }
+        seenRanking.add(resolvedRank);
+        normalizedRanking.push(resolvedRank);
+      }
+      for (const expected of expectedVariants) {
+        if (!seenRanking.has(expected)) {
+          warnings.push(
+            `profileVerdicts[${i}].ranking is missing variant "${expected}" \u2014 appended at end`
+          );
+          normalizedRanking.push(expected);
+        }
+      }
+      const confidence = typeof item.confidence === "number" && Number.isFinite(item.confidence) ? item.confidence : null;
+      if (confidence === null || confidence < 0 || confidence > 1) {
+        fail(`profileVerdicts[${i}].confidence=${confidence} is outside [0,1]`);
+      }
+      verdicts.push({
+        profile,
+        winner,
+        ranking: normalizedRanking,
+        confidence,
+        rationale: looseString.parse(item.rationale),
+        decisiveFactors: looseStringArray.parse(item.decisiveFactors),
+        disqualifiers: looseStringArray.parse(item.disqualifiers),
+        verificationStateUsed: lenientEnum(
+          VERIFICATION_STATE_VALUES,
+          "VerificationState",
+          `profileVerdicts[${i}].verificationStateUsed`,
+          warnings
+        ).parse(item.verificationStateUsed),
+        whyWinnerOverGreenAlternative: typeof item.whyWinnerOverGreenAlternative === "string" ? item.whyWinnerOverGreenAlternative : void 0
+      });
+    }
+    for (const required of REQUIRED_PROFILES) {
+      if (!seenProfiles.has(required)) {
+        fail(`profileVerdicts is missing required profile "${required}"`);
+      }
+    }
+    return verdicts;
+  });
+}
+function diagnosticsSchema(expectedVariants, warnings) {
+  const expectedSet = new Set(expectedVariants);
+  const riskLevel = (path) => lenientEnum(RISK_LEVEL_VALUES, "RiskLevel", path, warnings);
+  const riskFlagsSchema = z.preprocess(
+    (value) => {
+      const v = isRecord(value) ? value : {};
+      return {
+        securityRisk: v.securityRisk,
+        regressionRisk: v.regressionRisk,
+        scopeRisk: v.scopeRisk ?? v.blastRadius,
+        reversibilityRisk: v.reversibilityRisk ?? v.rollbackRisk,
+        migrationRisk: v.migrationRisk,
+        operatorWorkflowRisk: v.operatorWorkflowRisk
+      };
+    },
+    z.object({
+      securityRisk: riskLevel("diagnostics.riskFlags.securityRisk"),
+      regressionRisk: riskLevel("diagnostics.riskFlags.regressionRisk"),
+      scopeRisk: riskLevel("diagnostics.riskFlags.scopeRisk"),
+      reversibilityRisk: riskLevel("diagnostics.riskFlags.reversibilityRisk"),
+      migrationRisk: riskLevel("diagnostics.riskFlags.migrationRisk"),
+      operatorWorkflowRisk: riskLevel("diagnostics.riskFlags.operatorWorkflowRisk")
+    })
+  );
+  return z.unknown().transform((raw) => {
+    if (!isRecord(raw)) fail("diagnostics must be an object");
+    const resolveSoftRefs = (values, fieldPath) => {
+      const resolved = [];
+      for (const value of values) {
+        const { id, warning } = resolveVariantRef(value, expectedSet);
+        if (warning) warnings.push(`${fieldPath}: ${warning}`);
+        if (id !== null) resolved.push(id);
+      }
+      return resolved;
+    };
+    if (raw.requiredHumanChecks === void 0 || raw.requiredHumanChecks === null) {
+      warnings.push("diagnostics.requiredHumanChecks is missing \u2014 defaulting to []");
+    }
+    const paretoFrontier = resolveSoftRefs(
+      looseStringArray.parse(raw.paretoFrontier),
+      "diagnostics.paretoFrontier"
+    );
+    const dominatedVariants = resolveSoftRefs(
+      looseStringArray.parse(raw.dominatedVariants),
+      "diagnostics.dominatedVariants"
+    );
+    const followUpCostByVariant = {};
+    const rawFollowUpCostByVariant = raw.followUpCostByVariant ?? raw.fixupCostByVariant;
+    if (isRecord(rawFollowUpCostByVariant)) {
+      for (const [rawKey, value] of Object.entries(rawFollowUpCostByVariant)) {
+        const { id, warning } = resolveVariantRef(rawKey, expectedSet);
+        if (warning) warnings.push(`diagnostics.followUpCostByVariant: ${warning}`);
+        if (id === null) continue;
+        followUpCostByVariant[id] = lenientEnum(
+          FOLLOW_UP_COST_VALUES,
+          "FollowUpCost",
+          `diagnostics.followUpCostByVariant.${id}`,
+          warnings,
+          LEGACY_FOLLOW_UP_COST_ALIASES
+        ).parse(value);
+      }
+    }
+    const riskFlags = riskFlagsSchema.parse(raw.riskFlags);
+    const sensitivityRaw = isRecord(raw.sensitivity) ? raw.sensitivity : {};
+    const requiredHumanChecks = looseStringArray.parse(raw.requiredHumanChecks);
+    const llmBlockingHumanChecks = Array.isArray(raw.blockingHumanChecks) ? looseStringArray.parse(raw.blockingHumanChecks) : [];
+    const rawAdvisoryHumanChecks = Array.isArray(raw.advisoryHumanChecks) ? looseStringArray.parse(raw.advisoryHumanChecks) : requiredHumanChecks;
+    const blockingHumanChecks = Array.from(
+      /* @__PURE__ */ new Set([...requiredHumanChecks, ...llmBlockingHumanChecks])
+    );
+    const advisoryHumanChecks = rawAdvisoryHumanChecks.filter(
+      (check) => !blockingHumanChecks.includes(check)
+    );
+    return {
+      paretoFrontier,
+      dominatedVariants,
+      profileDisagreements: looseStringArray.parse(raw.profileDisagreements),
+      riskFlags,
+      followUpCostByVariant,
+      sensitivity: {
+        nearTies: looseStringArray.parse(sensitivityRaw.nearTies),
+        criteriaThatCouldFlipDecision: looseStringArray.parse(
+          sensitivityRaw.criteriaThatCouldFlipDecision
+        )
+      },
+      requiredHumanChecks,
+      blockingHumanChecks,
+      advisoryHumanChecks,
+      coverageGaps: looseStringArray.parse(raw.coverageGaps)
+    };
+  });
+}
+function disagreementsSchema(expectedVariants, warnings) {
+  const expectedSet = new Set(expectedVariants);
+  return z.unknown().transform((raw) => {
+    if (!isRecord(raw)) fail("disagreements must be an object");
+    const winnerByProfileRaw = isRecord(raw.winnerByProfile) ? raw.winnerByProfile : {};
+    const winnerByProfile = {
+      // Accept both new name (acceptance-ready) and legacy alias (merge-ready)
+      "acceptance-ready": looseString.parse(
+        winnerByProfileRaw["acceptance-ready"] ?? winnerByProfileRaw["merge-ready"]
+      ),
+      "best-as-delivered": looseString.parse(winnerByProfileRaw["best-as-delivered"]),
+      "best-foundation": looseString.parse(winnerByProfileRaw["best-foundation"])
+    };
+    for (const profile of REQUIRED_PROFILES) {
+      const rawWinner = winnerByProfile[profile];
+      if (!rawWinner) fail(`disagreements.winnerByProfile.${profile} is required`);
+      winnerByProfile[profile] = resolveWinnerRef(
+        rawWinner,
+        expectedSet,
+        `disagreements.winnerByProfile.${profile}`,
+        warnings,
+        `disagreements.winnerByProfile.${profile} "${rawWinner}" is not in expectedVariants [${expectedVariants.join(", ")}]`
+      );
+    }
+    return {
+      profilesDisagree: looseBoolean.parse(raw.profilesDisagree),
+      winnerByProfile,
+      explanation: looseString.parse(raw.explanation)
+    };
+  });
+}
+function synthesisOpportunitiesSchema(expectedVariants, warnings) {
+  const expectedSet = new Set(expectedVariants);
+  return z.unknown().transform((raw) => {
+    if (raw === void 0 || raw === null) {
+      warnings.push("synthesisOpportunities is missing \u2014 defaulting to []");
+      return [];
+    }
+    if (!Array.isArray(raw)) fail("synthesisOpportunities must be an array");
+    const opportunities = [];
+    for (let i = 0; i < raw.length; i++) {
+      const item = raw[i];
+      if (!isRecord(item)) {
+        warnings.push(`synthesisOpportunities[${i}] is not an object \u2014 skipping`);
+        continue;
+      }
+      const rawSourceVariant = looseString.parse(item.sourceVariant ?? item.variant);
+      if (!rawSourceVariant) fail(`synthesisOpportunities[${i}].sourceVariant is required`);
+      const { id: sourceVariant, warning } = resolveVariantRef(rawSourceVariant, expectedSet);
+      if (warning) warnings.push(`synthesisOpportunities[${i}].sourceVariant: ${warning}`);
+      if (sourceVariant === null) continue;
+      opportunities.push({
+        sourceVariant,
+        take: looseStringArray.parse(item.take),
+        reject: looseStringArray.parse(item.reject),
+        fixBeforeUse: looseStringArray.parse(item.fixBeforeUse),
+        rationale: looseString.parse(item.rationale)
+      });
+    }
+    return opportunities;
+  });
+}
+function criterionAssessmentsSchema(expectedVariants, expectedCriterionIds) {
+  return z.unknown().transform((raw) => {
+    if (expectedCriterionIds === void 0) {
+      if (raw === void 0 || raw === null) return void 0;
+    } else if (!Array.isArray(raw)) {
+      fail("criterionAssessments must be an array");
+    }
+    if (!Array.isArray(raw)) fail("criterionAssessments must be an array");
+    const variantSet = new Set(expectedVariants);
+    const criterionSet = new Set(expectedCriterionIds ?? []);
+    const seen = /* @__PURE__ */ new Set();
+    const assessments = raw.map((item, index) => {
+      if (!isRecord(item)) fail(`criterionAssessments[${index}] must be an object`);
+      const criterionId = looseString.parse(item.criterionId).trim();
+      const variant = looseString.parse(item.variant).trim();
+      if (!criterionId) fail(`criterionAssessments[${index}].criterionId is required`);
+      if (!variantSet.has(variant)) {
+        fail(`criterionAssessments[${index}].variant must be an exact expected variant ID`);
+      }
+      if (expectedCriterionIds !== void 0 && !criterionSet.has(criterionId)) {
+        fail(`criterionAssessments[${index}].criterionId "${criterionId}" is not expected`);
+      }
+      const key = `${criterionId}\0${variant}`;
+      if (seen.has(key)) {
+        fail(
+          `criterionAssessments contains duplicate criterion/variant pair: ${criterionId}/${variant}`
+        );
+      }
+      seen.add(key);
+      const status = z.enum(MATRIX_CRITERION_STATUS_VALUES).safeParse(item.status);
+      if (!status.success) fail(`criterionAssessments[${index}].status is invalid`);
+      const evidenceKind = z.enum(MATRIX_EVIDENCE_KIND_VALUES).safeParse(item.evidenceKind);
+      if (!evidenceKind.success) fail(`criterionAssessments[${index}].evidenceKind is invalid`);
+      const evidence = looseStringArray.parse(item.evidence).filter((entry) => entry.trim());
+      if (evidence.length === 0) fail(`criterionAssessments[${index}].evidence must not be empty`);
+      return {
+        criterionId,
+        variant,
+        status: status.data,
+        evidenceKind: evidenceKind.data,
+        evidence
+      };
+    });
+    if (expectedCriterionIds !== void 0) {
+      for (const criterionId of expectedCriterionIds) {
+        for (const variant of expectedVariants) {
+          if (!seen.has(`${criterionId}\0${variant}`)) {
+            fail(
+              `criterionAssessments is missing criterion/variant pair: ${criterionId}/${variant}`
+            );
+          }
+        }
+      }
+      const expectedCount = expectedCriterionIds.length * expectedVariants.length;
+      if (assessments.length !== expectedCount) {
+        fail(`criterionAssessments must contain exactly ${expectedCount} rows`);
+      }
+    }
+    return assessments;
+  });
+}
+function runnerUpAdvantagesSchema(expectedVariants, expectedCriterionIds, required) {
+  return z.unknown().transform((raw) => {
+    if (raw === void 0 || raw === null) {
+      if (required) fail("runnerUpAdvantages must be an array");
+      return void 0;
+    }
+    if (!Array.isArray(raw)) fail("runnerUpAdvantages must be an array");
+    const variantSet = new Set(expectedVariants);
+    return raw.map((item, index) => {
+      if (!isRecord(item)) fail(`runnerUpAdvantages[${index}] must be an object`);
+      const sourceVariant = looseString.parse(item.sourceVariant).trim();
+      if (!variantSet.has(sourceVariant)) {
+        fail(`runnerUpAdvantages[${index}].sourceVariant must be an exact expected variant ID`);
+      }
+      const advantage = looseString.parse(item.advantage).trim();
+      const rationale = looseString.parse(item.rationale).trim();
+      if (!advantage) fail(`runnerUpAdvantages[${index}].advantage is required`);
+      if (!rationale) fail(`runnerUpAdvantages[${index}].rationale is required`);
+      const evidenceKind = z.enum(MATRIX_EVIDENCE_KIND_VALUES).safeParse(item.evidenceKind);
+      if (!evidenceKind.success) fail(`runnerUpAdvantages[${index}].evidenceKind is invalid`);
+      const evidence = looseStringArray.parse(item.evidence).filter((entry) => entry.trim());
+      if (evidence.length === 0) fail(`runnerUpAdvantages[${index}].evidence must not be empty`);
+      const disposition = z.enum(["adopt", "harvest", "reject", "follow-up"]).safeParse(item.disposition);
+      if (!disposition.success) fail(`runnerUpAdvantages[${index}].disposition is invalid`);
+      const followUpCost = item.followUpCost === void 0 ? void 0 : typeof item.followUpCost === "string" && FOLLOW_UP_COST_VALUES.includes(item.followUpCost) ? item.followUpCost : fail(`runnerUpAdvantages[${index}].followUpCost is invalid`);
+      const hasWinnerCriterionGap = Object.hasOwn(item, "winnerCriterionGap");
+      if (required && !hasWinnerCriterionGap) {
+        fail(`runnerUpAdvantages[${index}].winnerCriterionGap is required`);
+      }
+      let winnerCriterionGap;
+      if (hasWinnerCriterionGap) {
+        if (item.winnerCriterionGap === null) {
+          winnerCriterionGap = null;
+        } else {
+          if (!isRecord(item.winnerCriterionGap)) {
+            fail(`runnerUpAdvantages[${index}].winnerCriterionGap must be an object or null`);
+          }
+          const variant = looseString.parse(item.winnerCriterionGap.variant).trim();
+          const criterionId = looseString.parse(item.winnerCriterionGap.criterionId).trim();
+          if (!variantSet.has(variant)) {
+            fail(
+              `runnerUpAdvantages[${index}].winnerCriterionGap.variant must be an exact expected variant ID`
+            );
+          }
+          if (!criterionId || expectedCriterionIds && !expectedCriterionIds.includes(criterionId)) {
+            fail(
+              `runnerUpAdvantages[${index}].winnerCriterionGap.criterionId must be an exact expected criterion ID`
+            );
+          }
+          winnerCriterionGap = { variant, criterionId };
+        }
+      }
+      return {
+        sourceVariant,
+        advantage,
+        evidenceKind: evidenceKind.data,
+        evidence,
+        disposition: disposition.data,
+        rationale,
+        ...followUpCost ? { followUpCost } : {},
+        ...hasWinnerCriterionGap ? { winnerCriterionGap } : {}
+      };
+    });
+  });
+}
+function calibrationStatusSchema(warnings) {
+  return z.unknown().transform((value) => {
+    if (value !== void 0 && value !== "experimental" && value !== "validated") {
+      warnings.push(`Unexpected calibrationStatus "${value}", defaulting to "experimental"`);
+    }
+    return value === "validated" ? "validated" : "experimental";
+  });
+}
+function isDegradedStatus(value) {
+  const normalized = value?.trim().toLowerCase().replace(/[_\s]+/g, "-");
+  if (!normalized) return false;
+  return normalized.includes("fail") || normalized.includes("error") || normalized.includes("timeout") || normalized.includes("timed-out") || normalized.includes("crash") || normalized.includes("degraded");
+}
+function buildMatrixWinnerStatus(input) {
+  const caveats = [];
+  const lowConfidenceProfiles = input.profileVerdicts.filter((verdict) => verdict.confidence < MATRIX_INCONCLUSIVE_CONFIDENCE_THRESHOLD).map((verdict) => `${verdict.profile}=${verdict.confidence.toFixed(2)}`);
+  if (input.profileVerdicts.length === 0) {
+    caveats.push("no profile verdicts were produced");
+  } else if (lowConfidenceProfiles.length === input.profileVerdicts.length) {
+    caveats.push(
+      `all profile verdicts below confidence threshold ${MATRIX_INCONCLUSIVE_CONFIDENCE_THRESHOLD}: ${lowConfidenceProfiles.join(", ")}`
+    );
+  }
+  const evidenceByVariant = new Map(
+    input.evidenceLedger.variants.map((entry) => [entry.variant, entry])
+  );
+  const allFailed = new Set(input.evidenceLedger.verificationSummary.allFailed);
+  const notRun = new Set(input.evidenceLedger.verificationSummary.notRun);
+  const degradedWinnerProfiles = input.profileVerdicts.filter((verdict) => {
+    if (verdict.profile === "best-foundation" && verdict.confidence < MATRIX_HIGH_CONFIDENCE_DEGRADED_THRESHOLD) {
+      return false;
+    }
+    const evidence = evidenceByVariant.get(verdict.winner);
+    return verdict.verificationStateUsed === "all-fail" || verdict.verificationStateUsed === "not-run" || allFailed.has(verdict.winner) || notRun.has(verdict.winner) || isDegradedStatus(evidence?.testStatus) || isDegradedStatus(evidence?.buildStatus);
+  }).map((verdict) => `${verdict.profile}=${verdict.winner}`);
+  if (degradedWinnerProfiles.length > 0) {
+    caveats.push(`degraded or unverified profile winner: ${degradedWinnerProfiles.join(", ")}`);
+  }
+  const hardInconclusiveCaveats = [...caveats];
+  if (hardInconclusiveCaveats.length > 0) {
+    return { status: "inconclusive", caveats: hardInconclusiveCaveats };
+  }
+  if (input.diagnostics.blockingHumanChecks.length > 0) {
+    return { status: "conditional", caveats: [...input.diagnostics.blockingHumanChecks] };
+  }
+  if (input.disagreements.profilesDisagree && input.diagnostics.sensitivity.nearTies.length > 0) {
+    caveats.push(
+      `split profile decision with near-tie sensitivity: ${input.diagnostics.sensitivity.nearTies.slice(0, 3).join(" | ")}`
+    );
+  }
+  if (caveats.length > 0) {
+    return { status: "inconclusive", caveats };
+  }
+  return { status: "accepted", caveats: [] };
+}
+function isAcceptedMatrixVerdict(status) {
+  return status === "accepted";
+}
+function parseMatrixResult(rawOutput, expectedVariants, options = {}) {
+  const warnings = [];
+  let parsed;
+  try {
+    parsed = extractJsonFromOutput(rawOutput);
+  } catch (err) {
+    return {
+      success: false,
+      error: `JSON extraction threw unexpectedly: ${err instanceof Error ? err.message : String(err)}`,
+      warnings
+    };
+  }
+  if (parsed === null || parsed === void 0) {
+    return { success: false, error: "No JSON object found in LLM output", warnings };
+  }
+  if (!isRecord(parsed)) {
+    return {
+      success: false,
+      error: `Parsed JSON is not an object (got ${Array.isArray(parsed) ? "array" : typeof parsed})`,
+      warnings
+    };
+  }
+  if (parsed.mode !== "profile-matrix") {
+    return {
+      success: false,
+      error: `Expected mode="profile-matrix", got ${JSON.stringify(parsed.mode)}`,
+      warnings
+    };
+  }
+  for (const key of Object.keys(parsed)) {
+    if (!KNOWN_TOP_LEVEL_FIELDS.has(key)) {
+      warnings.push(`Unexpected top-level field: "${key}"`);
+    }
+  }
+  const matrixSchema = z.object({
+    evidenceLedger: evidenceLedgerSchema(warnings),
+    baseAssessments: baseAssessmentsSchema(expectedVariants, warnings),
+    profileVerdicts: profileVerdictsSchema(expectedVariants, warnings),
+    diagnostics: diagnosticsSchema(expectedVariants, warnings),
+    disagreements: disagreementsSchema(expectedVariants, warnings),
+    synthesisOpportunities: synthesisOpportunitiesSchema(expectedVariants, warnings),
+    criterionAssessments: criterionAssessmentsSchema(
+      expectedVariants,
+      options.expectedCriterionIds
+    ),
+    runnerUpAdvantages: runnerUpAdvantagesSchema(
+      expectedVariants,
+      options.expectedCriterionIds,
+      options.expectedCriterionIds !== void 0
+    ),
+    calibrationStatus: calibrationStatusSchema(warnings)
+  });
+  let sections;
+  try {
+    sections = matrixSchema.parse(parsed);
+  } catch (err) {
+    if (err instanceof MatrixSchemaError) {
+      return { success: false, error: err.message, warnings };
+    }
+    return {
+      success: false,
+      error: `Matrix validation threw unexpectedly: ${err instanceof Error ? err.message : String(err)}`,
+      warnings
+    };
+  }
+  const result = {
+    mode: "profile-matrix",
+    matrixEvaluatorType: "ai-profile-matrix",
+    evidenceLedger: sections.evidenceLedger,
+    baseAssessments: sections.baseAssessments,
+    profileVerdicts: sections.profileVerdicts,
+    diagnostics: sections.diagnostics,
+    disagreements: sections.disagreements,
+    synthesisOpportunities: sections.synthesisOpportunities,
+    ...sections.criterionAssessments ? { criterionAssessments: sections.criterionAssessments } : {},
+    ...sections.runnerUpAdvantages ? { runnerUpAdvantages: sections.runnerUpAdvantages } : {},
+    calibrationStatus: sections.calibrationStatus
+  };
+  if (sections.criterionAssessments) {
+    const assessmentsByVariant = /* @__PURE__ */ new Map();
+    for (const assessment of sections.criterionAssessments) {
+      const entries = assessmentsByVariant.get(assessment.variant) ?? [];
+      entries.push(assessment);
+      assessmentsByVariant.set(assessment.variant, entries);
+    }
+    for (const verdict of sections.profileVerdicts) {
+      const hasRequiredGap = (assessmentsByVariant.get(verdict.winner) ?? []).some(
+        (assessment) => assessment.status === "partial" || assessment.status === "missing"
+      );
+      const diagnosticFollowUp = sections.diagnostics.followUpCostByVariant[verdict.winner];
+      const assessmentFollowUp = sections.baseAssessments.find(
+        (assessment) => assessment.variant === verdict.winner
+      )?.followUpCost;
+      if (hasRequiredGap && (diagnosticFollowUp === "none" || assessmentFollowUp === "none")) {
+        return {
+          success: false,
+          error: `Profile ${verdict.profile} winner ${verdict.winner} has a partial/missing required criterion but declares no follow-up cost`,
+          warnings
+        };
+      }
+    }
+    for (const advantage of sections.runnerUpAdvantages ?? []) {
+      const gap = advantage.winnerCriterionGap;
+      if (!gap) continue;
+      const selectedWinner = sections.profileVerdicts.some(
+        (verdict) => verdict.winner === gap.variant
+      );
+      if (!selectedWinner) {
+        return {
+          success: false,
+          error: `runnerUpAdvantages winnerCriterionGap target ${gap.variant} is not a selected profile winner`,
+          warnings
+        };
+      }
+      const assessment = (assessmentsByVariant.get(gap.variant) ?? []).find(
+        (entry) => entry.criterionId === gap.criterionId
+      );
+      if (assessment?.status === "delivered") {
+        return {
+          success: false,
+          error: `runnerUpAdvantages identifies ${gap.variant}/${gap.criterionId} as a winner criterion gap but criterionAssessments marks it delivered`,
+          warnings
+        };
+      }
+      const diagnosticFollowUp = sections.diagnostics.followUpCostByVariant[gap.variant];
+      const assessmentFollowUp = sections.baseAssessments.find(
+        (entry) => entry.variant === gap.variant
+      )?.followUpCost;
+      if (diagnosticFollowUp === "none" || assessmentFollowUp === "none") {
+        return {
+          success: false,
+          error: `runnerUpAdvantages identifies ${gap.variant}/${gap.criterionId} as a winner criterion gap but declares no follow-up cost`,
+          warnings
+        };
+      }
+    }
+  }
+  const winnerStatus = buildMatrixWinnerStatus({
+    evidenceLedger: sections.evidenceLedger,
+    profileVerdicts: sections.profileVerdicts,
+    diagnostics: sections.diagnostics,
+    disagreements: sections.disagreements
+  });
+  result.winnerStatus = winnerStatus.status;
+  if (winnerStatus.caveats.length > 0) {
+    result.winnerCaveats = winnerStatus.caveats;
+  }
+  return { success: true, result, warnings };
+}
+
+export {
+  resolveVariantRef,
+  buildMatrixWinnerStatus,
+  isAcceptedMatrixVerdict,
+  parseMatrixResult
+};
+//# sourceMappingURL=chunk-5LAMRH4X.js.map