@besales/ops-framework 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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.
+- Included precheck remediation artifacts in Checker and Verifier LLM input packs.
+- Updated Checker/Verifier/Supervisor rules to avoid one-item precheck loops and route minor/tooling issues to notes or human decision when acceptance is covered.
+
 ## 0.1.28
 
 - Added Verify reuse guard: a passing `verify.result.json` is reused when `plan.md` and `execution.md` hashes are unchanged, unless `--force` is passed.

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/llm-input-pack-utils.mjs

@@ -199,12 +199,13 @@ export function buildCheckerLlmInputPack({
 }) {
   const selectedMode = normalizeLlmContextMode(mode) || 'standard';
   const artifacts = selectedMode === 'strict'
-    ? readArtifacts(taskDir, ['brief.md', 'research.md', 'plan.md', 'status.md', 'feedback.md', 'execution-feedback.md'], 'full')
+    ? readArtifacts(taskDir, ['brief.md', 'research.md', 'plan.md', 'status.md', 'precheck-remediation.md', 'feedback.md', 'execution-feedback.md'], 'full')
     : {
         'brief.md': compactArtifact(taskDir, 'brief.md', selectedMode, ['goal', 'scope', 'success criteria']),
         'research.md': compactArtifact(taskDir, 'research.md', selectedMode, ['findings', 'evidence', 'repo', 'architecture', 'standards']),
         'plan.md': compactArtifact(taskDir, 'plan.md', selectedMode, CHECK_RELEVANT_SECTIONS),
         'status.md': compactStatus(readTaskFile(taskDir, 'status.md')),
+        'precheck-remediation.md': compactArtifact(taskDir, 'precheck-remediation.md', selectedMode, ['checklist', 'rerun rule', 'purpose']),
         'feedback.md': compactArtifact(taskDir, 'feedback.md', selectedMode, ['feedback event', 'classification', 'supervisor decision']),
       };
 
@@ -325,6 +326,7 @@ export function buildVerifierLlmInputPack({
           checkResult: readOptionalJson(taskDir, 'check.result.json'),
           mode: 'standard',
         }),
+        'precheck-remediation.md': compactArtifact(taskDir, 'precheck-remediation.md', 'standard', ['checklist', 'rerun rule', 'purpose']),
         'check-resolution.md': compactArtifact(taskDir, 'check-resolution.md', 'standard', ['structured resolution', 'root cause', 'resolution']),
         'human-gate-summary.md': truncateMiddle(readTaskFile(taskDir, 'human-gate-summary.md'), 3500),
         'execution.md': readTaskFile(taskDir, 'execution.md'),
@@ -346,6 +348,7 @@ export function buildVerifierLlmInputPack({
           checkResult: readOptionalJson(taskDir, 'check.result.json'),
           mode: selectedMode,
         }),
+        'precheck-remediation.md': compactArtifact(taskDir, 'precheck-remediation.md', selectedMode, ['checklist', 'rerun rule', 'purpose']),
         'check-resolution.md': truncateMiddle(readTaskFile(taskDir, 'check-resolution.md'), charLimitForMode(selectedMode, 1500, 3500)),
         'human-gate-summary.md': truncateMiddle(readTaskFile(taskDir, 'human-gate-summary.md'), charLimitForMode(selectedMode, 1200, 2500)),
         'execution.md': compactArtifact(taskDir, 'execution.md', selectedMode, VERIFY_EXECUTION_SECTIONS),

package/bin/lib/llm-input-pack-utils.test.mjs

@@ -118,6 +118,42 @@ describe('llm input pack utilities', () => {
     expect(pack.meta.compactedArtifacts).toContain('plan.md');
   });
 
+  it('includes precheck remediation in checker packs when present', () => {
+    const taskDir = createTask();
+    write(taskDir, 'precheck-remediation.md', [
+      '# Precheck Remediation',
+      '',
+      '## Checklist',
+      '',
+      '- [ ] P-001: Optimization Strategy is missing.',
+      '',
+      '## Rerun Rule',
+      '',
+      '- Rerun Check only after every checklist item is addressed.',
+    ].join('\n'));
+
+    const pack = buildCheckerLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      checkerPromptSha: 'sha256:test',
+      cacheKey: { test: true },
+      checkContext: {
+        planSha: 'sha256:plan',
+        memorySha: 'sha256:memory',
+        riskProfile: 'high',
+        riskTriggers: ['source-sync-provider'],
+      },
+      checkEvidence: '# Evidence\n\nok',
+      checkerContextPack: '# Checker Context Pack\n\nok',
+      taskManifest: '{}',
+      projectMemory: [],
+      mode: 'standard',
+    });
+
+    expect(pack.input.taskArtifacts['precheck-remediation.md']).toContain('Optimization Strategy is missing.');
+    expect(pack.input.taskArtifacts['precheck-remediation.md']).toContain('Rerun Check only after every checklist item is addressed.');
+  });
+
   it('stabilizes checker task manifest by excluding volatile check telemetry', () => {
     const taskDir = createTask();
     const pack = buildCheckerLlmInputPack({
@@ -274,6 +310,28 @@ describe('llm input pack utilities', () => {
     expect(pack.input.taskArtifacts['check.md']).toContain('Human question should remain visible.');
   });
 
+  it('includes precheck remediation in verifier packs when present', () => {
+    const taskDir = createTask();
+    write(taskDir, 'precheck-remediation.md', [
+      '# Precheck Remediation',
+      '',
+      '## Checklist',
+      '',
+      '- [ ] P-001: Source Sync / Provider Gate is missing.',
+    ].join('\n'));
+
+    const pack = buildVerifierLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      planSha: 'sha256:plan',
+      executionSha: 'sha256:execution',
+      verifier: { provider: 'test', model: 'test', reasoningEffort: 'none', runId: 'run' },
+      mode: 'standard',
+    });
+
+    expect(pack.input.taskArtifacts['precheck-remediation.md']).toContain('Source Sync / Provider Gate is missing.');
+  });
+
   it('uses a conservative estimate for Cyrillic and JSON-heavy payloads', () => {
     const value = JSON.stringify({
       text: 'Проверка русскоязычного JSON payload с большим количеством кавычек и структурных символов.',

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/bin/run-check.mjs

@@ -462,6 +462,12 @@ function writeDeterministicPrecheckReturn({
     readyForHumanGate: false,
     createdAt: new Date().toISOString(),
   };
+  const remediation = buildPrecheckRemediation({
+    taskId,
+    checkContext,
+    issues,
+    startedAt,
+  });
   const markdown = [
     '# Check',
     '',
@@ -471,6 +477,10 @@ function writeDeterministicPrecheckReturn({
     '',
     'External checker was not invoked because machine-readable plan/context gates already found blocking issues.',
     '',
+    '## Consolidated remediation',
+    '',
+    'Before rerunning Check, close the full checklist in `precheck-remediation.md`. Do not fix one item and immediately rerun Check while other listed items remain open.',
+    '',
     '## structured findings',
     '',
     '| ID | Severity | Category | Claim | Expected correction |',
@@ -488,15 +498,16 @@ function writeDeterministicPrecheckReturn({
 
   writeTaskFile(taskDir, 'check.md', markdown);
   writeTaskFile(taskDir, 'check.result.json', JSON.stringify(result, null, 2));
+  writeTaskFile(taskDir, 'precheck-remediation.md', remediation.markdown);
   updateStatus(taskDir, {
     checkVerdict: '`return_to_plan`',
     checkResult: '- `check.result.json`: current',
     supervisorAction: 'Deterministic Check preflight blocked external checker invocation.',
-    nextStep: 'Fix deterministic Check findings, then rerun Check.',
+    nextStep: 'Close every item in `precheck-remediation.md`, update plan/research/status once, then rerun Check.',
     humanApproval: 'no',
   });
   ensureFreshCheckContext(taskDir, taskId);
-  appendOrchestrationLog(taskDir, `deterministic Check preflight returned return_to_plan; findings=${findings.length}; external checker skipped`);
+  appendOrchestrationLog(taskDir, `deterministic Check preflight returned return_to_plan; findings=${findings.length}; remediation=${remediation.issueSetSha}; external checker skipped`);
 }
 
 function expectedCorrectionForPrecheckIssue(issue) {
@@ -509,6 +520,73 @@ function expectedCorrectionForPrecheckIssue(issue) {
   return 'Fix task-manifest/check-context consistency before external Check.';
 }
 
+function buildPrecheckRemediation({
+  taskId,
+  checkContext,
+  issues,
+  startedAt,
+}) {
+  const issueSetSha = sha256Json(issues.map((issue) => ({
+    category: issue.category,
+    message: issue.message,
+  })));
+  const grouped = groupIssuesByCategory(issues);
+  const lines = [
+    '# Precheck Remediation',
+    '',
+    `Task: \`${taskId}\``,
+    `Issue set: \`${issueSetSha}\``,
+    `Plan SHA: \`${checkContext.planSha}\``,
+    `Memory SHA: \`${checkContext.memorySha}\``,
+    `Created at: \`${new Date().toISOString()}\``,
+    `Precheck duration: \`${buildTiming(startedAt).durationMs}ms\``,
+    '',
+    '## Purpose',
+    '',
+    'This artifact consolidates deterministic Check blockers so the plan can be fixed in one focused pass before another external Check.',
+    '',
+    'Do not rerun external Check while any checklist item below is still open. Update `plan.md`, `research.md`, or `status.md` once, then rerun Check after the whole set is addressed.',
+    '',
+    '## Checklist',
+    '',
+  ];
+
+  let index = 1;
+  for (const [category, categoryIssues] of grouped.entries()) {
+    lines.push(`### ${category}`);
+    lines.push('');
+    for (const issue of categoryIssues) {
+      lines.push(`- [ ] P-${String(index).padStart(3, '0')}: ${issue.message}`);
+      lines.push(`  - Expected correction: ${expectedCorrectionForPrecheckIssue(issue)}`);
+      index += 1;
+    }
+    lines.push('');
+  }
+
+  lines.push('## Rerun Rule');
+  lines.push('');
+  lines.push('- Rerun Check only after every checklist item is addressed or explicitly rejected with evidence/human decision.');
+  lines.push('- If the same issue set appears again, consolidate the remaining fixes instead of starting another one-item loop.');
+  lines.push('- If a listed item is not applicable, record the reason in `plan.md` or `status.md` before rerunning Check.');
+  lines.push('');
+
+  return {
+    issueSetSha,
+    markdown: lines.join('\n'),
+  };
+}
+
+function groupIssuesByCategory(issues) {
+  const grouped = new Map();
+  for (const issue of issues) {
+    const category = issue.category || 'unknown';
+    const existing = grouped.get(category) || [];
+    existing.push(issue);
+    grouped.set(category, existing);
+  }
+  return grouped;
+}
+
 function escapeTableCell(value) {
   return String(value || '').replace(/\|/g, '\\|').replace(/\n/g, ' ').trim();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besales/ops-framework",
-  "version": "0.1.28",
+  "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

@@ -70,6 +70,9 @@ Project-specific context приходит только через task artifacts
 22. Если `checker-context-pack.md`, `task-manifest.json` или risk triggers показывают sync/import/provider/raw records/retries/pagination/rate limits/idempotency/replay/backfill/partial failure, план обязан содержать `## Source Sync / Provider Gate`: scope/provider window, idempotency with dedupe key and duplicate action, failure handling/retry boundaries and coverage/parity evidence. Для import/manual-upload/transcript/evidence-capture задач план также обязан содержать `## Import / Ingestion Contract`: real representative fixtures when available or explicit no-real-fixtures reason, raw metadata/speaker-label extraction needed downstream, and repeat-import policy. Размытое "duplicates detected or reported" без skip/link/update/reject/report-only semantics недостаточно.
 23. Если `task-manifest.json.loopDetector.requiresConsolidatedRemediation=true`, Checker должен блокировать повторный мелкий loop, пока plan/check-resolution не содержит consolidated remediation секцию, которая объединяет repeated reasons.
 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.
 
 ## Контракт выхода
 
@@ -95,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/supervisor.md

@@ -59,6 +59,8 @@ Supervisor является code-level orchestrator по контракту: rou
 25. `verify.result.json` должен сверять `plan.md` с фактическим `execution.md`, diff/files/tests и явным execution evidence. Self-reported executor checks без verifier verdict не являются достаточным Verify.
 26. `verify.result.json.verdict = pass | pass_with_notes` допустим при `verificationMode = internal_supervisor` для обычных `R0-R3` local engineering slices. Это cost-saving режим без независимого CLI/model verifier и он является default, если shared defaults или project agents override задают `verifier.mode = internal_supervisor`. `external_cli` обязателен только для R4/R5, production-readiness, destructive/security/financial/broad operational actions, production or real-user-data Prisma/data migrations/backfills, broad ambiguous refactors или explicit human request. Local scratch DB migrations, fixture imports and bounded local-only backfills can close with internal Verify when execution evidence covers the plan gates.
 27. Если external verifier/checker/browser tooling начинает тратить непропорционально много времени или блокируется окружением, Supervisor обязан остановить loop и вынести human decision: принять internal verify/evidence, запустить external escalation вручную или изменить scope.
+28. Если deterministic Check preflight создал `precheck-remediation.md`, Supervisor не должен запускать повторный Check после точечной правки одного пункта. Сначала Planner/Executor должен закрыть весь checklist или явно отметить not-applicable с evidence/human decision в `plan.md`/`status.md`, затем допускается один fresh Check.
+29. Перед повторным Check после deterministic precheck Supervisor обязан сверить, что `precheck-remediation.md` был использован как consolidated checklist: все listed gates отражены в plan/research/status, а не закрывались по одному через серию precheck loops.
 
 ## Hard Gate: Material Scope Expansion -> Brief Reset
 

package/prompts/verifier.md

@@ -44,6 +44,9 @@
 20. Если `plan.md` содержит `## Source Sync / Provider Gate`, verifier должен проверить `Source Sync / Provider Evidence`: scope/window, idempotency, retries/pagination/rate limits, raw-record handling, partial failure recovery and coverage/parity evidence.
 21. Если `task-manifest.json.loopDetector.requiresConsolidatedRemediation=true`, verifier не должен закрывать задачу, пока repeated return reasons не объединены в consolidated remediation и не покрыты execution evidence.
 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.
 
 ## Контракт выхода
 
@@ -59,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;