@besales/ops-framework 0.1.20 → 0.1.22

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.22
+
+- Added a compact `standard_plus` LLM context mode between `standard` and `strict` so near-cap Check/Verify runs avoid full strict context when compact evidence is sufficient.
+- Refreshed `task-manifest.json` after successful Check and cache hits so `lastCheckResult` reflects the final current verdict instead of stale `return_to_plan` results.
+
+## 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.

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

@@ -8,10 +8,11 @@ import {
   renderRelevantPlaybooks,
 } from './check-context-utils.mjs';
 
-export const LLM_CONTEXT_MODES = ['fast', 'standard', 'strict'];
+export const LLM_CONTEXT_MODES = ['fast', 'standard', 'standard_plus', 'strict'];
 export const LLM_CONTEXT_CAPS = {
   fast: 8000,
   standard: 20000,
+  standard_plus: 26000,
   strict: 45000,
 };
 
@@ -20,6 +21,7 @@ const PACK_CAP_SAFETY_MULTIPLIER = 1.15;
 const MEMORY_MAX_CHARS = {
   fast: 3000,
   standard: 3500,
+  standard_plus: 4500,
   strict: Infinity,
 };
 
@@ -163,6 +165,9 @@ export function nextLlmContextMode(mode) {
     return 'standard';
   }
   if (mode === 'standard') {
+    return 'standard_plus';
+  }
+  if (mode === 'standard_plus') {
     return 'strict';
   }
   return null;
@@ -215,8 +220,8 @@ export function buildCheckerLlmInputPack({
       fullContextAvailableViaStrict: selectedMode !== 'strict',
       contextInsufficientFallback: selectedMode === 'strict' ? 'stop_and_report' : `rerun_${nextLlmContextMode(selectedMode)}`,
     },
-    checkEvidence: compactGeneratedMarkdown('check-evidence.md', checkEvidence, selectedMode, { fast: 2800, standard: 4000 }),
-    checkerContextPack: compactGeneratedMarkdown('checker-context-pack.md', checkerContextPack, selectedMode, { fast: 3300, standard: 4600 }),
+    checkEvidence: compactGeneratedMarkdown('check-evidence.md', checkEvidence, selectedMode, { fast: 2800, standard: 4000, standard_plus: 5600 }),
+    checkerContextPack: compactGeneratedMarkdown('checker-context-pack.md', checkerContextPack, selectedMode, { fast: 3300, standard: 4600, standard_plus: 6200 }),
     relevantPlaybooks: selectedMode === 'strict'
       ? renderRelevantPlaybooks(readRelevantPlaybooks(checkContext.riskTriggers || []), { mode: 'strict' })
       : renderRelevantPlaybooks(readRelevantPlaybooks(checkContext.riskTriggers || []), { mode: 'compact' }),
@@ -254,23 +259,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 +294,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 +492,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 : mode === 'standard_plus' ? 120 : 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;
@@ -510,7 +585,11 @@ function compactGeneratedMarkdown(fileName, content, mode, limits) {
   if (mode === 'strict' || !content) {
     return content;
   }
-  const limit = mode === 'fast' ? limits.fast : limits.standard;
+  const limit = mode === 'fast'
+    ? limits.fast
+    : mode === 'standard_plus'
+      ? limits.standard_plus || Math.ceil(limits.standard * 1.35)
+      : limits.standard;
   return markCompacted(fileName, content, truncateMiddle(content, limit));
 }
 
@@ -637,7 +716,13 @@ function isProtectedSection(value) {
 }
 
 function charLimitForMode(mode, fastChars, standardChars) {
-  return mode === 'fast' ? fastChars : standardChars;
+  if (mode === 'fast') {
+    return fastChars;
+  }
+  if (mode === 'standard_plus') {
+    return Math.ceil(standardChars * 1.25);
+  }
+  return standardChars;
 }
 
 function readOptionalJson(taskDir, fileName) {

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,17 +75,49 @@ 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', () => {
-    expect(buildContextModeSequence('fast')).toEqual(['fast', 'standard', 'strict']);
-    expect(buildContextModeSequence('standard')).toEqual(['standard', 'strict']);
+    expect(buildContextModeSequence('fast')).toEqual(['fast', 'standard', 'standard_plus', 'strict']);
+    expect(buildContextModeSequence('standard')).toEqual(['standard', 'standard_plus', 'strict']);
+    expect(buildContextModeSequence('standard_plus')).toEqual(['standard_plus', 'strict']);
     expect(buildContextModeSequence('strict')).toEqual(['strict']);
     expect(isContextInsufficientResult({ verdict: 'context_insufficient' })).toBe(true);
   });
 
+  it('provides a compact standard_plus check mode before strict', () => {
+    const taskDir = createTask();
+    const pack = buildCheckerLlmInputPack({
+      taskDir,
+      taskId: 'TASK-999-token-pack',
+      checkerPromptSha: 'sha256:test',
+      cacheKey: { test: true },
+      checkContext: {
+        planSha: 'sha256:plan',
+        memorySha: 'sha256:memory',
+        riskProfile: 'high',
+        riskTriggers: ['source-sync-provider', 'prisma-schema'],
+      },
+      checkEvidence: '# Evidence\n\nok\n'.repeat(900),
+      checkerContextPack: '# Checker Context Pack\n\nok\n'.repeat(900),
+      taskManifest: '{}',
+      projectMemory: [],
+      mode: 'standard_plus',
+    });
+
+    expect(pack.meta.mode).toBe('standard_plus');
+    expect(pack.meta.capTokens).toBe(26000);
+    expect(pack.input.llmInputPolicy.contextInsufficientFallback).toBe('rerun_strict');
+    expect(pack.input.taskArtifacts['plan.md']).toContain('<!-- compacted:plan.md');
+    expect(pack.meta.compactedArtifacts).toContain('plan.md');
+  });
+
   it('preserves protected verification sections when compacting long plans', () => {
     const taskDir = createTask();
     const longPlan = [
@@ -246,6 +279,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/run-check.mjs

@@ -226,6 +226,7 @@ async function runMain() {
         rerunCount,
         timing: buildTiming(runStartedAt),
       });
+      refreshTaskManifestAfterCheck(taskDir);
       console.log(`Checker cache hit for ${taskId}: ${cacheKeySha}`);
       return;
     }
@@ -329,12 +330,22 @@ async function runMain() {
     rerunCount,
     timing: buildTiming(runStartedAt),
   });
+  refreshTaskManifestAfterCheck(taskDir);
   runValidator(taskArg);
   console.log(`Checker run completed for ${taskId}: ${providerOutput.checkResultJson?.verdict}`);
   console.log(`- finalLlmInputMode: ${promptPayload.pack.meta.mode}`);
   console.log(`- finalEstimatedInputTokens: ${promptPayload.pack.meta.estimatedTokens}`);
 }
 
+function refreshTaskManifestAfterCheck(taskDir) {
+  const manifest = buildTaskManifest({ taskDir });
+  writeTaskManifest(taskDir, manifest);
+  appendCheckTimeline(taskDir, {
+    event: 'task_manifest_refreshed_after_check',
+    lastCheckResult: manifest.lastCheckResult,
+  });
+}
+
 function appendCheckTimeline(taskDir, event) {
   const timelinePath = path.join(taskDir, 'check-timeline.json');
   let existing = [];

package/bin/run-verify.mjs

@@ -45,6 +45,13 @@ async function runMain() {
   const taskDir = resolveTaskDir(taskArg);
   const taskId = path.basename(taskDir);
   const verifierConfig = resolveVerifierConfig(args);
+  const runStartedAt = new Date();
+  appendVerifyTimeline(taskDir, {
+    event: 'verify_started',
+    mode: verifierConfig.mode,
+    provider: verifierConfig.provider,
+    model: verifierConfig.model,
+  });
   const planSha = hashTaskMarkdown(taskDir, 'plan.md');
   const executionSha = hashTaskMarkdown(taskDir, 'execution.md');
   const taskManifest = readOptionalJson(taskDir, 'task-manifest.json');
@@ -66,6 +73,12 @@ async function runMain() {
       executionSha,
       evidenceIssues,
     });
+    appendVerifyTimeline(taskDir, {
+      event: 'deterministic_preverify_blocked',
+      verdict: 'return_to_execute',
+      issues: evidenceIssues.map((issue) => issue.message),
+      timing: buildTiming(runStartedAt),
+    });
     console.log(`Verifier preflight blocked ${taskId}: return_to_execute`);
     console.log(`- evidenceIssues: ${evidenceIssues.length}`);
     return;
@@ -79,6 +92,11 @@ async function runMain() {
       planSha,
       executionSha,
     });
+    appendVerifyTimeline(taskDir, {
+      event: 'internal_supervisor_completed',
+      verdict: 'pass_with_notes',
+      timing: buildTiming(runStartedAt),
+    });
     console.log(`Internal supervisor Verify artifact written for ${taskId}: pass_with_notes`);
     return;
   }
@@ -109,12 +127,26 @@ async function runMain() {
       contextMode,
     });
     finalPack = promptPayload.pack;
+    appendVerifyTimeline(taskDir, {
+      event: 'llm_input_built',
+      contextMode,
+      verifierRunId,
+      packMeta: promptPayload.pack.meta,
+      timing: buildTiming(runStartedAt),
+    });
     console.log(`Verifier LLM input for ${taskId}`);
     for (const line of summarizePackForConsole(promptPayload.pack)) {
       console.log(line);
     }
     if (promptPayload.pack.meta.overCap && contextMode !== 'strict') {
       llmInputAttempts.push(buildAttemptRecord(promptPayload.pack.meta, 'skipped_over_cap'));
+      appendVerifyTimeline(taskDir, {
+        event: 'llm_input_over_cap_escalating',
+        contextMode,
+        verifierRunId,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       appendOrchestrationLog(taskDir, `verifier LLM input exceeded ${contextMode} cap; rerunning pack builder with expanded context`);
       continue;
     }
@@ -131,6 +163,13 @@ async function runMain() {
         message: `Strict LLM input pack exceeds cap: estimatedTokens=${promptPayload.pack.meta.estimatedTokens}, capTokens=${promptPayload.pack.meta.capTokens}`,
         rawOutput: null,
       });
+      appendVerifyTimeline(taskDir, {
+        event: 'context_overflow',
+        contextMode,
+        verifierRunId,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       recordLlmInputUsage({
         taskDir,
         stage: 'verify',
@@ -143,6 +182,17 @@ async function runMain() {
     }
 
     try {
+      const providerStartedAt = new Date();
+      appendVerifyTimeline(taskDir, {
+        event: 'provider_started',
+        provider: verifierConfig.provider,
+        model: verifierConfig.model,
+        reasoningEffort: verifierConfig.reasoningEffort,
+        contextMode,
+        verifierRunId,
+        packMeta: promptPayload.pack.meta,
+        timing: buildTiming(runStartedAt),
+      });
       output = await runExternalCliChecker({
         providerName: verifierConfig.provider,
         providerConfig: verifierConfig.providerConfig,
@@ -151,6 +201,15 @@ async function runMain() {
         prompt: promptPayload.prompt,
         cwd: repoRoot,
       });
+      appendVerifyTimeline(taskDir, {
+        event: 'provider_completed',
+        provider: verifierConfig.provider,
+        model: verifierConfig.model,
+        contextMode,
+        verifierRunId,
+        providerTiming: buildTiming(providerStartedAt),
+        timing: buildTiming(runStartedAt),
+      });
     } catch (error) {
       writeVerifierFailure({
         taskDir,
@@ -163,6 +222,16 @@ async function runMain() {
         message: error.message,
         rawOutput: error.rawOutput || null,
       });
+      appendVerifyTimeline(taskDir, {
+        event: 'provider_failed',
+        provider: verifierConfig.provider,
+        model: verifierConfig.model,
+        contextMode,
+        verifierRunId,
+        failureReason: error.failureReason || 'unknown',
+        message: error.message,
+        timing: buildTiming(runStartedAt),
+      });
       llmInputAttempts.push(buildAttemptRecord(promptPayload.pack.meta, `provider_failed:${error.failureReason || 'unknown'}`));
       recordLlmInputUsage({
         taskDir,
@@ -205,8 +274,17 @@ async function runMain() {
       packMeta: finalPack.meta,
       attempts: llmInputAttempts,
       rerunCount,
+      timing: buildTiming(runStartedAt),
     });
   }
+  appendVerifyTimeline(taskDir, {
+    event: 'verify_completed',
+    verdict: verifyResultJson.verdict,
+    verifierRunId,
+    finalMode: finalPack?.meta?.mode || null,
+    finalEstimatedTokens: finalPack?.meta?.estimatedTokens || null,
+    timing: buildTiming(runStartedAt),
+  });
   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}`);
@@ -216,6 +294,34 @@ async function runMain() {
   }
 }
 
+function buildTiming(startedAt, completedAt = new Date()) {
+  return {
+    startedAt: startedAt.toISOString(),
+    completedAt: completedAt.toISOString(),
+    durationMs: Math.max(0, completedAt.getTime() - startedAt.getTime()),
+  };
+}
+
+function appendVerifyTimeline(taskDir, event) {
+  const timelinePath = path.join(taskDir, 'verify-timeline.json');
+  let existing = [];
+  if (fs.existsSync(timelinePath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(timelinePath, 'utf8'));
+      if (Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    } catch {
+      existing = [];
+    }
+  }
+  existing.push({
+    at: new Date().toISOString(),
+    ...event,
+  });
+  writeTaskFile(taskDir, 'verify-timeline.json', JSON.stringify(existing, null, 2));
+}
+
 function buildAttemptRecord(packMeta, outcome) {
   return {
     mode: packMeta.mode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besales/ops-framework",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"