@besales/ops-framework 0.1.30 → 0.1.31

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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.

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/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/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.30",
+  "version": "0.1.31",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"

package/prompts/checker.md

@@ -73,6 +73,8 @@ Project-specific context приходит только через task artifacts
 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 очевидно найдет соседний.
 
 ## Контракт выхода
 

package/prompts/planner.md

@@ -53,6 +53,8 @@
 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.

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

@@ -47,6 +47,8 @@
 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`.
 
 ## Контракт выхода