@besales/ops-framework 0.1.18 → 0.1.21

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

@@ -13,12 +13,18 @@ import {
   riskRootWarnings,
   selectRelevantPlaybookNames,
   inspectComplexityPerformanceBudget,
+  inspectExecutionMetadata,
+  inspectAuditWriterModel,
+  inspectMigrationApplyPlan,
   inspectOptimizationStrategy,
   inspectProductionRolloutGate,
   inspectSourceSyncProviderGate,
+  inspectStandardsAlignment,
   inspectUiAcceptanceScenarios,
+  inspectVerificationLadder,
   parseMarkdownSections,
   requiresOptimizationStrategy,
+  requiresStandardsAlignment,
   validateExecutionEvidenceForPlan,
 } from './check-context-utils.mjs';
 
@@ -49,6 +55,176 @@ describe('agent pipeline quality gates', () => {
     expect(result.missingSignals).toContain('UI-visible risk detected but `## UI Acceptance Scenarios` is missing or incomplete.');
   });
 
+  it('blocks external check locally when execution metadata is placeholder-only', () => {
+    const plan = [
+      '# Plan',
+      '',
+      '## Risk tier and execution budget',
+      '',
+      '- Risk tier: `R0 | R1 | R2 | R3 | R4 | R5`',
+      '- Speed mode: `Fast | Standard | Strict`',
+      '- Approved execution target:',
+      '- Fast-loop allowed inside this slice:',
+      '- Requires return to Plan/Check if:',
+    ].join('\n');
+
+    const result = analyzePlanQualityGates({
+      planContent: plan,
+      risk: {
+        riskProfile: 'low',
+        riskTriggers: ['docs-only'],
+      },
+    });
+
+    expect(result.executionMetadata.present).toBe(false);
+    expect(result.missingSignals).toContain('Plan must include `## Risk tier and execution budget` with explicit risk tier, speed mode, execution target and budget/stop rule.');
+  });
+
+  it('accepts explicit execution metadata and verification ladder', () => {
+    const sections = parseMarkdownSections([
+      '# Plan',
+      '',
+      '## Risk tier and execution budget',
+      '',
+      '- Risk tier: `R2`',
+      '- Speed mode: `Standard`',
+      '- Approved execution target: local schema files and API DTOs only.',
+      '- Fast-loop allowed inside this slice: yes, until migration scope changes.',
+      '- Requires return to Plan/Check if: destructive migration or production data write appears.',
+      '',
+      '## План проверки',
+      '',
+      '### Verification ladder',
+      '',
+      '- Micro-verify during Execute: node --check.',
+      '- Slice-verify before completion: tests.',
+      '- External Verify required before closeout: no, internal_supervisor is enough.',
+    ].join('\n'));
+
+    expect(inspectExecutionMetadata(sections).present).toBe(true);
+    expect(inspectVerificationLadder(sections).present).toBe(true);
+  });
+
+  it('requires standards alignment only when standards references are present', () => {
+    expect(requiresStandardsAlignment({
+      referencedFiles: ['../.claude/CLAUDE.MD'],
+      structuralLines: [],
+    })).toBe(true);
+    expect(requiresStandardsAlignment({
+      referencedFiles: ['docs/01-overview.md'],
+      structuralLines: [],
+    })).toBe(false);
+
+    const missing = analyzePlanQualityGates({
+      planContent: '# Plan\n',
+      risk: {
+        riskProfile: 'low',
+        riskTriggers: ['docs-only'],
+      },
+      referencedFiles: ['../.claude/CLAUDE.MD'],
+    });
+    expect(missing.missingSignals).toContain('Standards file/reference detected but `## Global Standards Alignment` / `## Standards Alignment` is missing or incomplete.');
+
+    const sections = parseMarkdownSections([
+      '# Plan',
+      '',
+      '## Global Standards Alignment',
+      '',
+      '- Local interpretation: apply repo naming and validation rules to this task.',
+      '- Validation: run lint/test commands from the plan.',
+    ].join('\n'));
+    expect(inspectStandardsAlignment(sections).present).toBe(true);
+  });
+
+  it('requires a real disposable migration apply path for schema work before external check', () => {
+    const result = analyzePlanQualityGates({
+      planContent: [
+        '# Plan',
+        '',
+        '## Risk tier and execution budget',
+        '',
+        '- Risk tier: `R3`',
+        '- Speed mode: `Standard`',
+        '- Approved execution target: plain SQL migration.',
+        '- Requires return to Plan/Check if: database apply cannot run.',
+        '',
+        '## План проверки',
+        '',
+        '### Verification ladder',
+        '',
+        '- Micro-verify during Execute: static SQL review.',
+        '- Slice-verify before completion: blocked if Postgres unavailable.',
+        '- External Verify required before closeout: no.',
+        '',
+        '## Production Rollout Gate',
+        '',
+        '- Impact / blast radius: local schema migration only.',
+        '- Environment / deploy variables: none.',
+        '- Rollback / disable path: revert migration file.',
+        '- Post-deploy evidence: static SQL review if Postgres unavailable.',
+      ].join('\n'),
+      risk: {
+        riskProfile: 'high',
+        riskTriggers: ['prisma-schema'],
+      },
+    });
+
+    expect(result.migrationApply.required).toBe(true);
+    expect(result.migrationApply.present).toBe(false);
+    expect(result.missingSignals).toContain('Schema/migration work requires a real apply path on a disposable/scratch database before closeout; static SQL review alone is not enough.');
+  });
+
+  it('accepts migration apply plan with disposable database target', () => {
+    const sections = parseMarkdownSections([
+      '# Plan',
+      '',
+      '## Production Rollout Gate',
+      '',
+      '- Impact / blast radius: local schema migration only.',
+      '- Environment / deploy variables: temporary Railway Postgres scratch database.',
+      '- Rollback / disable path: drop scratch database and revert migration file.',
+      '- Post-deploy evidence: apply plain SQL migration with psql against throwaway Postgres; static SQL review alone is not enough.',
+    ].join('\n'));
+
+    const result = inspectMigrationApplyPlan(sections, ['prisma-schema']);
+
+    expect(result.present).toBe(true);
+    expect(result.hasApplyCommand).toBe(true);
+    expect(result.hasDisposableTarget).toBe(true);
+  });
+
+  it('requires audit writer model when entity_history audit is in scope', () => {
+    const sections = parseMarkdownSections([
+      '# Plan',
+      '',
+      '## Риски и открытые вопросы',
+      '',
+      '- Full audit triggers may expand scope; minimum is entity_history plus helper pattern.',
+    ].join('\n'));
+
+    const result = inspectAuditWriterModel(sections, Array.from(sections.values()).join('\n'));
+
+    expect(result.required).toBe(true);
+    expect(result.present).toBe(false);
+    expect(result.ambiguous).toBe(true);
+  });
+
+  it('accepts explicit DB trigger audit writer model', () => {
+    const sections = parseMarkdownSections([
+      '# Plan',
+      '',
+      '## Шаги реализации',
+      '',
+      '- Create entity_history.',
+      "- Create log_entity_change trigger function using current_setting('app.current_user_id') and attach triggers to core tables for before/after audit.",
+    ].join('\n'));
+
+    const result = inspectAuditWriterModel(sections, Array.from(sections.values()).join('\n'));
+
+    expect(result.present).toBe(true);
+    expect(result.writerModel).toBe('db_trigger');
+  });
+
   it('accepts UI acceptance scenarios with intent, steps, expected visible result and must-catch regressions', () => {
     const sections = parseMarkdownSections([
       '# Plan',
@@ -199,6 +375,54 @@ describe('agent pipeline quality gates', () => {
     expect(result.hasApproach).toBe(true);
     expect(result.hasAntiPatterns).toBe(true);
     expect(result.hasBudget).toBe(true);
+    expect(result.hasMeasurementPath).toBe(true);
+  });
+
+  it('requires a measurement path for O3 optimization strategy before external check', () => {
+    const result = analyzePlanQualityGates({
+      planContent: [
+        '# Plan',
+        '',
+        '## Risk tier and execution budget',
+        '',
+        '- Risk tier: `R3`',
+        '- Speed mode: `Standard`',
+        '- Approved execution target: worker hot path.',
+        '- Requires return to Plan/Check if: budget changes.',
+        '',
+        '## План проверки',
+        '',
+        '### Verification ladder',
+        '',
+        '- Micro-verify during Execute: unit test.',
+        '- Slice-verify before completion: smoke test.',
+        '- External Verify required before closeout: no.',
+        '',
+        '## Complexity / Performance Budget',
+        '',
+        '- Hot paths: worker materializer.',
+        '- Expected data size / row counts: 150k rows.',
+        '- Complexity risks: N+1 queries.',
+        '- Budget / stop rule: < 3 seconds.',
+        '',
+        '## Optimization Strategy',
+        '',
+        '- Optimization tier: O3 measured review.',
+        '- Hot paths: worker materializer.',
+        '- Expected data size / row counts: 150k rows.',
+        '- Chosen efficient approach: batch query and indexed lookup.',
+        '- Anti-patterns avoided: N+1 queries and repeated scans.',
+        '- Optimizer budget / stop rule: one focused review; defer speculative ideas.',
+      ].join('\n'),
+      risk: {
+        riskProfile: 'high',
+        riskTriggers: ['production-runtime'],
+      },
+    });
+
+    expect(result.optimizationTier).toBe('O3');
+    expect(result.optimizationStrategy.present).toBe(false);
+    expect(result.missingSignals).toContain('Optimization tier O3 detected but `## Optimization Strategy` is missing or incomplete.');
   });
 
   it('builds a checker context pack with exact quality-gate questions', () => {
@@ -431,6 +655,42 @@ describe('agent pipeline quality gates', () => {
     expect(issues).toEqual([]);
   });
 
+  it('pre-verify evidence gate blocks migration plans without successful scratch DB apply evidence', () => {
+    const plan = [
+      '# Plan',
+      '',
+      '## Production Rollout Gate',
+      '',
+      '- Impact / blast radius: local schema migration only.',
+      '- Environment / deploy variables: temporary Railway Postgres scratch database.',
+      '- Rollback / disable path: drop scratch database and revert migration file.',
+      '- Post-deploy evidence: apply plain SQL migration with psql against throwaway Postgres; static SQL review alone is not enough.',
+      '',
+      '## Шаги реализации',
+      '',
+      '- Create plain SQL migration with CREATE TABLE statements.',
+    ].join('\n');
+    const execution = [
+      '# Execution',
+      '',
+      '## Production Rollout Evidence',
+      '',
+      '| Check | Result | Evidence | Notes |',
+      '| --- | --- | --- | --- |',
+      '| migration | blocked | Postgres unavailable; static SQL review only | n/a |',
+    ].join('\n');
+
+    const issues = validateExecutionEvidenceForPlan({
+      planContent: plan,
+      executionContent: execution,
+    });
+
+    expect(issues).toContainEqual({
+      category: 'insufficient_evidence',
+      message: 'Migration Apply Evidence must show a successful apply/migrate/psql run against a disposable/scratch database target.',
+    });
+  });
+
   it('requires production rollout gate for production runtime triggers', () => {
     const result = analyzePlanQualityGates({
       planContent: '# Plan\n\n## Затронутые модули и файлы\n\n- deploy runtime env variable for worker',

package/bin/lib/execution-ledger-utils.mjs

@@ -33,6 +33,11 @@ export function buildExecutionLedger({
 }) {
   const git = collectGitExecutionState({ repoRoot, taskDir });
   const taskArtifacts = listTaskArtifacts(taskDir);
+  const executionMentionedFiles = readExecutionMentionedFiles(taskDir);
+  const changedFiles = git.changedFiles.map((file) => ({
+    ...file,
+    isExecutionMentioned: executionMentionedFiles.has(file.path),
+  }));
 
   return {
     schemaVersion: 1,
@@ -42,8 +47,8 @@ export function buildExecutionLedger({
     executionSha,
     git: {
       taskRelativePath: git.taskRelativePath,
-      changedFiles: compactLedgerFiles(git.changedFiles),
-      unrelatedDirtyFiles: compactLedgerFiles(git.changedFiles.filter((file) => !file.isTaskArtifact && !file.isOpsFrameworkFile)),
+      changedFiles: compactLedgerFiles(changedFiles),
+      unrelatedDirtyFiles: compactLedgerFiles(changedFiles.filter((file) => !file.isTaskArtifact && !file.isOpsFrameworkFile && !file.isExecutionMentioned)),
     },
     taskArtifacts,
     notes: [
@@ -59,6 +64,7 @@ function compactLedgerFiles(files) {
     status: file.status,
     isTaskArtifact: file.isTaskArtifact,
     isOpsFrameworkFile: file.isOpsFrameworkFile,
+    isExecutionMentioned: Boolean(file.isExecutionMentioned),
   }));
 }
 
@@ -145,6 +151,20 @@ function listTaskArtifacts(taskDir) {
     }));
 }
 
+function readExecutionMentionedFiles(taskDir) {
+  const executionPath = path.join(taskDir, 'execution.md');
+  if (!fs.existsSync(executionPath)) {
+    return new Set();
+  }
+  const content = fs.readFileSync(executionPath, 'utf8');
+  const refs = new Set();
+  const pathPattern = /`([^`\n]+\/[^`\n]+)`/g;
+  for (const match of content.matchAll(pathPattern)) {
+    refs.add(normalizePath(match[1].trim()));
+  }
+  return refs;
+}
+
 function runGitLines(repoRoot, args) {
   const result = spawnSync('git', args, {
     cwd: repoRoot,

package/bin/lib/execution-ledger-utils.test.mjs

@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import {
+  buildExecutionLedger,
   mergeChangedFiles,
   parseGitStatusLine,
 } from './execution-ledger-utils.mjs';
@@ -71,4 +76,59 @@ describe('execution ledger utils', () => {
       }),
     ]);
   });
+
+  it('does not classify execution-mentioned files as unrelated dirty files', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-ledger-repo-'));
+    run(repoRoot, ['init']);
+    run(repoRoot, ['config', 'user.email', 'test@example.com']);
+    run(repoRoot, ['config', 'user.name', 'Test User']);
+    fs.mkdirSync(path.join(repoRoot, 'apps', 'api'), { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, 'docs'), { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, 'apps', 'api', 'package.json'), '{}\n');
+    fs.writeFileSync(path.join(repoRoot, 'docs', 'source.md'), 'source\n');
+    run(repoRoot, ['add', '.']);
+    run(repoRoot, ['commit', '-m', 'initial']);
+
+    fs.writeFileSync(path.join(repoRoot, 'apps', 'api', 'package.json'), '{"type":"module"}\n');
+    fs.writeFileSync(path.join(repoRoot, 'docs', 'source.md'), 'dirty source\n');
+
+    const taskDir = path.join(repoRoot, 'ops', 'agent-pipeline', 'tasks', 'TASK-999-example');
+    fs.mkdirSync(taskDir, { recursive: true });
+    fs.writeFileSync(path.join(taskDir, 'execution.md'), [
+      '# Execution',
+      '',
+      '## Измененные файлы',
+      '',
+      '| File | Change summary | Planned item / reason |',
+      '| --- | --- | --- |',
+      '| `apps/api/package.json` | package setup | planned |',
+    ].join('\n'));
+
+    const ledger = buildExecutionLedger({
+      taskId: 'TASK-999-example',
+      taskDir,
+      repoRoot,
+      planSha: 'sha256:plan',
+      executionSha: 'sha256:execution',
+    });
+
+    expect(ledger.git.changedFiles).toContainEqual(expect.objectContaining({
+      path: 'apps/api/package.json',
+      isExecutionMentioned: true,
+    }));
+    expect(ledger.git.unrelatedDirtyFiles.map((file) => file.path)).not.toContain('apps/api/package.json');
+    expect(ledger.git.unrelatedDirtyFiles.map((file) => file.path)).toContain('docs/source.md');
+
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
 });
+
+function run(cwd, args) {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+  });
+  if (result.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${result.stdout}${result.stderr}`);
+  }
+}

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

@@ -254,23 +254,27 @@ export function buildVerifierLlmInputPack({
 }) {
   const selectedMode = normalizeLlmContextMode(mode) || 'standard';
   const taskArtifacts = selectedMode === 'strict'
-    ? readArtifacts(taskDir, [
-        'brief.md',
-        'research.md',
-        'plan.md',
-        'task-manifest.json',
-        'check.result.json',
-        'check.md',
-        'check-resolution.md',
-        'human-gate-summary.md',
-        'execution.md',
-        'execution-ledger.json',
-        'verify.md',
-        'status.md',
-        'feedback.md',
-        'execution-feedback.md',
-        'orchestration-log.md',
-      ], 'full')
+    ? {
+        'brief.md': readTaskFile(taskDir, 'brief.md'),
+        'research.md': readTaskFile(taskDir, 'research.md'),
+        'plan.md': readTaskFile(taskDir, 'plan.md'),
+        'task-manifest.json': readTaskFile(taskDir, 'task-manifest.json'),
+        'check.result.json': readTaskFile(taskDir, 'check.result.json'),
+        'check.md': compactCheckMarkdown({
+          checkMarkdown: readTaskFile(taskDir, 'check.md'),
+          checkResult: readOptionalJson(taskDir, 'check.result.json'),
+          mode: 'standard',
+        }),
+        'check-resolution.md': compactArtifact(taskDir, 'check-resolution.md', 'standard', ['structured resolution', 'root cause', 'resolution']),
+        'human-gate-summary.md': truncateMiddle(readTaskFile(taskDir, 'human-gate-summary.md'), 3500),
+        'execution.md': readTaskFile(taskDir, 'execution.md'),
+        'execution-ledger.json': compactExecutionLedger(readOptionalJson(taskDir, 'execution-ledger.json'), 'strict'),
+        'verify.md': compactVerifierMarkdown(readTaskFile(taskDir, 'verify.md'), readOptionalJson(taskDir, 'verify.result.json'), 'standard'),
+        'status.md': compactStatus(readTaskFile(taskDir, 'status.md')),
+        'feedback.md': compactArtifact(taskDir, 'feedback.md', 'standard', ['feedback event', 'classification', 'supervisor decision']),
+        'execution-feedback.md': compactArtifact(taskDir, 'execution-feedback.md', 'standard', ['feedback event', 'classification', 'supervisor decision']),
+        'orchestration-log.md': compactOrchestrationLog(readTaskFile(taskDir, 'orchestration-log.md'), 'standard'),
+      }
     : {
         'brief.md': compactArtifact(taskDir, 'brief.md', selectedMode, ['goal', 'scope', 'success criteria']),
         'research.md': compactArtifact(taskDir, 'research.md', selectedMode, ['findings', 'evidence', 'repo']),
@@ -285,8 +289,8 @@ export function buildVerifierLlmInputPack({
         'check-resolution.md': truncateMiddle(readTaskFile(taskDir, 'check-resolution.md'), charLimitForMode(selectedMode, 1500, 3500)),
         'human-gate-summary.md': truncateMiddle(readTaskFile(taskDir, 'human-gate-summary.md'), charLimitForMode(selectedMode, 1200, 2500)),
         'execution.md': compactArtifact(taskDir, 'execution.md', selectedMode, VERIFY_EXECUTION_SECTIONS),
-        'execution-ledger.json': readTaskFile(taskDir, 'execution-ledger.json'),
-        'verify.md': compactArtifact(taskDir, 'verify.md', selectedMode, ['verdict', 'findings', 'residual risks', 'recommended next step']),
+        'execution-ledger.json': compactExecutionLedger(readOptionalJson(taskDir, 'execution-ledger.json'), selectedMode),
+        'verify.md': compactVerifierMarkdown(readTaskFile(taskDir, 'verify.md'), readOptionalJson(taskDir, 'verify.result.json'), selectedMode),
         'status.md': compactStatus(readTaskFile(taskDir, 'status.md')),
         'feedback.md': compactArtifact(taskDir, 'feedback.md', selectedMode, ['feedback event', 'classification', 'supervisor decision']),
         'orchestration-log.md': compactOrchestrationLog(readTaskFile(taskDir, 'orchestration-log.md'), selectedMode),
@@ -483,6 +487,72 @@ function compactOrchestrationLog(log, mode) {
   return markCompacted('orchestration-log.md', log, compacted);
 }
 
+function compactVerifierMarkdown(verifyMarkdown, verifyResult, mode) {
+  if (!verifyMarkdown.trim()) {
+    return '';
+  }
+  const findings = Array.isArray(verifyResult?.findings) ? verifyResult.findings : [];
+  const lines = [
+    '# Verify compact excerpt',
+    '',
+    `Verdict: ${verifyResult?.verdict || 'unknown'}`,
+    `Verifier run: ${verifyResult?.verifierRunId || 'unknown'}`,
+    `Findings: ${findings.length}`,
+    '',
+    compactMarkdownSections(verifyMarkdown, ['verdict', 'findings', 'residual risks', 'recommended next step'], charLimitForMode(mode, 1600, 3200)),
+    '',
+    ...findings.map((finding) => [
+      `## ${finding.id || 'finding'}`,
+      `- Severity: ${finding.severity || 'unknown'}`,
+      `- Category: ${finding.claimCategory || 'unknown'}`,
+      `- Affected artifacts: ${truncateEnd(JSON.stringify(finding.affectedArtifacts || []), 250)}`,
+      '- Evidence refs:',
+      ...formatRefs(finding.evidenceRefs || [], 220),
+      `- Claim: ${truncateEnd(finding.claim || '', 700)}`,
+      `- Expected correction: ${truncateEnd(finding.expectedCorrection || '', 700)}`,
+    ].join('\n')),
+  ];
+  return markCompacted('verify.md', verifyMarkdown, lines.join('\n').trim());
+}
+
+function compactExecutionLedger(ledger, mode) {
+  if (!ledger || typeof ledger !== 'object' || Array.isArray(ledger)) {
+    return '{}';
+  }
+  const changedFiles = Array.isArray(ledger.git?.changedFiles) ? ledger.git.changedFiles : [];
+  const unrelatedDirtyFiles = Array.isArray(ledger.git?.unrelatedDirtyFiles) ? ledger.git.unrelatedDirtyFiles : [];
+  const limit = mode === 'fast' ? 40 : mode === 'standard' ? 90 : 160;
+  const compact = {
+    schemaVersion: ledger.schemaVersion,
+    taskId: ledger.taskId,
+    createdAt: ledger.createdAt,
+    planSha: ledger.planSha,
+    executionSha: ledger.executionSha,
+    git: {
+      taskRelativePath: ledger.git?.taskRelativePath || null,
+      changedFileCount: changedFiles.length,
+      unrelatedDirtyFileCount: unrelatedDirtyFiles.length,
+      changedFiles: changedFiles.slice(0, limit).map(compactLedgerFile),
+      unrelatedDirtyFiles: unrelatedDirtyFiles.slice(0, limit).map(compactLedgerFile),
+      truncatedChangedFiles: Math.max(0, changedFiles.length - limit),
+      truncatedUnrelatedDirtyFiles: Math.max(0, unrelatedDirtyFiles.length - limit),
+    },
+    taskArtifacts: Array.isArray(ledger.taskArtifacts) ? ledger.taskArtifacts : [],
+    notes: ledger.notes || [],
+  };
+  return markCompacted('execution-ledger.json', JSON.stringify(ledger, null, 2), JSON.stringify(compact, null, 2));
+}
+
+function compactLedgerFile(file) {
+  return {
+    path: file.path,
+    status: file.status,
+    isTaskArtifact: Boolean(file.isTaskArtifact),
+    isOpsFrameworkFile: Boolean(file.isOpsFrameworkFile),
+    isExecutionMentioned: Boolean(file.isExecutionMentioned),
+  };
+}
+
 function compactProjectMemory(projectMemory, mode) {
   if (mode === 'strict') {
     return projectMemory;

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

@@ -62,9 +62,10 @@ describe('llm input pack utilities', () => {
     expect(pack.meta.compactedArtifacts).toContain('orchestration-log.md');
   });
 
-  it('keeps full artifacts in strict verifier pack', () => {
-    const taskDir = createTask({ orchestrationEvents: 8 });
+  it('compacts generated review artifacts in strict verifier pack', () => {
+    const taskDir = createTask({ orchestrationEvents: 80 });
     const fullLog = fs.readFileSync(path.join(taskDir, 'orchestration-log.md'), 'utf8');
+    const fullExecution = fs.readFileSync(path.join(taskDir, 'execution.md'), 'utf8');
     const pack = buildVerifierLlmInputPack({
       taskDir,
       taskId: 'TASK-999-token-pack',
@@ -74,8 +75,12 @@ describe('llm input pack utilities', () => {
       mode: 'strict',
     });
 
-    expect(pack.input.taskArtifacts['orchestration-log.md']).toBe(fullLog);
-    expect(pack.meta.compactedArtifacts).not.toContain('orchestration-log.md');
+    expect(pack.input.taskArtifacts['execution.md']).toBe(fullExecution);
+    expect(pack.input.taskArtifacts['orchestration-log.md']).toContain('# Orchestration Log Compact');
+    expect(pack.input.taskArtifacts['orchestration-log.md'].length).toBeLessThan(fullLog.length);
+    expect(pack.input.taskArtifacts['verify.md']).toContain('# Verify compact excerpt');
+    expect(pack.meta.compactedArtifacts).toContain('orchestration-log.md');
+    expect(pack.meta.compactedArtifacts).toContain('verify.md');
   });
 
   it('builds bounded fallback mode sequence for context insufficient results', () => {
@@ -246,6 +251,8 @@ function createTask({ orchestrationEvents = 40 } = {}) {
   write(taskDir, 'status.md', '# Status\n\n## Текущий этап\n\nverify\n\n## Следующий шаг\n\nRun verify.');
   write(taskDir, 'check.result.json', JSON.stringify({ verdict: 'ready_for_human_gate', findings: [] }, null, 2));
   write(taskDir, 'check.md', '# Check\n\n## Итоговая оценка\n\nReady.');
+  write(taskDir, 'verify.result.json', JSON.stringify({ verdict: 'return_to_execute', findings: [] }, null, 2));
+  write(taskDir, 'verify.md', '# Verify\n\n## verdict\n\nreturn_to_execute\n\n## findings\n\nPrevious finding.');
   write(taskDir, 'execution-ledger.json', JSON.stringify({ git: { changedFiles: [] } }, null, 2));
   write(taskDir, 'task-manifest.json', JSON.stringify({ context: { riskTriggers: ['panel-ui'] } }, null, 2));
   write(taskDir, 'orchestration-log.md', [

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

@@ -26,7 +26,18 @@ describe('task manifest utilities', () => {
         '',
         '## Risk tier and execution budget',
         '',
+        '- Risk tier: `R1`',
         '- Speed mode: `Fast`',
+        '- Approved execution target: docs/example.md only.',
+        '- Requires return to Plan/Check if: code changes are needed.',
+        '',
+        '## План проверки',
+        '',
+        '### Verification ladder',
+        '',
+        '- Micro-verify during Execute: markdown review.',
+        '- Slice-verify before completion: self-test.',
+        '- External Verify required before closeout: no.',
         '',
         '## Затронутые модули и файлы',
         '',
@@ -94,7 +105,18 @@ describe('task manifest utilities', () => {
         '',
         '## Risk tier and execution budget',
         '',
+        '- Risk tier: `R1`',
         '- Speed mode: `Fast`',
+        '- Approved execution target: docs/example.md only.',
+        '- Requires return to Plan/Check if: code changes are needed.',
+        '',
+        '## План проверки',
+        '',
+        '### Verification ladder',
+        '',
+        '- Micro-verify during Execute: markdown review.',
+        '- Slice-verify before completion: self-test.',
+        '- External Verify required before closeout: no.',
         '',
         '## Затронутые модули и файлы',
         '',