@besales/ops-framework 0.1.29 → 0.1.30

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.30
+
+- Added a generic `golden-set-regression` risk trigger for golden sets, eval fixtures, label cards, ground-truth datasets and regression checklists.
+- Added shared `golden-set-regression` playbook and deterministic plan gate requiring label-card schema, coverage matrix, negative/edge cases and harness boundary.
+- Added Verify evidence checks for golden-set/regression work so execution must prove label cards, coverage, edge cases, expected outputs/non-goals, source refs and manual-vs-automated boundary.
+
 ## 0.1.29
 
 - Added `precheck-remediation.md` for deterministic Check blocks so all missing plan gates are consolidated into one checklist before another external Check.

package/bin/lib/check-context-utils.mjs

@@ -46,7 +46,7 @@ export const RISK_CONFIG = {
 };
 
 export const ALLOWED_RISK_PROFILES = Object.keys(RISK_CONFIG);
-export const ALLOWED_RISK_TRIGGERS = ['auth-security', 'docs-only', 'dto-readmodel', 'ingestion-provider', 'materializer', 'panel-ui', 'prisma-schema', 'production-runtime', 'source-sync-provider', 'ui-visible-api', 'worker-queue'];
+export const ALLOWED_RISK_TRIGGERS = ['auth-security', 'docs-only', 'dto-readmodel', 'golden-set-regression', 'ingestion-provider', 'materializer', 'panel-ui', 'prisma-schema', 'production-runtime', 'source-sync-provider', 'ui-visible-api', 'worker-queue'];
 
 export const CHECKER_CONTEXT_PACK_FILE = 'checker-context-pack.md';
 export const PLAYBOOK_TRIGGER_MAP = new Map([
@@ -60,6 +60,7 @@ export const PLAYBOOK_TRIGGER_MAP = new Map([
   ['worker-queue', ['complexity-performance']],
   ['materializer', ['complexity-performance']],
   ['dto-readmodel', ['complexity-performance']],
+  ['golden-set-regression', ['golden-set-regression']],
 ]);
 
 export const ALLOWED_VERDICTS = ['return_to_plan', 'ready_for_human_gate', 'human_arbitration_required', 'context_insufficient', 'checker_failed'];
@@ -663,6 +664,9 @@ export function classifyRisk({ structuralLines, referencedFiles, planSections, r
   if (hasText(/\b(dto|validation|read model|payload shape|contract)\b/)) {
     triggers.add('dto-readmodel');
   }
+  if (hasText(/\b(golden set|golden-set|golden dataset|eval|evals|evaluation|regression checklist|regression fixture|regression fixtures|fixture labels?|label cards?|ground truth|expected outputs?)\b/)) {
+    triggers.add('golden-set-regression');
+  }
 
   if (triggers.size === 0 && isDocsOnly(referencedFiles, planSections)) {
     triggers.add('docs-only');
@@ -768,6 +772,7 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
   const optimizationRequired = requiresOptimizationStrategy(optimizationTier);
   const productionRolloutRequired = requiresProductionRolloutGate(risk.riskTriggers);
   const sourceSyncProviderRequired = requiresSourceSyncProviderGate(risk.riskTriggers);
+  const goldenSetRequired = requiresGoldenSetRegressionGate(risk.riskTriggers);
   const executionMetadata = inspectExecutionMetadata(sections);
   const verificationLadder = inspectVerificationLadder(sections);
   const standardsAlignmentRequired = requiresStandardsAlignment({ referencedFiles, structuralLines });
@@ -780,6 +785,7 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
   const productionRollout = inspectProductionRolloutGate(sections);
   const sourceSyncProvider = inspectSourceSyncProviderGate(sections);
   const importIngestion = inspectImportIngestionGate(sections, planContent);
+  const goldenSetRegression = inspectGoldenSetRegressionGate(sections, planContent);
   const missingSignals = [];
 
   if (!executionMetadata.present) {
@@ -821,6 +827,9 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
   if (sourceSyncProviderRequired && importIngestion.required && !importIngestion.present) {
     missingSignals.push('Import/ingestion plan must include an Import / Ingestion Contract naming representative real fixtures or an explicit no-real-fixtures reason, raw metadata/speaker-label extraction, and duplicate-import policy.');
   }
+  if (goldenSetRequired && !goldenSetRegression.present) {
+    missingSignals.push('Golden set/eval fixture work must include `## Label Card Schema`, `## Coverage Matrix`, `## Negative / Edge Cases`, and `## Harness Boundary` so examples become a test contract, not just a list.');
+  }
 
   return {
     executionMetadata,
@@ -841,6 +850,8 @@ export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [
     sourceSyncProviderRequired,
     sourceSyncProvider,
     importIngestion,
+    goldenSetRequired,
+    goldenSetRegression,
     missingSignals,
   };
 }
@@ -1070,6 +1081,10 @@ export function requiresSourceSyncProviderGate(riskTriggers = []) {
   return riskTriggers.includes('ingestion-provider') || riskTriggers.includes('source-sync-provider');
 }
 
+export function requiresGoldenSetRegressionGate(riskTriggers = []) {
+  return riskTriggers.includes('golden-set-regression');
+}
+
 export function inspectUiAcceptanceScenarios(sections) {
   const body = readCanonicalSection(sections, ['ui acceptance scenarios', 'ui acceptance', 'ui scenarios']);
   if (!body) {
@@ -1102,6 +1117,63 @@ export function inspectUiAcceptanceScenarios(sections) {
   return result;
 }
 
+export function inspectGoldenSetRegressionGate(sections) {
+  const labelSchema = readCanonicalSection(sections, [
+    'label card schema',
+    'label schema',
+    'golden set label schema',
+    'fixture label schema',
+  ]);
+  const coverageMatrix = readCanonicalSection(sections, [
+    'coverage matrix',
+    'golden set coverage matrix',
+    'eval coverage matrix',
+    'fixture coverage matrix',
+  ]);
+  const negativeEdgeCases = readCanonicalSection(sections, [
+    'negative / edge cases',
+    'negative and edge cases',
+    'negative cases',
+    'edge cases',
+    'known edge cases',
+  ]);
+  const harnessBoundary = readCanonicalSection(sections, [
+    'harness boundary',
+    'automation boundary',
+    'regression harness boundary',
+    'manual vs automated boundary',
+  ]);
+
+  const combined = [labelSchema, coverageMatrix, negativeEdgeCases, harnessBoundary].join('\n').toLowerCase();
+  const result = {
+    present: false,
+    hasLabelCardSchema: Boolean(labelSchema),
+    hasExpectedOutputs: /expected output|expected result|expectation|ground truth|acceptance|ожидаем|результат/.test(labelSchema.toLowerCase()),
+    hasNonGoals: /non-?goal|ignored|deferred|out of scope|not applied|не\s+дела|игнор|отлож/.test(labelSchema.toLowerCase()),
+    hasSourceEvidence: /source|quote|snippet|evidence|reference|ref|path|цитат|источник|сниппет/.test(labelSchema.toLowerCase()),
+    hasCoverageMatrix: Boolean(coverageMatrix),
+    hasCoverageDimensions: /track|profile|scenario|behavior|dimension|case|category|matrix|coverage|профил|сценари|покрыт|категор/.test(coverageMatrix.toLowerCase()),
+    hasNegativeEdgeCases: Boolean(negativeEdgeCases),
+    hasNegativeExpectation: /negative|edge|missing|unavailable|single|ambiguous|conflict|false positive|should not|must not|негатив|краев|отсутств|неоднознач/.test(negativeEdgeCases.toLowerCase()),
+    hasHarnessBoundary: Boolean(harnessBoundary),
+    hasManualVsAutomatedBoundary: /manual|automated|runner|harness|ci|checklist|later|future|not yet|ручн|автомат|позже|сейчас/.test(harnessBoundary.toLowerCase()),
+    hasMissingCoveragePolicy: /missing|unavailable|gap|deferred|not found|known missing|отсутств|недоступ|пробел|отлож/.test(combined),
+  };
+  result.complete = result.hasLabelCardSchema
+    && result.hasExpectedOutputs
+    && result.hasNonGoals
+    && result.hasSourceEvidence
+    && result.hasCoverageMatrix
+    && result.hasCoverageDimensions
+    && result.hasNegativeEdgeCases
+    && result.hasNegativeExpectation
+    && result.hasHarnessBoundary
+    && result.hasManualVsAutomatedBoundary
+    && result.hasMissingCoveragePolicy;
+  result.present = result.complete;
+  return result;
+}
+
 export function inspectComplexityPerformanceBudget(sections) {
   const body = readCanonicalSection(sections, [
     'complexity / performance budget',
@@ -1407,6 +1479,17 @@ export function buildCheckerContextPack({
         ].join('\n')
       : '- Source sync/provider gate is not required by detected triggers.',
     '',
+    '## Golden Set / Regression Expectations',
+    '',
+    qualityGates.goldenSetRequired
+      ? [
+          '- Golden set/eval/regression fixture risk detected.',
+          `- Golden Set / Regression Gate complete: \`${qualityGates.goldenSetRegression.present ? 'yes' : 'no'}\`.`,
+          '- Checker must return `return_to_plan` if the plan lacks label-card schema, coverage matrix, negative/edge cases, harness boundary, missing coverage policy or source evidence rules.',
+          '- A golden set is a reusable test contract, not merely a list of examples to process.',
+        ].join('\n')
+      : '- Golden set/regression fixture gate is not required by detected triggers.',
+    '',
     '## Relevant Playbooks',
     '',
     renderRelevantPlaybookIndex(relevantPlaybooks),
@@ -1634,6 +1717,27 @@ export function validateExecutionEvidenceForPlan({ planContent, executionContent
     }
   }
 
+  if (hasAnySection(planSections, ['label card schema', 'label schema', 'coverage matrix', 'negative / edge cases', 'harness boundary'])) {
+    const evidence = readAnySection(executionSections, [
+      'golden set / regression evidence',
+      'golden set evidence',
+      'regression fixture evidence',
+      'label evidence',
+      'fixture evidence',
+    ]);
+    if (!evidence) {
+      errors.push({
+        category: 'missing_evidence',
+        message: 'Plan contains Golden Set / Regression Gate but execution.md is missing Golden Set / Regression Evidence.',
+      });
+    } else if (!/(label card|label schema|coverage matrix|negative|edge case|harness|runner|manual|automated|expected output|non-?goal|source|quote|snippet|missing coverage)/i.test(evidence)) {
+      errors.push({
+        category: 'insufficient_evidence',
+        message: 'Golden Set / Regression Evidence must show label cards, coverage matrix, negative/edge cases, harness boundary, expected outputs/non-goals and source refs.',
+      });
+    }
+  }
+
   return errors;
 }
 
@@ -1685,6 +1789,9 @@ function buildCheckerQuestions({ risk, qualityGates }) {
   if (qualityGates.importIngestion?.required) {
     questions.push('Does the import plan use representative real fixtures when available, extract raw metadata needed downstream, and define exact duplicate-import behavior?');
   }
+  if (qualityGates.goldenSetRequired) {
+    questions.push('Does the golden set define a reusable test contract with label-card schema, coverage matrix, negative/edge cases, source refs and explicit manual-vs-automated harness boundary?');
+  }
   return questions;
 }
 

package/bin/lib/check-context-utils.test.mjs

@@ -14,6 +14,7 @@ import {
   selectRelevantPlaybookNames,
   inspectComplexityPerformanceBudget,
   inspectExecutionMetadata,
+  inspectGoldenSetRegressionGate,
   inspectAuditWriterModel,
   inspectMigrationApplyPlan,
   inspectOptimizationStrategy,
@@ -24,6 +25,7 @@ import {
   inspectVerificationLadder,
   parseMarkdownSections,
   requiresOptimizationStrategy,
+  requiresGoldenSetRegressionGate,
   requiresStandardsAlignment,
   validateExecutionEvidenceForPlan,
 } from './check-context-utils.mjs';
@@ -833,4 +835,120 @@ describe('agent pipeline quality gates', () => {
     expect(result.importIngestion.present).toBe(true);
     expect(result.missingSignals.some((signal) => signal.includes('Import/ingestion plan must include'))).toBe(false);
   });
+
+  it('detects golden set regression work and requires a test-contract gate', () => {
+    const risk = classifyRisk({
+      structuralLines: [
+        '- Create golden set label cards and regression checklist for process quality.',
+      ],
+      referencedFiles: [],
+      planSections: new Map(),
+    });
+
+    expect(risk.riskTriggers).toContain('golden-set-regression');
+    expect(requiresGoldenSetRegressionGate(risk.riskTriggers)).toBe(true);
+    expect(selectRelevantPlaybookNames(risk.riskTriggers)).toContain('golden-set-regression');
+
+    const result = analyzePlanQualityGates({
+      planContent: [
+        '# Plan',
+        '',
+        '## Implementation Steps',
+        '',
+        '- Select golden set examples with expected outputs and non-goals.',
+      ].join('\n'),
+      risk,
+    });
+
+    expect(result.goldenSetRequired).toBe(true);
+    expect(result.goldenSetRegression.present).toBe(false);
+    expect(result.missingSignals).toContain('Golden set/eval fixture work must include `## Label Card Schema`, `## Coverage Matrix`, `## Negative / Edge Cases`, and `## Harness Boundary` so examples become a test contract, not just a list.');
+  });
+
+  it('accepts golden set regression gate with schema, coverage, edge cases and harness boundary', () => {
+    const plan = [
+      '# Plan',
+      '',
+      '## Label Card Schema',
+      '',
+      '- Source path / source id and short quote snippet are required.',
+      '- Expected outputs and acceptance expectations are required.',
+      '- Non-goals / ignored or deferred outputs are required.',
+      '- Confidence and risk notes are recorded when uncertain.',
+      '',
+      '## Coverage Matrix',
+      '',
+      '- Coverage dimensions: track, profile, scenario category and source format.',
+      '- Missing coverage / unavailable fixtures are recorded as gaps.',
+      '',
+      '## Negative / Edge Cases',
+      '',
+      '- Negative examples and edge cases must catch false positives and ambiguous input.',
+      '- Missing edge cases are recorded instead of fabricated.',
+      '',
+      '## Harness Boundary',
+      '',
+      '- Manual labels are created now; automated runner/CI harness comes later.',
+    ].join('\n');
+    const sections = parseMarkdownSections(plan);
+    const inspected = inspectGoldenSetRegressionGate(sections);
+    const result = analyzePlanQualityGates({
+      planContent: plan,
+      risk: {
+        riskProfile: 'medium',
+        riskTriggers: ['golden-set-regression'],
+      },
+    });
+
+    expect(inspected.present).toBe(true);
+    expect(result.goldenSetRegression.present).toBe(true);
+    expect(result.missingSignals.some((signal) => signal.includes('Golden set/eval fixture work'))).toBe(false);
+  });
+
+  it('requires golden set regression execution evidence when the plan declares label gates', () => {
+    const plan = [
+      '# Plan',
+      '',
+      '## Label Card Schema',
+      '',
+      '- Source path and source quote snippet.',
+      '- Expected outputs and non-goals.',
+      '',
+      '## Coverage Matrix',
+      '',
+      '- Coverage dimensions and missing coverage gaps.',
+      '',
+      '## Negative / Edge Cases',
+      '',
+      '- Negative cases and edge case behavior.',
+      '',
+      '## Harness Boundary',
+      '',
+      '- Manual labels now, automated runner later.',
+    ].join('\n');
+
+    const missing = validateExecutionEvidenceForPlan({
+      planContent: plan,
+      executionContent: '# Execution\n\nNo golden set evidence yet.',
+    });
+    expect(missing).toContainEqual({
+      category: 'missing_evidence',
+      message: 'Plan contains Golden Set / Regression Gate but execution.md is missing Golden Set / Regression Evidence.',
+    });
+
+    const ok = validateExecutionEvidenceForPlan({
+      planContent: plan,
+      executionContent: [
+        '# Execution',
+        '',
+        '## Golden Set / Regression Evidence',
+        '',
+        '- Label cards follow the label schema and include expected output, non-goals, source refs and short quote snippets.',
+        '- Coverage matrix filled; missing coverage recorded.',
+        '- Negative / edge case examples documented.',
+        '- Harness boundary: manual checklist now, automated runner later.',
+      ].join('\n'),
+    });
+    expect(ok.some((issue) => issue.message.includes('Golden Set / Regression'))).toBe(false);
+  });
 });

package/bin/lib/task-manifest-utils.mjs

@@ -84,6 +84,12 @@ export function buildTaskManifest({ taskDir, now = new Date().toISOString(), exi
         evidenceRequired: hasPlanGate(inputs.taskArtifacts.get('plan.md'), ['import / ingestion contract', 'import ingestion contract', 'ingestion contract', 'import contract']),
         evidenceComplete: !evidenceIssues.some((issue) => issue.message.includes('Import / Ingestion')),
       },
+      goldenSetRegression: {
+        required: Boolean(inputs.qualityGates.goldenSetRequired),
+        planComplete: Boolean(inputs.qualityGates.goldenSetRegression?.present),
+        evidenceRequired: hasPlanGate(inputs.taskArtifacts.get('plan.md'), ['label card schema', 'label schema', 'coverage matrix', 'negative / edge cases', 'harness boundary']),
+        evidenceComplete: !evidenceIssues.some((issue) => issue.message.includes('Golden Set / Regression Evidence')),
+      },
     },
     context: {
       planSha: inputs.planFingerprint.planSha,

package/bin/quality-gates.mjs

@@ -38,6 +38,8 @@ function main() {
         productionRolloutComplete: inputs.qualityGates.productionRollout.present,
         sourceSyncProviderRequired: inputs.qualityGates.sourceSyncProviderRequired,
         sourceSyncProviderComplete: inputs.qualityGates.sourceSyncProvider.present,
+        goldenSetRequired: inputs.qualityGates.goldenSetRequired,
+        goldenSetComplete: inputs.qualityGates.goldenSetRegression.present,
         missingSignals: inputs.qualityGates.missingSignals,
       },
       executionEvidence: {
@@ -67,6 +69,7 @@ function printHuman(result) {
   console.log(`- Optimization strategy: ${result.planQuality.optimizationRequired ? `${result.planQuality.optimizationTier} required / ${result.planQuality.optimizationStrategyComplete ? 'complete' : 'missing'}` : `${result.planQuality.optimizationTier || 'O0'} / not required`}`);
   console.log(`- Production rollout: ${result.planQuality.productionRolloutRequired ? result.planQuality.productionRolloutComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
   console.log(`- Source sync/provider: ${result.planQuality.sourceSyncProviderRequired ? result.planQuality.sourceSyncProviderComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
+  console.log(`- Golden set/regression: ${result.planQuality.goldenSetRequired ? result.planQuality.goldenSetComplete ? 'required / complete' : 'required / missing' : 'not required'}`);
   if (result.planQuality.missingSignals.length > 0) {
     console.log('Plan quality issues:');
     for (const issue of result.planQuality.missingSignals) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besales/ops-framework",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"

package/playbooks/golden-set-regression.md

@@ -0,0 +1,58 @@
+# Golden Set / Regression Fixture Playbook
+
+Use this when a task creates or changes golden sets, eval fixtures, label cards,
+ground-truth examples, regression checklists or expected-output datasets.
+
+Golden sets are test contracts, not just lists of examples.
+
+## Required Plan Sections
+
+- `## Label Card Schema`
+- `## Coverage Matrix`
+- `## Negative / Edge Cases`
+- `## Harness Boundary`
+
+## Label Card Schema
+
+Each label card must define:
+
+- stable fixture/source id and source reference;
+- expected outputs or expected behavior;
+- non-goals, ignored outputs or deferred outputs;
+- source evidence rules, such as short quotes/snippets/refs and privacy limits;
+- confidence/risk notes when labels are uncertain.
+
+## Coverage Matrix
+
+The plan must name coverage dimensions that matter for this product area.
+Examples include profiles, tracks, event types, user journeys, data qualities,
+known edge behaviors, or source formats.
+
+For every important dimension, record one of:
+
+- selected fixture/example;
+- explicitly missing/unavailable;
+- intentionally deferred with reason.
+
+## Negative / Edge Cases
+
+Include negative or edge cases that protect against false positives and
+over-application. If no negative case exists in the current fixture pool, record
+the missing case as a coverage gap instead of fabricating it.
+
+## Harness Boundary
+
+State whether the task is creating manual labels/fixtures only or an automated
+runner/CI harness. Do not claim automated regression coverage when only manual
+label artifacts exist.
+
+## Verify Expectations
+
+Execution evidence must show:
+
+- label cards were created according to schema;
+- coverage matrix was filled;
+- negative/edge cases were selected or documented as missing;
+- expected outputs and non-goals are inspectable;
+- source refs/snippets respect privacy boundaries;
+- manual-vs-automated harness boundary is explicit.

package/prompts/checker.md

@@ -72,6 +72,7 @@ Project-specific context приходит только через task artifacts
 24. Если `llmInputPolicy.mode` не `strict` и отсутствующий full artifact реально нужен для честной оценки, verdict должен быть `context_insufficient`. Не используй `context_insufficient`, если deterministic gate уже явно показывает `return_to_plan`.
 25. Если в task artifacts есть `precheck-remediation.md`, Checker должен проверить, что весь checklist был закрыт одним consolidated plan update. Не создавай новый мелкий blocker по одному пункту из старого checklist, если оставшиеся пункты тоже очевидно не закрыты: верни consolidated finding, ссылающийся на `precheck-remediation.md`.
 26. Minor process/evidence polish не должен блокировать Human Gate, если deterministic gates закрыты, acceptance criteria покрыты, scope/risk/security/data correctness не нарушены, а остаток можно безопасно записать как `non_blocking` или human question.
+27. Если plan/task/checker-context показывает golden set/eval/regression fixtures/label cards/ground truth, Checker должен требовать `## Label Card Schema`, `## Coverage Matrix`, `## Negative / Edge Cases` и `## Harness Boundary`. Golden set без schema/coverage/negative cases/source evidence/non-goals/manual-vs-automated boundary является `return_to_plan`, даже если есть общий текст про expected outputs.
 
 ## Контракт выхода
 
@@ -97,6 +98,7 @@ Project-specific context приходит только через task artifacts
 - проверка Optimization Strategy;
 - проверка Production Rollout Gate;
 - проверка Source Sync / Provider Gate;
+- проверка Golden Set / Regression Gate;
 - проверка Loop Detector / consolidated remediation;
 - достаточность compact context или `context_insufficient`;
 - рекомендация supervisor: `return_to_plan` или `ready_for_human_gate`.

package/prompts/planner.md

@@ -55,6 +55,7 @@
 19. План проверки должен быть ladder-based: micro-verify during Execute, slice-verify before completion and external Verify requirement for closeout/high-risk claims.
 20. План должен описывать meaningful slice. Не дроби локальную работу на отдельный Plan/Check/Verify для каждого микрофикса, если риски и target остаются внутри одного approved tier.
 21. Если risk triggers или `checker-context-pack.md` показывают O2/O3 hot-path work, Planner обязан добавить `## Optimization Strategy`: tier, hot paths, expected data size, chosen efficient approach, anti-patterns avoided and bounded optimizer budget/stop rule. Цель gate — предотвратить очевидно неэффективное решение до Execute, а не запускать бесконечную оптимизацию.
+22. Если задача создает golden set/eval/regression fixtures/label cards/ground truth, Planner обязан добавить `## Label Card Schema`, `## Coverage Matrix`, `## Negative / Edge Cases` и `## Harness Boundary`. Golden set должен быть test contract with expected outputs, non-goals, source refs, missing coverage policy and manual-vs-automated boundary.
 
 ## Check Resolution Contract
 
@@ -122,6 +123,7 @@ Allowed `evidenceRefs[].type` and `artifactChangeRefs[].type`:
 - verification ladder;
 - UI verification path или явное `not applicable`;
 - Optimization Strategy для O2/O3 или явное `not applicable`;
+- Label Card Schema / Coverage Matrix / Negative Edge Cases / Harness Boundary для golden set/eval fixture задач;
 - global standards alignment;
 - что требует human approval.
 

package/prompts/verifier.md

@@ -46,6 +46,7 @@
 22. Если `llmInputPolicy.mode` не `strict` и отсутствующий full artifact реально нужен для честной оценки, verdict должен быть `context_insufficient`. Не используй `context_insufficient`, если execution evidence уже явно отсутствует или противоречит plan.
 23. Если task содержит `precheck-remediation.md`, verifier должен проверить только применимые пункты, которые дошли до Execute. Не возвращай `return_to_execute` из-за старого precheck checklist, если план закрыл его до Human Gate и фактическая реализация покрывает acceptance.
 24. Environment/tooling failures внешнего verifier/browser smoke не должны превращаться в бесконечный `return_to_execute` loop. Если implementation evidence достаточно, но внешний инструмент заблокирован окружением, используй `pass_with_notes` или `human_arbitration_required` согласно риску.
+25. Если `plan.md` содержит golden set/eval/regression fixture sections, verifier должен проверить `Golden Set / Regression Evidence`: label cards follow schema, coverage matrix is filled, negative/edge cases are selected or documented missing, expected outputs/non-goals are inspectable, source refs/snippets exist and manual-vs-automated harness boundary is explicit.
 
 ## Контракт выхода
 
@@ -61,6 +62,7 @@
 - Optimization Review Evidence, если `plan.md` содержит O2/O3 `Optimization Strategy`;
 - Production Rollout Gate evidence, если он есть в `plan.md`;
 - Source Sync / Provider Gate evidence, если он есть в `plan.md`;
+- Golden Set / Regression Evidence, если plan создает golden set/eval fixtures/label cards;
 - Loop Detector / consolidated remediation status;
 - достаточность compact context или `context_insufficient`;
 - findings;