@besales/ops-framework 0.1.29 → 0.1.31

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.31
+
+- Added bounded review budgets for Check and Verify: default 3 minute stage SLA and one external provider run per stage.
+- Added review budget gates that route repeated external Check/Verify loops to `human_arbitration_required` instead of launching another provider call; humans can explicitly override with `--force-review-budget`.
+- Added `review_budget_summary` telemetry to Check/Verify timelines so elapsed time, provider runs, deterministic blocks and provider duration are visible without manual log math.
+- Updated Planner/Checker/Verifier/Supervisor prompts to prefer consolidated remediation over one-item external review loops.
+
+## 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/README.md

@@ -188,6 +188,18 @@ Do not commit that `file:` dependency to production projects. It is only for pac
 - `initiative-requirements`
 - `test/self-test`
 
+## Review Budgets
+
+External `run-check` and `run-verify` are bounded by default:
+
+- stage SLA: `180000ms`;
+- max external provider runs per stage: `1`.
+
+When the budget is exceeded, the framework writes `human_arbitration_required`
+instead of starting another provider loop. Consolidate the remaining findings in
+task artifacts, or rerun with `--force-review-budget` only after explicit human
+approval.
+
 ## Learning Loop
 
 Learning is controlled and human-approved:

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/review-budget-utils.mjs

@@ -0,0 +1,79 @@
+export function resolveStageReviewBudget(config, stage) {
+  const defaults = {
+    stageSlaMs: 180000,
+    maxExternalRunsPerStage: 1,
+  };
+  const reviewBudgets = config.reviewBudgets || {};
+  return {
+    ...defaults,
+    ...(reviewBudgets[stage] || {}),
+  };
+}
+
+export function summarizeReviewBudgetWindow({
+  timeline = [],
+  stage,
+  now = new Date(),
+}) {
+  const terminalEvents = stage === 'verify'
+    ? new Set(['pass', 'pass_with_notes', 'human_arbitration_required', 'verifier_failed'])
+    : new Set(['ready_for_human_gate', 'human_arbitration_required', 'checker_failed']);
+  let lastTerminalIndex = -1;
+  for (let index = 0; index < timeline.length; index += 1) {
+    const event = timeline[index];
+    if ((event.event === `${stage}_completed` || event.event === 'check_completed') && terminalEvents.has(event.verdict)) {
+      lastTerminalIndex = index;
+    }
+  }
+
+  const windowEvents = timeline.slice(lastTerminalIndex + 1);
+  const firstEventAt = firstValidDate(windowEvents.map((event) => event.at)) || now;
+  const providerStarted = windowEvents.filter((event) => event.event === 'provider_started').length;
+  const providerCompleted = windowEvents.filter((event) => event.event === 'provider_completed').length;
+  const deterministicBlocks = windowEvents.filter((event) => event.event.includes('deterministic')).length;
+  const elapsedMs = Math.max(0, now.getTime() - firstEventAt.getTime());
+  const providerMs = windowEvents
+    .filter((event) => event.event === 'provider_completed')
+    .reduce((sum, event) => sum + Number(event.providerTiming?.durationMs || 0), 0);
+
+  return {
+    windowStartedAt: firstEventAt.toISOString(),
+    elapsedMs,
+    providerStarted,
+    providerCompleted,
+    deterministicBlocks,
+    providerMs,
+    eventCount: windowEvents.length,
+  };
+}
+
+export function evaluateReviewBudget({ budget, summary, force = false }) {
+  if (force) {
+    return { ok: true, reason: null };
+  }
+  if (summary.providerStarted >= budget.maxExternalRunsPerStage) {
+    return {
+      ok: false,
+      reason: 'max_external_runs_per_stage_exceeded',
+      message: `External review run budget exceeded: providerStarted=${summary.providerStarted}, maxExternalRunsPerStage=${budget.maxExternalRunsPerStage}.`,
+    };
+  }
+  if (summary.elapsedMs >= budget.stageSlaMs) {
+    return {
+      ok: false,
+      reason: 'stage_sla_exceeded',
+      message: `Review stage SLA exceeded: elapsedMs=${summary.elapsedMs}, stageSlaMs=${budget.stageSlaMs}.`,
+    };
+  }
+  return { ok: true, reason: null };
+}
+
+function firstValidDate(values) {
+  for (const value of values) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return null;
+}

package/bin/lib/review-budget-utils.test.mjs

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import {
+  evaluateReviewBudget,
+  resolveStageReviewBudget,
+  summarizeReviewBudgetWindow,
+} from './review-budget-utils.mjs';
+
+describe('review budget utils', () => {
+  it('blocks a second external check in the same active stage window', () => {
+    const now = new Date('2026-06-04T12:02:00.000Z');
+    const summary = summarizeReviewBudgetWindow({
+      stage: 'check',
+      now,
+      timeline: [
+        { at: '2026-06-04T12:00:00.000Z', event: 'check_started' },
+        { at: '2026-06-04T12:00:02.000Z', event: 'provider_started' },
+        {
+          at: '2026-06-04T12:01:30.000Z',
+          event: 'provider_completed',
+          providerTiming: { durationMs: 88000 },
+          verdict: 'return_to_plan',
+        },
+      ],
+    });
+
+    expect(summary.providerStarted).toBe(1);
+    expect(evaluateReviewBudget({
+      budget: { stageSlaMs: 180000, maxExternalRunsPerStage: 1 },
+      summary,
+    })).toMatchObject({
+      ok: false,
+      reason: 'max_external_runs_per_stage_exceeded',
+    });
+  });
+
+  it('blocks when wall-clock stage SLA is exceeded even without provider time', () => {
+    const summary = summarizeReviewBudgetWindow({
+      stage: 'check',
+      now: new Date('2026-06-04T12:04:00.000Z'),
+      timeline: [
+        { at: '2026-06-04T12:00:00.000Z', event: 'check_started' },
+        { at: '2026-06-04T12:00:01.000Z', event: 'deterministic_precheck_blocked' },
+      ],
+    });
+
+    expect(summary.providerStarted).toBe(0);
+    expect(evaluateReviewBudget({
+      budget: { stageSlaMs: 180000, maxExternalRunsPerStage: 1 },
+      summary,
+    })).toMatchObject({
+      ok: false,
+      reason: 'stage_sla_exceeded',
+    });
+  });
+
+  it('resets the active check window after ready_for_human_gate', () => {
+    const summary = summarizeReviewBudgetWindow({
+      stage: 'check',
+      now: new Date('2026-06-04T12:10:30.000Z'),
+      timeline: [
+        { at: '2026-06-04T12:00:00.000Z', event: 'check_started' },
+        { at: '2026-06-04T12:00:05.000Z', event: 'provider_started' },
+        { at: '2026-06-04T12:01:00.000Z', event: 'provider_completed', verdict: 'ready_for_human_gate' },
+        { at: '2026-06-04T12:01:00.100Z', event: 'check_completed', verdict: 'ready_for_human_gate' },
+        { at: '2026-06-04T12:10:00.000Z', event: 'check_started' },
+      ],
+    });
+
+    expect(summary.providerStarted).toBe(0);
+    expect(summary.elapsedMs).toBe(30000);
+    expect(evaluateReviewBudget({
+      budget: { stageSlaMs: 180000, maxExternalRunsPerStage: 1 },
+      summary,
+    })).toMatchObject({ ok: true });
+  });
+
+  it('uses configured stage budgets over defaults', () => {
+    expect(resolveStageReviewBudget({
+      reviewBudgets: {
+        verify: {
+          stageSlaMs: 120000,
+          maxExternalRunsPerStage: 2,
+        },
+      },
+    }, 'verify')).toEqual({
+      stageSlaMs: 120000,
+      maxExternalRunsPerStage: 2,
+    });
+  });
+});

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

@@ -45,6 +45,11 @@ import {
   validateManifest,
   writeTaskManifest,
 } from './lib/task-manifest-utils.mjs';
+import {
+  evaluateReviewBudget,
+  resolveStageReviewBudget,
+  summarizeReviewBudgetWindow,
+} from './lib/review-budget-utils.mjs';
 
 function main() {
   runMain().catch((error) => {
@@ -64,6 +69,8 @@ async function runMain() {
   const taskId = path.basename(taskDir);
   const dryRun = getFlag(args, 'dry-run', false) === true;
   const noCache = getFlag(args, 'no-cache', false) === true;
+  const forceReviewBudget = getFlag(args, 'force-review-budget', false) === true
+    || getFlag(args, 'force-external-review', false) === true;
   const checkerConfig = resolveCheckerConfig(args);
   const runStartedAt = new Date();
   appendCheckTimeline(taskDir, {
@@ -72,6 +79,7 @@ async function runMain() {
     model: checkerConfig.model,
     noCache,
     dryRun,
+    forceReviewBudget,
   });
 
   let checkContext = ensureFreshCheckContext(taskDir, taskId);
@@ -231,6 +239,55 @@ async function runMain() {
       return;
     }
 
+    const reviewBudget = evaluateCurrentReviewBudget({
+      taskDir,
+      stage: 'check',
+      config: readAgentsConfig(),
+      force: forceReviewBudget,
+    });
+    if (!reviewBudget.ok) {
+      writeReviewBudgetReturn({
+        taskDir,
+        taskId,
+        checkContext,
+        checkerConfig,
+        checkerPromptSha,
+        cacheKey,
+        reason: reviewBudget.reason,
+        message: reviewBudget.message,
+        budget: reviewBudget.budget,
+        summary: reviewBudget.summary,
+        startedAt: runStartedAt,
+      });
+      appendCheckTimeline(taskDir, {
+        event: 'review_budget_blocked',
+        verdict: 'human_arbitration_required',
+        reason: reviewBudget.reason,
+        message: reviewBudget.message,
+        budget: reviewBudget.budget,
+        summary: reviewBudget.summary,
+        timing: buildTiming(runStartedAt),
+      });
+      recordLlmInputUsage({
+        taskDir,
+        stage: 'check',
+        packMeta: promptPayload.pack.meta,
+        attempts: [
+          ...llmInputAttempts,
+          buildAttemptRecord(promptPayload.pack.meta, `review_budget_blocked:${reviewBudget.reason}`),
+        ],
+        rerunCount,
+        timing: buildTiming(runStartedAt),
+      });
+      refreshTaskManifestAfterCheck(taskDir);
+      runValidator(taskArg);
+      console.log(`Checker review budget blocked ${taskId}: human_arbitration_required`);
+      console.log(`- reason: ${reviewBudget.reason}`);
+      console.log(`- elapsedMs: ${reviewBudget.summary.elapsedMs}`);
+      console.log(`- providerStarted: ${reviewBudget.summary.providerStarted}`);
+      return;
+    }
+
     try {
       const providerStartedAt = new Date();
       appendCheckTimeline(taskDir, {
@@ -319,6 +376,7 @@ async function runMain() {
     cacheKeySha,
     timing: buildTiming(runStartedAt),
   });
+  appendReviewBudgetSummary(taskDir);
   if (!isContextInsufficientResult(providerOutput.checkResultJson)) {
     storeInCache({ taskDir, cacheKeySha });
   }
@@ -337,6 +395,127 @@ async function runMain() {
   console.log(`- finalEstimatedInputTokens: ${promptPayload.pack.meta.estimatedTokens}`);
 }
 
+function evaluateCurrentReviewBudget({ taskDir, stage, config, force }) {
+  const budget = resolveStageReviewBudget(config, stage);
+  const summary = summarizeReviewBudgetWindow({
+    timeline: readTimeline(taskDir, 'check-timeline.json'),
+    stage,
+    now: new Date(),
+  });
+  return {
+    ...evaluateReviewBudget({ budget, summary, force }),
+    budget,
+    summary,
+  };
+}
+
+function readTimeline(taskDir, fileName) {
+  const timelinePath = path.join(taskDir, fileName);
+  if (!fs.existsSync(timelinePath)) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(timelinePath, 'utf8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeReviewBudgetReturn({
+  taskDir,
+  taskId,
+  checkContext,
+  checkerConfig,
+  checkerPromptSha,
+  cacheKey,
+  reason,
+  message,
+  budget,
+  summary,
+  startedAt,
+}) {
+  const result = {
+    taskId,
+    stage: 'Check',
+    checkerProvider: 'review-budget',
+    checkerModel: 'none',
+    planSha: checkContext.planSha,
+    memorySha: checkContext.memorySha,
+    riskProfile: checkContext.riskProfile,
+    verdict: 'human_arbitration_required',
+    failureReason: null,
+    blockingFindings: 1,
+    nonBlockingFindings: 0,
+    humanQuestions: 1,
+    findings: [
+      {
+        id: 'F-001',
+        severity: 'blocking',
+        claimCategory: 'human_decision_required',
+        claim: message,
+        evidenceRefs: [
+          {
+            type: 'file',
+            ref: 'check-timeline.json',
+          },
+        ],
+        affectedPlanSections: ['Plan/Check orchestration'],
+        expectedCorrection: 'Stop the repeated external review loop. Consolidate remaining findings into plan/status/check-resolution, or ask the human to approve one extra external review with --force-review-budget.',
+      },
+    ],
+    reviewBudget: {
+      reason,
+      budget,
+      summary,
+      forceFlag: '--force-review-budget',
+    },
+    readyForHumanGate: false,
+    createdAt: new Date().toISOString(),
+  };
+  const markdown = [
+    '# Check',
+    '',
+    '## итоговая оценка',
+    '',
+    '`human_arbitration_required`',
+    '',
+    '## Review Budget Gate',
+    '',
+    message,
+    '',
+    'The external Checker was not invoked. The framework enforces a bounded Check stage so quality work happens through consolidated remediation instead of repeated provider loops.',
+    '',
+    '## Budget',
+    '',
+    '```json',
+    JSON.stringify({ reason, budget, summary }, null, 2),
+    '```',
+    '',
+    '## Required decision',
+    '',
+    '- Consolidate all remaining Check findings into `plan.md`, `status.md`, and `check-resolution.md`, then run one fresh Check after the window resets; or',
+    '- Ask the human to approve an extra external review and rerun with `--force-review-budget`.',
+    '',
+    '## Timing',
+    '',
+    `- Duration: ${buildTiming(startedAt).durationMs}ms`,
+  ].join('\n');
+
+  writeTaskFile(taskDir, 'check.md', appendRunnerMetadata(markdown, checkerPromptSha, cacheKey));
+  writeTaskFile(taskDir, 'check.result.json', JSON.stringify(result, null, 2));
+  updateStatus(taskDir, {
+    stage: 'Human Arbitration',
+    routingDecision: `review_budget_blocked:${reason}`,
+    checkVerdict: '`human_arbitration_required`',
+    checkResult: '- `check.result.json`: current; review budget blocked external Checker invocation',
+    supervisorAction: 'Check review budget blocked another external provider loop.',
+    nextStep: 'Human Arbitration: approve one extra external review with `--force-review-budget` or consolidate remaining findings before a fresh Check.',
+    humanApproval: 'yes',
+  });
+  appendOrchestrationLog(taskDir, `Check review budget blocked external checker; reason=${reason}; elapsedMs=${summary.elapsedMs}; providerStarted=${summary.providerStarted}; maxExternalRuns=${budget.maxExternalRunsPerStage}; stageSlaMs=${budget.stageSlaMs}`);
+}
+
 function refreshTaskManifestAfterCheck(taskDir) {
   const manifest = buildTaskManifest({ taskDir });
   writeTaskManifest(taskDir, manifest);
@@ -366,6 +545,21 @@ function appendCheckTimeline(taskDir, event) {
   writeTaskFile(taskDir, 'check-timeline.json', JSON.stringify(existing, null, 2));
 }
 
+function appendReviewBudgetSummary(taskDir) {
+  const config = readAgentsConfig();
+  const budget = resolveStageReviewBudget(config, 'check');
+  const summary = summarizeReviewBudgetWindow({
+    timeline: readTimeline(taskDir, 'check-timeline.json'),
+    stage: 'check',
+    now: new Date(),
+  });
+  appendCheckTimeline(taskDir, {
+    event: 'review_budget_summary',
+    budget,
+    summary,
+  });
+}
+
 function buildAttemptRecord(packMeta, outcome) {
   return {
     mode: packMeta.mode,

package/bin/run-verify.mjs

@@ -28,6 +28,11 @@ import {
   summarizePackForConsole,
 } from './lib/llm-input-pack-utils.mjs';
 import { recordLlmInputUsage } from './lib/task-manifest-utils.mjs';
+import {
+  evaluateReviewBudget,
+  resolveStageReviewBudget,
+  summarizeReviewBudgetWindow,
+} from './lib/review-budget-utils.mjs';
 
 function main() {
   runMain().catch((error) => {
@@ -47,12 +52,15 @@ async function runMain() {
   const taskId = path.basename(taskDir);
   const verifierConfig = resolveVerifierConfig(args);
   const force = getFlag(args, 'force', false) === true;
+  const forceReviewBudget = getFlag(args, 'force-review-budget', false) === true
+    || getFlag(args, 'force-external-review', false) === true;
   const runStartedAt = new Date();
   appendVerifyTimeline(taskDir, {
     event: 'verify_started',
     mode: verifierConfig.mode,
     provider: verifierConfig.provider,
     model: verifierConfig.model,
+    forceReviewBudget,
   });
   const planSha = hashTaskMarkdown(taskDir, 'plan.md');
   const executionSha = hashTaskMarkdown(taskDir, 'execution.md');
@@ -202,6 +210,52 @@ async function runMain() {
       return;
     }
 
+    const reviewBudget = evaluateCurrentReviewBudget({
+      taskDir,
+      stage: 'verify',
+      config: readAgentsConfig(),
+      force: forceReviewBudget,
+    });
+    if (!reviewBudget.ok) {
+      writeVerifyReviewBudgetReturn({
+        taskDir,
+        taskId,
+        verifierConfig,
+        verifierRunId,
+        planSha,
+        executionSha,
+        reason: reviewBudget.reason,
+        message: reviewBudget.message,
+        budget: reviewBudget.budget,
+        summary: reviewBudget.summary,
+      });
+      appendVerifyTimeline(taskDir, {
+        event: 'review_budget_blocked',
+        verdict: 'human_arbitration_required',
+        reason: reviewBudget.reason,
+        message: reviewBudget.message,
+        budget: reviewBudget.budget,
+        summary: reviewBudget.summary,
+        timing: buildTiming(runStartedAt),
+      });
+      recordLlmInputUsage({
+        taskDir,
+        stage: 'verify',
+        packMeta: promptPayload.pack.meta,
+        attempts: [
+          ...llmInputAttempts,
+          buildAttemptRecord(promptPayload.pack.meta, `review_budget_blocked:${reviewBudget.reason}`),
+        ],
+        rerunCount,
+        timing: buildTiming(runStartedAt),
+      });
+      console.log(`Verifier review budget blocked ${taskId}: human_arbitration_required`);
+      console.log(`- reason: ${reviewBudget.reason}`);
+      console.log(`- elapsedMs: ${reviewBudget.summary.elapsedMs}`);
+      console.log(`- providerStarted: ${reviewBudget.summary.providerStarted}`);
+      return;
+    }
+
     try {
       const providerStartedAt = new Date();
       appendVerifyTimeline(taskDir, {
@@ -310,6 +364,7 @@ async function runMain() {
     finalEstimatedTokens: finalPack?.meta?.estimatedTokens || null,
     timing: buildTiming(runStartedAt),
   });
+  appendReviewBudgetSummary(taskDir);
   appendOrchestrationLog(taskDir, `external CLI verifier completed via ${verifierConfig.provider}; verdict=${verifyResultJson.verdict}; runId=${verifierRunId}`);
   console.log(`Verifier run completed for ${taskId}: ${verifyResultJson.verdict}`);
   console.log(`- verifierRunId: ${verifierRunId}`);
@@ -319,6 +374,119 @@ async function runMain() {
   }
 }
 
+function evaluateCurrentReviewBudget({ taskDir, stage, config, force }) {
+  const budget = resolveStageReviewBudget(config, stage);
+  const summary = summarizeReviewBudgetWindow({
+    timeline: readTimeline(taskDir, 'verify-timeline.json'),
+    stage,
+    now: new Date(),
+  });
+  return {
+    ...evaluateReviewBudget({ budget, summary, force }),
+    budget,
+    summary,
+  };
+}
+
+function readTimeline(taskDir, fileName) {
+  const timelinePath = path.join(taskDir, fileName);
+  if (!fs.existsSync(timelinePath)) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(timelinePath, 'utf8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeVerifyReviewBudgetReturn({
+  taskDir,
+  taskId,
+  verifierConfig,
+  verifierRunId,
+  planSha,
+  executionSha,
+  reason,
+  message,
+  budget,
+  summary,
+}) {
+  const verifyMarkdown = [
+    '# Verify',
+    '',
+    '## Verdict',
+    '',
+    '`human_arbitration_required`',
+    '',
+    '## Review Budget Gate',
+    '',
+    message,
+    '',
+    'The external Verifier was not invoked. The framework enforces a bounded Verify stage so execution fixes are consolidated instead of repeatedly rechecked by an external provider.',
+    '',
+    '## Budget',
+    '',
+    '```json',
+    JSON.stringify({ reason, budget, summary }, null, 2),
+    '```',
+    '',
+    '## Required decision',
+    '',
+    '- Consolidate remaining Verify findings in `execution.md` / evidence artifacts, then run one fresh Verify after the window resets; or',
+    '- Ask the human to approve an extra external review and rerun with `--force-review-budget`.',
+  ].join('\n');
+  const result = {
+    schemaVersion: 1,
+    taskId,
+    planSha,
+    executionSha,
+    verificationMode: 'external_cli',
+    verifierProvider: 'review-budget',
+    verifierModel: 'none',
+    verifierRunId,
+    verdict: 'human_arbitration_required',
+    failureReason: null,
+    readyForRetrospective: false,
+    counts: {
+      blockingFindings: 1,
+      nonBlockingFindings: 0,
+      questions: 1,
+    },
+    findings: [
+      {
+        id: 'V-001',
+        severity: 'blocking',
+        claimCategory: 'runtime_risk',
+        affectedArtifacts: ['verify-timeline.json'],
+        claim: message,
+        evidenceRefs: [
+          {
+            type: 'artifact',
+            ref: 'verify-timeline.json',
+          },
+        ],
+        expectedCorrection: 'Stop the repeated external Verify loop. Consolidate remaining execution fixes or ask the human to approve one extra external review with --force-review-budget.',
+      },
+    ],
+    reviewBudget: {
+      reason,
+      budget,
+      summary,
+      forceFlag: '--force-review-budget',
+    },
+  };
+
+  writeTaskFile(taskDir, 'verify.md', verifyMarkdown);
+  writeTaskFile(taskDir, 'verify.result.json', JSON.stringify(result, null, 2));
+  updateStatusForVerifyResult(taskDir, result, {
+    reused: false,
+    verifierMode: 'external_cli',
+  });
+  appendOrchestrationLog(taskDir, `Verify review budget blocked external verifier; reason=${reason}; elapsedMs=${summary.elapsedMs}; providerStarted=${summary.providerStarted}; maxExternalRuns=${budget.maxExternalRunsPerStage}; stageSlaMs=${budget.stageSlaMs}`);
+}
+
 function buildTiming(startedAt, completedAt = new Date()) {
   return {
     startedAt: startedAt.toISOString(),
@@ -426,6 +594,21 @@ function appendVerifyTimeline(taskDir, event) {
   writeTaskFile(taskDir, 'verify-timeline.json', JSON.stringify(existing, null, 2));
 }
 
+function appendReviewBudgetSummary(taskDir) {
+  const config = readAgentsConfig();
+  const budget = resolveStageReviewBudget(config, 'verify');
+  const summary = summarizeReviewBudgetWindow({
+    timeline: readTimeline(taskDir, 'verify-timeline.json'),
+    stage: 'verify',
+    now: new Date(),
+  });
+  appendVerifyTimeline(taskDir, {
+    event: 'review_budget_summary',
+    budget,
+    summary,
+  });
+}
+
 function buildAttemptRecord(packMeta, outcome) {
   return {
     mode: packMeta.mode,

package/config/default-agents.json

@@ -18,6 +18,16 @@
     "isolatedContext": true,
     "readOnly": true
   },
+  "reviewBudgets": {
+    "check": {
+      "stageSlaMs": 180000,
+      "maxExternalRunsPerStage": 1
+    },
+    "verify": {
+      "stageSlaMs": 180000,
+      "maxExternalRunsPerStage": 1
+    }
+  },
   "checkerProviders": {
     "codex-cli": {
       "command": "${CODEX_CLI_COMMAND}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besales/ops-framework",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "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,9 @@ 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.
+28. Если remaining issue является процессной ясностью, wording polish или удобством статуса, а план уже содержит executable scope, acceptance, risk gates and verification evidence path, не возвращай `return_to_plan`; запиши как non-blocking note или human question. Цель Check - предотвратить дорогие ошибки до Execute, а не создавать повторные внешние циклы ради косметики.
+29. Если видишь несколько related blockers, объедини их в один consolidated finding с полным checklist. Не выдавай только первый найденный blocker, если следующий внешний Check очевидно найдет соседний.
 
 ## Контракт выхода
 
@@ -97,6 +100,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

@@ -53,8 +53,11 @@
 17. Если Planner знает факт только из conversation context, этот факт нужно перенести в artifact: `brief.md`, `research.md`, `status.md` или `human_decision` evidence. Невидимый контекст не является evidence.
 18. Plan должен назвать risk tier (`R0`-`R5`), execution target and execution budget. Для `R1/R2` можно разрешить fast loop inside approved scope, но обязательно назвать stop rules.
 19. План проверки должен быть ladder-based: micro-verify during Execute, slice-verify before completion and external Verify requirement for closeout/high-risk claims.
+20. После `return_to_plan` Planner обязан выполнить один consolidated remediation pass: закрыть все blocking findings, precheck checklist и obvious adjacent gaps в `plan.md`/`check-resolution.md` до следующего Check. Не запускай внешний Check после единичной мелкой правки, если другие known blockers остаются открыты.
+21. Если Check остановлен review budget gate (`human_arbitration_required` с `reviewBudget.reason`), Planner не должен пытаться обойти это повторным запуском. Нужно либо запросить human approval на `--force-review-budget`, либо укрупнить remediation и вернуться к Check после явного решения.
 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 +125,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

@@ -61,6 +61,8 @@ Supervisor является code-level orchestrator по контракту: rou
 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.
+30. External Check и external Verify имеют stage SLA по умолчанию 3 минуты и максимум один external provider run на фазу. Если `check.result.json` или `verify.result.json` вернул `human_arbitration_required` с `reviewBudget.reason`, Supervisor не запускает еще один внешний review без явного human approval и `--force-review-budget`.
+31. После `return_to_plan` / `return_to_execute` Supervisor должен требовать один consolidated remediation pass. Запрещено запускать серию внешних Check/Verify для мелких последовательных правок, если их можно закрыть в одном artifact update.
 
 ## Hard Gate: Material Scope Expansion -> Brief Reset
 

package/prompts/verifier.md

@@ -46,6 +46,9 @@
 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.
+26. External Verify должен укладываться в bounded review model: один внешний provider run по умолчанию. Если остаются несколько blockers, верни один consolidated `return_to_execute` finding с полным checklist. Minor documentation/status polish не должен запускать новый внешний цикл, если acceptance/evidence покрыты.
+27. Если review budget gate уже вернул `human_arbitration_required`, не предлагай повторный external Verify как обычный следующий шаг. Следующий шаг: consolidated execution fix, internal evidence decision или явный human approval на `--force-review-budget`.
 
 ## Контракт выхода
 
@@ -61,6 +64,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;