@besales/ops-framework 0.1.18 → 0.1.21

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.1.21
+
+- Added `verify-timeline.json` telemetry for Verify runs, including deterministic blocks, LLM input sizing, context-mode escalation, provider duration/failure and final verdict.
+- Prevented Verify artifact-growth loops by compacting generated review/log artifacts (`verify.md`, `check.md`, `check-resolution.md`, `orchestration-log.md`) even in strict verifier context while preserving full execution evidence.
+- Compacted `execution-ledger.json` in verifier input and marked files mentioned in `execution.md` so task-scope files do not remain in `unrelatedDirtyFiles`.
+
+## 0.1.20
+
+- Added deterministic task Check gates for schema/migration plans: a real disposable/scratch database apply path is required before external Check, and Verify/Human Gate evidence must show a successful apply/migrate/psql run rather than static SQL review only.
+- Added audit/entity_history ambiguity gates: plans and initiative synthesis must explicitly choose a functional DB trigger writer model or an application-code writer model.
+- Added a draft-storage synthesis gate for Variant-A/draft-only apply contracts so `proposed_changes` must explicitly support deferred fact domains with entity/change type, JSON payload, source quote, confidence, financial event, related person and conflict metadata.
+
+## 0.1.19
+
+- Strengthened deterministic Check preflight so external checker calls are skipped when the plan still has placeholder execution metadata, missing verification ladder or missing standards alignment.
+- Tightened O3 optimization gating: plans must include a representative measurement path or explicit blocked/human-owned fallback before external Check.
+- Added `check-timeline.json` telemetry for Check runs, including deterministic blocks, LLM input sizing, cache hits, provider start/completion/failure and context overflow events.
+
 ## 0.1.18
 
 - Added work-package dependency metadata (`Depends on`, `Unblocks`, `Can run parallel with`, `Sequencing notes`) to new initiative work packages.

package/bin/initiative.mjs

@@ -1038,7 +1038,9 @@ function buildSynthesisReadinessGates({ requirements, sourceDocs }) {
   });
   addScopeStorageConflictGate({ gates, sourceText, requirementText });
   addApplyContractGate({ gates, sourceText, requirementText });
+  addDraftStorageShapeGate({ gates, sourceText, requirementText });
   addSchemaCompatibilityGate({ gates, sourceText, requirements });
+  addAuditWriterModelGate({ gates, sourceText, requirementText });
   addSchemaAttributionWarningGate({ gates, sourceText, requirements });
   addSequencingGate({ gates, sourceText, requirementText });
   addStrongerSourceRefGate({ gates, sourceDocs, requirements });
@@ -1105,6 +1107,65 @@ function addApplyContractGate({ gates, sourceText, requirementText }) {
   }
 }
 
+function addDraftStorageShapeGate({ gates, sourceText, requirementText }) {
+  const combinedText = `${requirementText}\n${sourceText}`;
+  const hasDraftOnlyContract = /(variant\s*a|draft[- ]only|draft|proposed only|not applied|только proposed|чернов)/i.test(combinedText);
+  const hasDeferredFactDomains = /(commitments?|decisions?|risks?|projects?|financial_event|related_person_id|has_conflict)/i.test(combinedText);
+  const mentionsProposedChanges = /proposed_changes?|proposedchange|proposed change/i.test(combinedText);
+  if (!hasDraftOnlyContract || !hasDeferredFactDomains || !mentionsProposedChanges) {
+    return;
+  }
+
+  const requiredFields = [
+    ['entity_type', /entity_type/i],
+    ['change_type', /change_type/i],
+    ['proposed_value JSONB', /(proposed_value|payload).{0,40}(jsonb|json)/i],
+    ['source_quote/source_quote_raw', /source_quote(?:_raw)?/i],
+    ['confidence', /confidence/i],
+    ['financial_event_type', /financial_event_type/i],
+    ['related_person_id', /related_person_id/i],
+    ['has_conflict', /has_conflict/i],
+  ];
+  const missing = requiredFields
+    .filter(([, pattern]) => !pattern.test(requirementText))
+    .map(([name]) => name);
+
+  if (missing.length) {
+    gates.push({
+      id: 'draft-storage-proposed-changes-shape',
+      severity: 'critical',
+      blocking: true,
+      title: 'Draft-only apply contract lacks proposed_changes storage shape',
+      issue: `Variant/draft-only requirements rely on proposed_changes for deferred fact domains, but synthesized requirements do not explicitly cover ${missing.join(', ')}.`,
+      action: 'Before WP planning, add acceptance that `proposed_changes` can store draft commitments/decisions/risks/projects/facts with entity_type, change_type, proposed_value JSONB, source quote fields, confidence, financial_event_type, related_person_id and conflict metadata, or narrow the draft output scope.',
+    });
+  }
+}
+
+function addAuditWriterModelGate({ gates, sourceText, requirementText }) {
+  const combinedText = `${requirementText}\n${sourceText}`;
+  const mentionsAudit = /(entity_history|audit|before\/after|before and after|log_entity_change|app\.current_user_id|attribution)/i.test(combinedText);
+  if (!mentionsAudit) {
+    return;
+  }
+  const triggerModel = /(trigger|log_entity_change|before\/after|before and after|current_setting\('app\.current_user_id'\)|триггер)/i.test(requirementText);
+  const appModel = /(application[- ]code writer|app(?:lication)? writes|apply[- ]code writes|manual writer|writes entity_history manually|пишет entity_history|прикладн)/i.test(requirementText);
+  const ambiguous = /(trigger|триггер).{0,80}\b(or|или)\b.{0,80}(application|app|manual|код|вручн)/i.test(combinedText)
+    || /(application|app|manual|код|вручн).{0,80}\b(or|или)\b.{0,80}(trigger|триггер)/i.test(combinedText)
+    || /(table only|only table|таблиц[ауы].{0,80}без триггер|helper pattern only|entity_history plus helper pattern|helper pattern)/i.test(combinedText);
+  if (!ambiguous && (triggerModel || appModel)) {
+    return;
+  }
+  gates.push({
+    id: 'audit-writer-model-ambiguous',
+    severity: 'needs_decision',
+    blocking: true,
+    title: 'Audit history writer model is ambiguous',
+    issue: 'Requirements mention audit/entity_history/attribution, but do not decide whether audit rows are written by functional DB triggers or by application/apply code.',
+    action: 'Before WP-001 planning, choose the audit writer model explicitly. For DB-trigger audit, require `log_entity_change`, trigger attachment to core tables and `app.current_user_id`; for app-code audit, require the exact apply-code writer contract and covered entities.',
+  });
+}
+
 function addSchemaCompatibilityGate({ gates, sourceText, requirements }) {
   const schemaReq = findSchemaRequirement(requirements);
   if (!schemaReq) {

package/bin/initiative.test.mjs

@@ -783,6 +783,120 @@ describe('initiative framework', () => {
     expect(schemaGate.issue).toContain('meeting_track');
     expect(schemaGate.action).toContain('meetings.raw_speaker_labels');
   });
+
+  it('blocks synthesis when draft-only proposed_changes storage shape is incomplete', () => {
+    const root = makeProject();
+    const docsDir = path.join(root, 'docs', 'delivery-os');
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(path.join(docsDir, '99-feedback-log.md'), [
+      '# Feedback',
+      '',
+      '- Human-approved Variant A: commitments, decisions, risks and financial_event facts are draft-only ProposedChange outputs in Phase 1.',
+      '- Drafts need related_person_id, has_conflict and source quote attribution.',
+    ].join('\n'));
+    createInitiative({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      title: 'Delivery OS MVP',
+    });
+    initiativeIntake({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      docsDir: 'docs/delivery-os',
+      phase: 'phase-1',
+    });
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    fs.writeFileSync(path.join(initiativeDir, 'requirements-map.md'), [
+      '# Requirements Map',
+      '',
+      '## Requirement Details',
+      '',
+      '### REQ-005',
+      '',
+      '- Status: `approved`',
+      '- Source: `docs/delivery-os/99-feedback-log.md:1`',
+      '- Source hash: `sha`',
+      '- Phase: `phase-1`',
+      '- Quality: `complete`',
+      '- Quality issue: (none)',
+      '- Work package: WP-004',
+      '- Acceptance: Variant A keeps commitments/decisions/risks as draft ProposedChange records, not applied truth writes.',
+      '- Decision: `approve`',
+      '- Notes: Human-approved Variant A.',
+      '- Requirement: Phase 1 apply writes clients/people/meetings and keeps deferred domains as draft proposed_changes.',
+      '',
+    ].join('\n'));
+
+    const synthesis = initiativeRequirementsSynthesis({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+    });
+
+    const gate = synthesis.gates.find((item) => item.id === 'draft-storage-proposed-changes-shape');
+    expect(gate).toMatchObject({
+      severity: 'critical',
+      blocking: true,
+    });
+    expect(gate.issue).toContain('entity_type');
+    expect(gate.issue).toContain('related_person_id');
+    expect(synthesis.rewriteRequired).toBe(true);
+  });
+
+  it('blocks synthesis when audit/entity_history writer model is ambiguous', () => {
+    const root = makeProject();
+    const docsDir = path.join(root, 'docs', 'delivery-os');
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(path.join(docsDir, '07-adrs.md'), [
+      '# ADR',
+      '',
+      '- Attribution requires app.current_user_id and entity_history audit before/after records.',
+    ].join('\n'));
+    createInitiative({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      title: 'Delivery OS MVP',
+    });
+    initiativeIntake({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+      docsDir: 'docs/delivery-os',
+      phase: 'phase-1',
+    });
+    const initiativeDir = path.join(root, 'ops', 'agent-pipeline', 'initiatives', 'delivery-os-mvp');
+    fs.writeFileSync(path.join(initiativeDir, 'requirements-map.md'), [
+      '# Requirements Map',
+      '',
+      '## Requirement Details',
+      '',
+      '### REQ-002',
+      '',
+      '- Status: `approved`',
+      '- Source: `docs/delivery-os/07-adrs.md:1`',
+      '- Source hash: `sha`',
+      '- Phase: `phase-1`',
+      '- Quality: `complete`',
+      '- Quality issue: (none)',
+      '- Work package: WP-001',
+      '- Acceptance: Schema includes entity_history and app.current_user_id helper pattern.',
+      '- Decision: `approve`',
+      '- Notes: Audit trigger scope may expand; minimum is entity_history plus helper pattern.',
+      '- Requirement: Phase 1 schema preserves attribution and audit history.',
+      '',
+    ].join('\n'));
+
+    const synthesis = initiativeRequirementsSynthesis({
+      projectRoot: root,
+      initiativeId: 'delivery-os-mvp',
+    });
+
+    const gate = synthesis.gates.find((item) => item.id === 'audit-writer-model-ambiguous');
+    expect(gate).toMatchObject({
+      severity: 'needs_decision',
+      blocking: true,
+    });
+    expect(gate.action).toContain('log_entity_change');
+    expect(synthesis.rewriteRequired).toBe(true);
+  });
 });
 
 function makeProject() {

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

@@ -228,6 +228,8 @@ export function computeTaskContextInputs(taskDir) {
   const qualityGates = analyzePlanQualityGates({
     planContent: taskArtifacts.get('plan.md'),
     risk,
+    referencedFiles,
+    structuralLines,
   });
 
   return {
@@ -755,7 +757,7 @@ ${missingSignals.length ? missingSignals.map((signal) => `- ${signal}`).join('\n
 `;
 }
 
-export function analyzePlanQualityGates({ planContent, risk }) {
+export function analyzePlanQualityGates({ planContent, risk, referencedFiles = [], structuralLines = [] }) {
   const sections = parseMarkdownSections(planContent);
   const uiRequired = requiresUiAcceptanceScenarios(risk.riskTriggers);
   const complexityRequired = requiresComplexityBudget(risk.riskTriggers);
@@ -763,6 +765,12 @@ export function analyzePlanQualityGates({ planContent, risk }) {
   const optimizationRequired = requiresOptimizationStrategy(optimizationTier);
   const productionRolloutRequired = requiresProductionRolloutGate(risk.riskTriggers);
   const sourceSyncProviderRequired = requiresSourceSyncProviderGate(risk.riskTriggers);
+  const executionMetadata = inspectExecutionMetadata(sections);
+  const verificationLadder = inspectVerificationLadder(sections);
+  const standardsAlignmentRequired = requiresStandardsAlignment({ referencedFiles, structuralLines });
+  const standardsAlignment = inspectStandardsAlignment(sections);
+  const migrationApply = inspectMigrationApplyPlan(sections, risk.riskTriggers);
+  const auditWriterModel = inspectAuditWriterModel(sections, planContent);
   const uiAcceptance = inspectUiAcceptanceScenarios(sections);
   const complexityBudget = inspectComplexityPerformanceBudget(sections);
   const optimizationStrategy = inspectOptimizationStrategy(sections);
@@ -770,6 +778,21 @@ export function analyzePlanQualityGates({ planContent, risk }) {
   const sourceSyncProvider = inspectSourceSyncProviderGate(sections);
   const missingSignals = [];
 
+  if (!executionMetadata.present) {
+    missingSignals.push('Plan must include `## Risk tier and execution budget` with explicit risk tier, speed mode, execution target and budget/stop rule.');
+  }
+  if (!verificationLadder.present) {
+    missingSignals.push('Plan must include a `Verification ladder` with micro-verify, slice-verify and external Verify decision.');
+  }
+  if (standardsAlignmentRequired && !standardsAlignment.present) {
+    missingSignals.push('Standards file/reference detected but `## Global Standards Alignment` / `## Standards Alignment` is missing or incomplete.');
+  }
+  if (migrationApply.required && !migrationApply.present) {
+    missingSignals.push('Schema/migration work requires a real apply path on a disposable/scratch database before closeout; static SQL review alone is not enough.');
+  }
+  if (auditWriterModel.required && !auditWriterModel.present) {
+    missingSignals.push('Audit/entity_history requirement must declare the writer model: functional DB trigger versus explicit application-code writer, not an ambiguous table-only audit.');
+  }
   if (uiRequired && !uiAcceptance.present) {
     missingSignals.push('UI-visible risk detected but `## UI Acceptance Scenarios` is missing or incomplete.');
   }
@@ -782,6 +805,9 @@ export function analyzePlanQualityGates({ planContent, risk }) {
   if (optimizationRequired && !optimizationStrategy.present) {
     missingSignals.push(`Optimization tier ${optimizationTier} detected but \`## Optimization Strategy\` is missing or incomplete.`);
   }
+  if (optimizationTier === 'O3' && optimizationStrategy.present && !optimizationStrategy.hasMeasurementPath) {
+    missingSignals.push('Optimization tier O3 requires a representative measurement path or explicit blocked/human-owned fallback.');
+  }
   if (productionRolloutRequired && !productionRollout.present) {
     missingSignals.push('Production rollout risk detected but `## Production Rollout Gate` is missing or incomplete.');
   }
@@ -790,6 +816,12 @@ export function analyzePlanQualityGates({ planContent, risk }) {
   }
 
   return {
+    executionMetadata,
+    verificationLadder,
+    standardsAlignmentRequired,
+    standardsAlignment,
+    migrationApply,
+    auditWriterModel,
     uiRequired,
     uiAcceptance,
     complexityRequired,
@@ -805,6 +837,173 @@ export function analyzePlanQualityGates({ planContent, risk }) {
   };
 }
 
+export function inspectExecutionMetadata(sections) {
+  const body = readCanonicalSection(sections, [
+    'risk tier and execution budget',
+    'risk tier',
+    'execution budget',
+  ]);
+  if (!body) {
+    return {
+      present: false,
+      hasRiskTier: false,
+      hasSpeedMode: false,
+      hasExecutionTarget: false,
+      hasBudget: false,
+    };
+  }
+
+  const normalized = body.toLowerCase();
+  const targetValue = readLabeledValue(body, ['approved execution target', 'execution target', 'target']);
+  const budgetValue = firstNonEmptyValue([
+    readLabeledValue(body, ['execution budget', 'budget', 'optimizer budget / stop rule']),
+    readLabeledValue(body, ['fast-loop allowed inside this slice', 'fast-loop allowed']),
+    readLabeledValue(body, ['requires return to plan/check if', 'requires return']),
+  ]);
+  const result = {
+    present: true,
+    hasRiskTier: /risk tier\s*:\s*`?\s*R[0-5]\b/i.test(body) && !/risk tier\s*:\s*`?\s*R0\s*\|/i.test(body),
+    hasSpeedMode: /speed mode\s*:\s*`?\s*(fast|standard|strict)\b/i.test(body) && !/speed mode\s*:\s*`?\s*fast\s*\|/i.test(body),
+    hasExecutionTarget: Boolean(targetValue && !/^(tbd|todo|n\/a|none|-)?$/i.test(targetValue.trim())),
+    hasBudget: Boolean(budgetValue && !/^(tbd|todo|n\/a|none|-)?$/i.test(budgetValue.trim())) || /(?:budget|stop rule|лимит|бюджет)\s*:\s*\S/i.test(normalized),
+  };
+  result.complete = result.hasRiskTier && result.hasSpeedMode && result.hasExecutionTarget && result.hasBudget;
+  result.present = result.complete;
+  return result;
+}
+
+export function inspectVerificationLadder(sections) {
+  const body = [
+    readCanonicalSection(sections, ['verification ladder']),
+    readCanonicalSection(sections, ['план проверки', 'verification plan', 'verification and replay plan']),
+  ].filter(Boolean).join('\n');
+  if (!body) {
+    return {
+      present: false,
+      hasMicroVerify: false,
+      hasSliceVerify: false,
+      hasExternalVerifyDecision: false,
+    };
+  }
+
+  const normalized = body.toLowerCase();
+  const result = {
+    present: true,
+    hasMicroVerify: /micro-?verify|micro verify|микро/.test(normalized),
+    hasSliceVerify: /slice-?verify|slice verify|слайс/.test(normalized),
+    hasExternalVerifyDecision: /external verify|required before closeout|yes\s*\|\s*no|external_cli|internal_supervisor|внешн/.test(normalized),
+  };
+  result.complete = result.hasMicroVerify && result.hasSliceVerify && result.hasExternalVerifyDecision;
+  result.present = result.complete;
+  return result;
+}
+
+export function requiresStandardsAlignment({ referencedFiles = [], structuralLines = [] } = {}) {
+  const text = [...referencedFiles, ...structuralLines].join('\n').toLowerCase();
+  return /(^|\/|\.)(claude|standards|standard|rules|conventions)(\.md|\.mdc|\/|$)/.test(text)
+    || /\b(standards|conventions|coding rules|global rules|claude\.md)\b/.test(text);
+}
+
+export function inspectStandardsAlignment(sections) {
+  const body = readCanonicalSection(sections, [
+    'global standards alignment',
+    'standards alignment',
+    'standards',
+  ]);
+  if (!body) {
+    return {
+      present: false,
+      hasLocalInterpretation: false,
+      hasValidation: false,
+    };
+  }
+
+  const normalized = body.toLowerCase();
+  const result = {
+    present: true,
+    hasLocalInterpretation: /local interpretation|applied here|applies|интерпретац|применим|учитываем|следуем/.test(normalized),
+    hasValidation: /validate|verification|check|test|lint|провер/.test(normalized),
+  };
+  result.complete = result.hasLocalInterpretation && result.hasValidation;
+  result.present = result.complete;
+  return result;
+}
+
+export function inspectMigrationApplyPlan(sections, riskTriggers = []) {
+  const required = riskTriggers.includes('prisma-schema');
+  const body = [
+    readCanonicalSection(sections, ['production rollout gate', 'production rollout', 'rollout gate', 'deployment gate']),
+    readCanonicalSection(sections, ['план проверки', 'verification plan', 'verification and replay plan']),
+    readCanonicalSection(sections, ['risk tier and execution budget']),
+  ].filter(Boolean).join('\n');
+  if (!required) {
+    return {
+      required: false,
+      present: true,
+      hasApplyCommand: false,
+      hasDisposableTarget: false,
+      rejectsStaticOnly: false,
+    };
+  }
+  if (!body) {
+    return {
+      required,
+      present: false,
+      hasApplyCommand: false,
+      hasDisposableTarget: false,
+      rejectsStaticOnly: false,
+    };
+  }
+
+  const normalized = body.toLowerCase();
+  const result = {
+    required,
+    present: true,
+    hasApplyCommand: /\b(apply|migrate|psql|db push|migration)\b/.test(normalized),
+    hasDisposableTarget: /\b(disposable|scratch|throwaway|temporary|temp|ephemeral|test database|local postgres|railway postgres|staging db|однораз|временн|тестов)\b/.test(normalized),
+    rejectsStaticOnly: /static(?: sql)? review alone is not enough|not static[- ]only|статическ.{0,40}недостаточно|blocked evidence.{0,80}not accepted/i.test(body),
+  };
+  result.complete = result.hasApplyCommand && result.hasDisposableTarget;
+  result.present = result.complete;
+  return result;
+}
+
+export function inspectAuditWriterModel(sections, planContent = '') {
+  const text = [
+    planContent,
+    readCanonicalSection(sections, ['production rollout gate', 'production rollout']),
+    readCanonicalSection(sections, ['шаги реализации', 'implementation steps']),
+    readCanonicalSection(sections, ['риски и открытые вопросы', 'known risks']),
+  ].filter(Boolean).join('\n');
+  const required = /(entity_history|audit|before\/after|before and after|log_entity_change|current_setting\('app\.current_user_id'\)|app\.current_user_id|attribution)/i.test(text);
+  if (!required) {
+    return {
+      required: false,
+      present: true,
+      writerModel: null,
+      ambiguous: false,
+    };
+  }
+
+  const triggerModel = /(trigger|log_entity_change|before\/after|before and after|current_setting\('app\.current_user_id'\)|навеш|триггер)/i.test(text);
+  const appModel = /(application[- ]code writer|app(?:lication)? writes|apply[- ]code writes|manual writer|writes entity_history manually|пишет entity_history|прикладн)/i.test(text);
+  const tableOnlyAmbiguity = /(table only|only table|таблиц[ауы].{0,80}без триггер|entity_history.{0,120}(without|no) trigger|helper pattern only|minimum is entity_history plus helper pattern)/i.test(text);
+  const eitherOrAmbiguity = /(trigger|триггер).{0,80}\b(or|или)\b.{0,80}(application|app|manual|код|вручн)/i.test(text)
+    || /(application|app|manual|код|вручн).{0,80}\b(or|или)\b.{0,80}(trigger|триггер)/i.test(text);
+  const ambiguous = tableOnlyAmbiguity || eitherOrAmbiguity || (!triggerModel && !appModel);
+  const writerModel = triggerModel && !eitherOrAmbiguity
+    ? 'db_trigger'
+    : appModel && !eitherOrAmbiguity
+      ? 'application_code'
+      : null;
+  return {
+    required,
+    present: Boolean(writerModel && !ambiguous),
+    writerModel,
+    ambiguous,
+  };
+}
+
 export function requiresUiAcceptanceScenarios(riskTriggers = []) {
   return riskTriggers.includes('panel-ui') || riskTriggers.includes('ui-visible-api');
 }
@@ -953,13 +1152,16 @@ export function inspectOptimizationStrategy(sections) {
     hasApproach: /strategy|approach|chosen|batch|map|set|index|query|window|memo|cache|подход|стратег/.test(normalized),
     hasAntiPatterns: /n\+1|repeated scan|nested|o\(n\^2\)|unbounded|full scan|render|anti-pattern|антипаттерн/.test(normalized),
     hasBudget: /budget|stop rule|stop-rule|minutes|минут|measurement|timing|benchmark|explain|defer|бюджет|лимит/.test(normalized),
+    hasMeasurementPath: /measurement|timing|benchmark|profile|profiling|explain|representative|smoke metric|human-owned fallback|blocked fallback|измер|замер|метрик/.test(normalized),
   };
+  const tierRequiresMeasurement = result.tier === 'O3';
   result.complete = Boolean(result.tier)
     && result.hasHotPaths
     && result.hasDataSize
     && result.hasApproach
     && result.hasAntiPatterns
-    && result.hasBudget;
+    && result.hasBudget
+    && (!tierRequiresMeasurement || result.hasMeasurementPath);
   result.present = result.complete;
   return result;
 }
@@ -1034,6 +1236,21 @@ function readCanonicalSection(sections, names) {
   return '';
 }
 
+function readLabeledValue(body, labels) {
+  for (const label of labels) {
+    const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = new RegExp(`${escaped}\\s*:\\s*([^\\n]+)`, 'i').exec(body);
+    if (match) {
+      return match[1].replace(/^[-\s`]*/, '').replace(/`+$/, '').trim();
+    }
+  }
+  return '';
+}
+
+function firstNonEmptyValue(values) {
+  return values.find((value) => typeof value === 'string' && value.trim()) || '';
+}
+
 export function buildCheckerContextPack({
   taskId,
   risk,
@@ -1313,6 +1530,28 @@ export function validateExecutionEvidenceForPlan({ planContent, executionContent
     }
   }
 
+  if (planRequiresRealMigrationApply(planContent)) {
+    const evidence = readAnySection(executionSections, [
+      'migration apply evidence',
+      'schema migration evidence',
+      'production rollout evidence',
+      'rollout evidence',
+      'preflight evidence',
+      'micro-verify evidence',
+    ]);
+    if (!evidence) {
+      errors.push({
+        category: 'unrun_required_check',
+        message: 'Schema/migration plan requires real disposable/scratch DB apply evidence before Verify/Human Gate.',
+      });
+    } else if (!/(apply|migrate|psql|migration|db push)/i.test(evidence) || !/(pass|passed|success|ok|applied|успеш)/i.test(evidence) || !/(scratch|throwaway|disposable|temporary|temp|ephemeral|test database|local postgres|railway postgres|однораз|временн|тестов)/i.test(evidence)) {
+      errors.push({
+        category: 'insufficient_evidence',
+        message: 'Migration Apply Evidence must show a successful apply/migrate/psql run against a disposable/scratch database target.',
+      });
+    }
+  }
+
   if (hasAnySection(planSections, ['source sync / provider gate', 'source sync provider gate', 'source sync gate', 'provider gate'])) {
     const evidence = readAnySection(executionSections, ['source sync / provider evidence', 'source sync evidence', 'provider evidence']);
     if (!evidence) {
@@ -1331,6 +1570,16 @@ export function validateExecutionEvidenceForPlan({ planContent, executionContent
   return errors;
 }
 
+function planRequiresRealMigrationApply(planContent) {
+  const sections = parseMarkdownSections(planContent || '');
+  const planText = planContent || '';
+  const hasMigration = /(schema\.prisma|prisma\/migrations|migration|migrations?|create table|alter table|plain sql|DDL|схем|миграц)/i.test(planText);
+  if (!hasMigration) {
+    return false;
+  }
+  return inspectMigrationApplyPlan(sections, ['prisma-schema']).present;
+}
+
 function hasAnySection(sections, names) {
   return Boolean(readAnySection(sections, names));
 }