@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/matrix-prompt-builder-4ZBOGZSB.js

@@ -0,0 +1,527 @@
+import {
+  analyzeVerificationEvidenceQuality,
+  buildVariantFileInventory
+} from "./chunk-CTDLERWU.js";
+import {
+  formatVerificationProvenanceForPrompt,
+  resolveJudgeEvaluationContext
+} from "./chunk-QTCLJHLZ.js";
+import "./chunk-SU6UFUQY.js";
+import "./chunk-FSA5BPFI.js";
+import "./chunk-INJ3SS6A.js";
+import "./chunk-LDJCKAJP.js";
+import "./chunk-XON4ZCYX.js";
+import "./chunk-PPHXX4W7.js";
+import "./chunk-ETA2K4KI.js";
+import "./chunk-ZJB6SQPA.js";
+import {
+  deriveVariantOutcome
+} from "./chunk-3OPP2OZB.js";
+import "./chunk-PXKERBKX.js";
+import {
+  extractCleanStdout,
+  filterPatchDiffByExcludedPaths,
+  frameUntrustedJudgeEvidence,
+  frameUntrustedJudgeTaskText,
+  presentUntrustedJudgeEvidence,
+  redactSuspiciousJudgePromptPatterns
+} from "./chunk-AEQWV746.js";
+import "./chunk-SVUNZOPG.js";
+import "./chunk-KUEWV2JH.js";
+import "./chunk-R2TIYG7U.js";
+import "./chunk-5FKHIKTS.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import "./chunk-AHU3FKPA.js";
+import "./chunk-TUQMMFEQ.js";
+import "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import "./chunk-RPIMAMV7.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import "./chunk-2VLJUXJU.js";
+import "./chunk-FKCG7K6H.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-V2TVPO3X.js";
+import "./chunk-RRC5BL7B.js";
+import "./chunk-RCP2Y6DQ.js";
+import "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import {
+  BUILD_JUDGE_EXPERIMENTAL,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/judge/matrix-prompt-builder.ts
+var MATRIX_EVIDENCE_TRUNCATION_CHARS = 8e4;
+var MATRIX_TOTAL_EVIDENCE_CHARS = 24e4;
+var FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT = 20;
+function truncateDiffHeadTail(text, budget) {
+  if (text.length <= budget) return text;
+  const sideBudget = Math.max(0, Math.floor(budget / 2) - 50);
+  const head = text.slice(0, sideBudget);
+  const tail = text.slice(text.length - sideBudget);
+  const omitted = text.length - head.length - tail.length;
+  return `${head}
+... [diff truncated: ${omitted} chars omitted] ...
+${tail}`;
+}
+function deriveGateSignals(result) {
+  const testsRun = result.testMetrics?.totalTests;
+  const testsPassed = result.testMetrics?.passedTests;
+  const testsFailed = result.testMetrics?.failedTests;
+  const outcome = result.outcome ?? deriveVariantOutcome(result);
+  const buildFinding = result.verification?.findings?.find((finding) => finding.kind === "build");
+  const lintFinding = result.verification?.findings?.find((finding) => finding.kind === "lint");
+  const signal = {
+    ...result.testStatus ? { testStatus: result.testStatus } : {},
+    ...buildFinding ? { buildSignal: buildFinding.exitCode === 0 ? "passed" : "failed" } : {},
+    ...lintFinding ? { lintSignal: lintFinding.exitCode === 0 ? "passed" : "failed" } : {},
+    ...outcome.verification.outcome ? { verificationStatusAdjusted: outcome.verification.outcome } : {},
+    ...typeof testsRun === "number" ? { testsRun } : {},
+    ...typeof testsPassed === "number" ? { testsPassed } : {},
+    ...typeof testsFailed === "number" ? { testsFailed } : {}
+  };
+  return Object.keys(signal).length > 0 ? signal : void 0;
+}
+function formatMatrixVariantIdentifier(result) {
+  const rawVariant = typeof result.variant === "string" ? result.variant.trim() : "";
+  if (rawVariant.split(":").length >= 3) return rawVariant;
+  const provider = typeof result.provider === "string" ? result.provider.trim() : "";
+  const model = typeof result.resolvedModel === "string" && result.resolvedModel.trim().length > 0 ? result.resolvedModel.trim() : typeof result.model === "string" && result.model.trim().length > 0 ? result.model.trim() : "";
+  if (!provider || !model) return rawVariant || provider || "unknown";
+  const rawEffort = typeof result.effectiveReasoningEffort === "string" && result.effectiveReasoningEffort.trim().length > 0 ? result.effectiveReasoningEffort.trim() : typeof result.requestedReasoningEffort === "string" && result.requestedReasoningEffort.trim().length > 0 ? result.requestedReasoningEffort.trim() : "";
+  const effort = rawEffort ? `:${rawEffort.startsWith("effort-") ? rawEffort : `effort-${rawEffort}`}` : "";
+  const executionMode = typeof result.executionMode === "string" && result.executionMode.trim().length > 0 ? result.executionMode.trim() : "local";
+  return `${provider}:${model}${effort}:${executionMode}`;
+}
+function buildVariantSection(result, label, gateSignals, fileConstraint, evidenceTruncationChars) {
+  const inventory = buildVariantFileInventory(result, { fileConstraint });
+  const inventoryLines = [];
+  inventoryLines.push(`**Artifacts Changed (${inventory.totalArtifactsChanged}):**`);
+  if (inventory.artifactList.length > 0) {
+    for (const f of inventory.artifactList) {
+      inventoryLines.push(`- ${f}`);
+    }
+  } else {
+    inventoryLines.push("- (none detected)");
+  }
+  if (inventory.suspiciousArtifacts.length > 0) {
+    inventoryLines.push("");
+    inventoryLines.push(` Scope Hygiene: ${inventory.scopeHygieneRisk} risk`);
+    inventoryLines.push("Suspicious/generated artifacts:");
+    for (const f of inventory.suspiciousArtifacts) {
+      inventoryLines.push(`- ${f}`);
+    }
+  }
+  const coverage = inventory.fileTargetCoverage;
+  if (coverage) {
+    inventoryLines.push("");
+    inventoryLines.push(`**FILE Target Coverage (${coverage.mode}):**`);
+    inventoryLines.push(`- Touched: ${coverage.touchedTargets.length}/${coverage.targetCount}`);
+    if (coverage.touchedTargets.length > 0) {
+      inventoryLines.push("- Touched targets:");
+      for (const target of coverage.touchedTargets.slice(
+        0,
+        FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT
+      )) {
+        inventoryLines.push(`  - ${target}`);
+      }
+      const omitted = coverage.touchedTargets.length - FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT;
+      if (omitted > 0) inventoryLines.push(`  - ... ${omitted} more`);
+    }
+    if (coverage.missingTargets.length > 0) {
+      inventoryLines.push("- Missing targets:");
+      for (const target of coverage.missingTargets.slice(
+        0,
+        FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT
+      )) {
+        inventoryLines.push(`  - ${target}`);
+      }
+      const omitted = coverage.missingTargets.length - FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT;
+      if (omitted > 0) inventoryLines.push(`  - ... ${omitted} more`);
+    }
+    if (coverage.offTargetArtifacts.length > 0) {
+      inventoryLines.push("- Off-target artifacts for hard scope:");
+      for (const artifact of coverage.offTargetArtifacts.slice(
+        0,
+        FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT
+      )) {
+        inventoryLines.push(`  - ${artifact}`);
+      }
+      const omitted = coverage.offTargetArtifacts.length - FILE_TARGET_COVERAGE_PROMPT_ITEM_LIMIT;
+      if (omitted > 0) inventoryLines.push(`  - ... ${omitted} more`);
+    }
+  }
+  const inventoryBlock = inventoryLines.join("\n");
+  const hasWorktreeDiff = Boolean((result.worktreeDiff ?? "").trim());
+  const analysisWithoutDiff = result.executionIntent === "analysis" && !hasWorktreeDiff;
+  const rawDiff = hasWorktreeDiff ? result.worktreeDiff ?? "" : analysisWithoutDiff ? "" : result.worktreeDiff ?? result.output ?? "";
+  const diffSource = presentUntrustedJudgeEvidence(filterPatchDiffByExcludedPaths(rawDiff));
+  const diffBody = frameUntrustedJudgeEvidence(
+    truncateDiffHeadTail(diffSource, evidenceTruncationChars)
+  );
+  const claimSource = hasWorktreeDiff && !analysisWithoutDiff ? presentUntrustedJudgeEvidence(
+    filterPatchDiffByExcludedPaths(
+      [result.result?.stdout ?? "", result.output ?? ""].filter(Boolean).join("\n")
+    )
+  ) : presentUntrustedJudgeEvidence(filterPatchDiffByExcludedPaths(extractCleanStdout(result)));
+  const deliverableBody = frameUntrustedJudgeEvidence(
+    truncateDiffHeadTail(claimSource, evidenceTruncationChars)
+  );
+  const diffBlock = diffBody.trim().length > 0 ? `Source: direct implementation evidence
+\`\`\`diff
+${diffBody}
+\`\`\`` : "(no diff available)";
+  const deliverableBlock = deliverableBody.trim().length > 0 ? analysisWithoutDiff || !diffBody.trim() ? `**Deliverable Output:**
+
+\`\`\`text
+${deliverableBody}
+\`\`\`` : `**Executor Claims (not implementation evidence):**
+
+\`\`\`text
+${deliverableBody}
+\`\`\`` : "**Deliverable Output:** (none captured)";
+  const verificationProvenance = formatVerificationProvenanceForPrompt(result);
+  const lines = [
+    `### Variant: ${label}`,
+    "",
+    inventoryBlock,
+    "",
+    "**Diff / Patch Evidence:**",
+    "",
+    diffBlock,
+    "",
+    deliverableBlock,
+    ""
+  ];
+  if (verificationProvenance) {
+    lines.push(verificationProvenance, "");
+  }
+  if (gateSignals) {
+    lines.push("**Gate signals:**");
+    if (gateSignals.buildSignal !== void 0) {
+      lines.push(`- Build: ${gateSignals.buildSignal}`);
+    }
+    if (gateSignals.lintSignal !== void 0) {
+      lines.push(`- Lint: ${gateSignals.lintSignal}`);
+    }
+    if (gateSignals.testStatus !== void 0) {
+      lines.push(`- Tests: ${gateSignals.testStatus}`);
+    }
+    if (gateSignals.verificationStatusAdjusted !== void 0) {
+      lines.push(
+        `- Verification status (adjusted, baseline-aware): ${gateSignals.verificationStatusAdjusted}`
+      );
+    }
+    if (gateSignals.testsRun !== void 0 && gateSignals.testsPassed !== void 0 && gateSignals.testsFailed !== void 0) {
+      lines.push(
+        `- Test counts: ${gateSignals.testsRun} run, ${gateSignals.testsPassed} passed, ${gateSignals.testsFailed} failed`
+      );
+    }
+    lines.push("");
+  }
+  const verificationQuality = analyzeVerificationEvidenceQuality(result);
+  lines.push("**Verification evidence quality:**");
+  lines.push(`- Quality: ${verificationQuality.quality}`);
+  for (const reason of verificationQuality.reasons) {
+    lines.push(`- ${reason}`);
+  }
+  lines.push(`- Instruction: ${verificationQuality.instruction}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function buildMatrixJudgePrompt(options) {
+  const { variants, variantLabels, gateSignalsByVariant } = options;
+  const taskPrompt = redactSuspiciousJudgePromptPatterns(options.taskPrompt ?? "");
+  const framedTaskPrompt = frameUntrustedJudgeTaskText(taskPrompt);
+  const evaluationContext = resolveJudgeEvaluationContext(taskPrompt, {
+    evaluationContext: options.evaluationContext,
+    variants
+  });
+  const fileConstraint = evaluationContext.promptSpec.fileConstraint;
+  const requiredCriteria = evaluationContext.criteria.filter((item) => item.severity === "must");
+  const requiredCriteriaBlock = requiredCriteria.length > 0 ? requiredCriteria.map((item) => `- ${item.id}: ${item.text}`).join("\n") : "- (none)";
+  const escalationSections = [
+    ["Reasons", options.escalationContext?.reasons],
+    ["Weak or missing evidence", options.escalationContext?.weakOrMissingEvidence],
+    ["Criterion disagreements", options.escalationContext?.criterionDisagreements],
+    ["Degraded independence", options.escalationContext?.degradedIndependence]
+  ];
+  const escalationContextBlock = escalationSections.filter(([, values]) => values && values.length > 0).map(([label, values]) => `${label}:
+${values?.map((value) => `- ${value}`).join("\n")}`).join("\n");
+  const evidenceBlockCount = variants.reduce((count, variant) => {
+    const hasDiffEvidence = Boolean((variant.worktreeDiff ?? variant.output ?? "").trim());
+    const hasDeliverableEvidence = Boolean(extractCleanStdout(variant).trim());
+    return count + Number(hasDiffEvidence) + Number(hasDeliverableEvidence);
+  }, 0);
+  const evidenceTruncationChars = Math.min(
+    MATRIX_EVIDENCE_TRUNCATION_CHARS,
+    Math.max(1, Math.floor(MATRIX_TOTAL_EVIDENCE_CHARS / Math.max(1, evidenceBlockCount)))
+  );
+  const variantSections = variants.map((v, index) => {
+    const key = v.variant || v.provider || "unknown";
+    const label = variantLabels?.[index] ?? formatMatrixVariantIdentifier(v);
+    const signals = gateSignalsByVariant?.get(key) ?? deriveGateSignals(v);
+    return buildVariantSection(v, label, signals, fileConstraint, evidenceTruncationChars);
+  }).join("\n---\n\n");
+  const experimentalBanner = readEnv(BUILD_JUDGE_EXPERIMENTAL).value ? "\n EXPERIMENTAL: This is profile-aware judgment under active calibration.\n" : "";
+  const taskTypeLine = `**TASK TYPE**: ${evaluationContext.taskTypeResolution.taskType}`;
+  return `# Judge Profile Matrix Evaluation
+
+You are producing a Judge Profile Matrix: one coherent evidence model with three profile verdicts.
+${experimentalBanner}
+${taskTypeLine}
+
+Execution contract:
+- Do not use tools.
+- Do not enter plan mode.
+- Do not write files.
+- Return exactly one JSON object in your assistant message.
+- Do not wrap the JSON in XML, tool calls, markdown prose, or explanatory text.
+
+## Task
+
+${framedTaskPrompt}
+
+## Variants
+
+${variantSections}
+
+## Instructions
+
+Evaluate in seven strict phases. Do not skip phases or select winners before Phase 4.
+
+## Required Criteria (stable IDs)
+
+${requiredCriteriaBlock}
+
+${escalationContextBlock ? `## Escalation Context (qualitative, non-anchoring)
+
+${escalationContextBlock}
+
+Use this only to identify evidence that needs independent scrutiny. It contains no prior numeric scores or rankings and must not anchor the verdict.` : ""}
+
+### Phase 1: Evidence Ledger
+Build a shared evidence model. Identify task requirements, acceptance criteria, verification data, and concrete variant evidence. Do NOT select winners.
+
+For each acceptance criterion, assess whether each variant's evidence demonstrates delivery or merely implies proximity. A clean artifact, helper, section, config, patch, model, or document that exists but is not shown to be connected to the required outcome is proximity, not delivery. Surface unverified delivery assumptions in keyFindings.
+
+### Phase 2: Required-Criterion Reconciliation
+For every Required Criteria ID and every variant, emit exactly one criterionAssessments row. Use status delivered, partial, missing, or unverified and cite concrete evidence plus its evidenceKind. A row is about delivered behavior, not stylistic preference.
+
+Reconcile positive and negative evidence before assigning status. For an absolute criterion expressed with words such as every, never, only, or unless, one concrete counterexample prevents a delivered status even when other paths comply. A keyFinding that records a criterion violation must agree with criterionAssessments; do not acknowledge the violation in one section and mark that criterion delivered in another.
+
+### Phase 3: Base Assessments
+For each variant, assess: correctness (0-100), completeness (0-100), codeQuality (0-100), architecture (0-100; interpret as approach strength for non-code tasks), verificationConfidence (0-100), acceptanceRisk (low/medium/high/critical/unknown), followUpCost (none/mechanical/localized/moderate/structural/unknown). Include a one-sentence rationale.
+
+Also assess scopeHygiene (clean/minor-issues/significant-churn) \u2014 whether the result includes unrelated artifacts, unmanaged/generated/state artifacts, or non-task churn. Use the artifact inventory and suspicious artifact list provided for each variant. For analysis-only or no-edit tasks, use Deliverable Output as primary delivery evidence; do not score a variant as empty solely because it has zero changed artifacts.
+
+Gate contract: use "Verification status (adjusted, baseline-aware)" as the high-value verification outcome. If it is baseline_clean, raw build/test/lint failures are pre-existing unless the diff proves the variant introduced them. If it is failed, treat failed gates as acceptance-risk evidence. This is judge evidence only; do not invent host-side eligibility rules.
+
+Evidence-quality contract: use "Verification evidence quality" to distinguish trusted verification from partial, unavailable, or contradicted evidence. Partial/unavailable verification is not proof of a variant-introduced failure unless the diff, failure output, or adjusted verification status independently supports that conclusion. If the winning decision depends on partial, unavailable, or contradicted verification evidence, put the concern in winnerCaveats and set winnerStatus to conditional rather than accepted.
+
+Verification command boundary: acceptance criteria and verification findings must come from the task text or the host-provided variant evidence. Do not add generic convergence commands such as test:fast, typecheck, lint, build, npm scripts, or language-specific tooling as acceptance criteria unless the task explicitly requested that exact command or the host evidence shows that exact command was configured/requested for this run. If a command is unsupported, absent, or not requested, mark verification as unavailable/not-run only for that command; do not penalize a variant for failing to add scripts or tooling that the target project did not already declare and the task did not ask for.
+
+Apply three advisory lenses to the same evidence while forming the base assessments:
+- Correctness lens: identify requirement coverage, integration, and regression evidence gaps.
+- Security lens: identify authentication, authorization, injection, data exposure, and unsafe default risks.
+- Reproducibility lens: identify missing setup, verification, environment, or command evidence.
+
+Lens findings are advisory coverage signals. Emit unresolved lens findings only in diagnostics.coverageGaps or diagnostics.advisoryHumanChecks. Do not put lens findings in diagnostics.requiredHumanChecks or diagnostics.blockingHumanChecks, and do not use lens findings alone to make winnerStatus conditional.
+
+### Phase 4: Profile Verdicts
+Apply each profile independently to the SAME evidence ledger:
+
+**Acceptance Ready**: Which result can be accepted now with the least unresolved risk? Prioritize passing verification, low unresolved risk, contained scope of impact, minimal follow-up work required. A failing variant may still win when the judge determines it is the best result overall. If a variant's success depends on an unverified assumption about whether the delivered artifact is connected to the required outcome, classify that as a blocking unresolved assumption and emit it in diagnostics.blockingHumanChecks. Do not treat it as advisory because the variant is clean, small, elegant, or well-tested in isolation.
+
+**Best Overall (As Delivered)**: Which variant is the best complete deliverable as submitted? Evaluate what was ACTUALLY delivered, not what COULD be delivered with follow-up. Prioritize correctness, completeness, quality, maintainability, and evidence against acceptance criteria. When two variants both pass verification, completeness against explicitly stated acceptance criteria outweighs stylistic superiority \u2014 a variant that covers all stated scope items wins over one with slightly better style but missing stated deliverables. A variant with a blocking delivery-linkage assumption should not beat a variant that demonstrably delivers the required outcome unless the delivering variant has a more severe correctness, safety, or verification failure. Penalize: unrelated artifact churn, unmanaged/generated/state artifacts, missing integration points that the task specified, incomplete requested verification or presentation wiring, and any cleanup required before the result could be accepted. Do not give credit for unrealized potential that requires additional work to realize.
+
+**Best Foundation**: Which variant is the best base for repair or follow-up? Prioritize underlying approach, requirement coverage, clean boundaries, extensibility, and localized follow-up cost. A failing variant may beat a passing variant only when total acceptance effort is lower. A proximity-only variant may still win best-foundation if it is the best base for follow-up, but the verdict must explicitly separate foundation quality from acceptance readiness.
+
+For each profile verdict, declare: winner, ranking, confidence (0-1), rationale, decisiveFactors, concerns, verificationStateUsed, and whyWinnerOverGreenAlternative (if winner has failing verification).
+
+### Phase 5: Disagreement
+If profiles disagree on winner, explain which evidence was weighted differently.
+If profiles agree, state the decision is profile-insensitive.
+
+### Phase 6: Diagnostics and Runner-Up Reconciliation
+Emit: paretoFrontier (variants not dominated on any dimension), dominatedVariants, profileDisagreements, riskFlags (securityRisk, regressionRisk, scopeRisk, reversibilityRisk, migrationRisk, operatorWorkflowRisk), followUpCostByVariant, sensitivity (nearTies, criteriaThatCouldFlipDecision), coverageGaps, requiredHumanChecks, blockingHumanChecks, advisoryHumanChecks.
+
+Identify every verified material advantage held by a non-winning variant and emit one runnerUpAdvantages entry. Disposition each advantage explicitly as adopt, harvest, reject, or follow-up. A rejection must cite contrary evidence; adopt/harvest/follow-up must state the cost when work remains. Emit an empty array only when no verified material runner-up advantage exists.
+
+Runner-up reconciliation must agree with criterionAssessments. If an adopt, harvest, or follow-up disposition says the winner needs a change to satisfy a required criterion, the winner's row for that criterion cannot be delivered and its follow-up cost cannot be none.
+
+Every runnerUpAdvantages entry must classify that relationship with winnerCriterionGap. Set it to { variant, criterionId } when the advantage is needed for that selected winner to satisfy a required criterion; otherwise set it to null. Do not use null for a change that closes an acknowledged criterion violation.
+
+Consistency rule: if any selected profile winner has a required criterion marked partial or missing, neither its base-assessment followUpCost nor its diagnostics.followUpCostByVariant entry may claim "none". Do not call such a winner complete with zero follow-up.
+
+VARIANT REFERENCE RULE: every field that names a variant \u2014 paretoFrontier, dominatedVariants, the keys of followUpCostByVariant, every winner, every ranking entry, and winnerByProfile \u2014 MUST contain the EXACT variant ID verbatim and nothing else. In narrative fields, also use the full exact variant ID whenever referring to a variant. Never abbreviate an anonymous label: write "Solution A", never bare "A", "A's", "A/B", or similar shorthand. Do NOT append parenthetical notes, "dominated by ...", reasons, or any inline commentary next to a variant ID. Put all reasoning in the rationale, profileDisagreements, decisiveFactors, or explanation fields instead. Example: use "claude:sonnet:local", NOT "claude:sonnet:local (weaker tests)".
+
+Split human checks into three fields:
+- blockingHumanChecks: concerns about correctness, safety, data integrity, or production risk that MUST be resolved before the result can be accepted automatically. Only include genuinely blocking issues here.
+- advisoryHumanChecks: style preferences, coverage suggestions, or completeness improvements worth reviewing but that do not represent acceptance risk.
+- requiredHumanChecks: backwards-compatible acceptance checks that truly require human attention before automatic acceptance. Include blockingHumanChecks here; do not include advisory-only preferences that should not affect winnerStatus.
+
+If the task text explicitly allows multiple acceptable implementation or test styles, such as "add or update", "either ... or ...", or "X or Y", do not make a preference between those allowed alternatives a requiredHumanCheck, blockingHumanCheck, or conditional winnerStatus. Put that preference in advisoryHumanChecks only, unless the chosen alternative violates an explicit requirement or creates correctness, safety, data integrity, or production risk.
+
+### Phase 7: Synthesis Opportunities
+For each variant, identify what a later synthesis pass should take, reject, or fix before using.
+This is advisory implementation guidance only; it must not change any profile verdict.
+
+## Output Format
+
+Respond with a single JSON object matching this schema.
+
+The schema below is ANNOTATED for readability: \`//\` marks a trailing comment, and values like \`"string"\`, \`0\`, or \`low|medium|high\` describe the expected type or allowed values. Your output must be strict JSON \u2014 strip every \`//\` comment, and replace each placeholder with a real value. JSON does not permit comments.
+
+{
+  "mode": "profile-matrix",                    // literal string
+  "evidenceLedger": {
+    "taskSummary": "string",                   // one-paragraph synthesis of task requirements
+    "acceptanceCriteria": ["string"],           // extracted acceptance criteria
+    "variants": [
+      {
+        "variant": "string",                   // variant label
+        "artifactsChanged": 0,                 // number
+        "artifactList": ["string"],            // changed artifacts from inventory
+        "suspiciousArtifacts": ["string"],     // generated/state/non-task artifacts from inventory
+        "scopeHygieneRisk": "low",             // low|medium|high|unknown
+        "linesAdded": 0,                       // number
+        "linesRemoved": 0,                     // number
+        "testStatus": "string",                // e.g. "passed", "failed", "not_run"
+        "buildStatus": "string",               // e.g. "passed", "failed", "not_run"
+        "keyFindings": ["string"]              // concrete observations from the diff
+      }
+    ],
+    "crossVariantFindings": ["string"],        // observations spanning multiple variants
+    "verificationSummary": {
+      "allPassed": ["string"],                 // variant names where all gates passed
+      "partialFailures": ["string"],           // variant names with partial failures
+      "allFailed": ["string"],                 // variant names where all gates failed
+      "notRun": ["string"],                    // variant names with no verification data
+      "decisiveVerificationSignals": ["string"] // signals that most affect scoring
+    }
+  },
+  "baseAssessments": [
+    {
+      "variant": "string",
+      "correctness": 0,                        // 0-100
+      "completeness": 0,                       // 0-100
+      "codeQuality": 0,                        // 0-100
+      "architecture": 0,                       // 0-100; approach strength for non-code tasks
+      "verificationConfidence": 0,             // 0-100
+      "acceptanceRisk": "low",                  // low|medium|high|critical|unknown
+      "followUpCost": "none",                  // none|mechanical|localized|moderate|structural|unknown
+      "scopeHygiene": "clean",                 // clean|minor-issues|significant-churn|unknown
+      "rationale": "string"                    // one sentence
+    }
+  ],
+  "criterionAssessments": [
+    {
+      "criterionId": "CR-001",              // exact stable ID from Required Criteria
+      "variant": "string",                  // EXACT bare variant ID
+      "status": "delivered",                // delivered|partial|missing|unverified
+      "evidenceKind": "direct",             // outcome|direct|proxy|negative|missing|unverifiable
+      "evidence": ["string"]                // concrete provenance/citation; non-empty
+    }
+  ],
+  "profileVerdicts": [
+    {
+      "profile": "acceptance-ready",           // acceptance-ready|best-as-delivered|best-foundation
+      "winner": "string",                     // EXACT bare variant ID, no inline commentary
+      "ranking": ["string"],                  // all variants, best first; EXACT bare IDs only
+      "confidence": 0.0,                      // 0-1
+      "rationale": "string",
+      "decisiveFactors": ["string"],
+      "concerns": ["string"],                  // concerns considered in ranking
+      "verificationStateUsed": "all-pass",    // all-pass|partial-fail|all-fail|not-run|mixed|unknown
+      "whyWinnerOverGreenAlternative": "string" // only present when winner has failing verification
+    }
+  ],
+  "diagnostics": {
+    "paretoFrontier": ["string"],             // EXACT bare variant IDs not dominated on any dimension; no commentary
+    "dominatedVariants": ["string"],          // EXACT bare variant IDs strictly worse than another; explain in profileDisagreements, NOT inline
+    "profileDisagreements": ["string"],       // descriptions of cross-profile disagreements
+    "riskFlags": {
+      "securityRisk": "low",                  // low|medium|high|critical|unknown
+      "regressionRisk": "low",
+      "scopeRisk": "low",
+      "reversibilityRisk": "low",
+      "migrationRisk": "low",
+      "operatorWorkflowRisk": "low"
+    },
+    "followUpCostByVariant": {
+      "<variant>": "none"                     // key = EXACT bare variant ID (no commentary); value = none|mechanical|localized|moderate|structural|unknown
+    },
+    "sensitivity": {
+      "nearTies": ["string"],                 // pairs that are close in score
+      "criteriaThatCouldFlipDecision": ["string"]
+    },
+    "requiredHumanChecks": ["string"],        // acceptance checks that truly require human attention; exclude advisory-only preferences
+    "blockingHumanChecks": ["string"],        // safety/correctness concerns that MUST be resolved before accepting (production risk, data loss, security)
+    "advisoryHumanChecks": ["string"],        // style, coverage, or completeness suggestions worth reviewing but not blocking
+    "coverageGaps": ["string"]                // advisory correctness/security/reproducibility lens gaps; does not affect winnerStatus
+  },
+  "disagreements": {
+    "profilesDisagree": false,                // boolean
+    "winnerByProfile": {
+      "acceptance-ready": "string",           // EXACT bare variant ID, no commentary
+      "best-as-delivered": "string",          // EXACT bare variant ID, no commentary
+      "best-foundation": "string"             // EXACT bare variant ID, no commentary
+    },
+    "explanation": "string"
+  },
+  "synthesisOpportunities": [
+    {
+      "sourceVariant": "string",              // EXACT bare variant ID, no commentary
+      "take": ["string"],                     // reusable ideas, artifacts, or evidence
+      "reject": ["string"],                   // pieces not to reuse
+      "fixBeforeUse": ["string"],             // changes required before using as a base
+      "rationale": "string"
+    }
+  ],
+  "runnerUpAdvantages": [
+    {
+      "sourceVariant": "string",            // EXACT bare non-winning variant ID
+      "advantage": "string",
+      "evidenceKind": "direct",             // outcome|direct|proxy|negative|missing|unverifiable
+      "evidence": ["string"],
+      "disposition": "harvest",             // adopt|harvest|reject|follow-up
+      "rationale": "string",
+      "followUpCost": "mechanical",          // optional; none|mechanical|localized|moderate|structural|unknown
+      "winnerCriterionGap": {                 // required; null when this is only an enhancement or unrelated advantage
+        "variant": "string",                 // exact selected winner variant ID
+        "criterionId": "CR-001"              // exact Required Criteria ID the advantage is needed to satisfy
+      }
+    }
+  ],
+  "calibrationStatus": "experimental",       // literal string for now
+  "winnerStatus": "accepted",                // accepted|conditional|inconclusive; your verdict, not host-derived
+  "winnerCaveats": ["string"]                // concrete reasons for conditional/inconclusive; [] when accepted
+}
+
+IMPORTANT: Do NOT include any text outside the JSON object. Do NOT call any tool or planning function.`;
+}
+export {
+  buildMatrixJudgePrompt
+};
+//# sourceMappingURL=matrix-prompt-builder-4ZBOGZSB.js.map

package/dist/matrix-result-parser-EZJM4YXP.js

@@ -0,0 +1,14 @@
+import {
+  isAcceptedMatrixVerdict,
+  parseMatrixResult,
+  resolveVariantRef
+} from "./chunk-6PZY2TTU.js";
+import "./chunk-LPQ7NZEN.js";
+import "./chunk-TGCVL74Y.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  isAcceptedMatrixVerdict,
+  parseMatrixResult,
+  resolveVariantRef
+};
+//# sourceMappingURL=matrix-result-parser-EZJM4YXP.js.map