@besales/ops-framework 0.1.26 → 0.1.28

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.28
+
+- Added Verify reuse guard: a passing `verify.result.json` is reused when `plan.md` and `execution.md` hashes are unchanged, unless `--force` is passed.
+- Updated status after external Verify pass/fail/return verdicts so Supervisor routing does not keep asking for stale Verify reruns.
+- Routed passing Verify results to retrospective/learning closeout instead of repeated verifier loops.
+
+## 0.1.27
+
+- Updated internal Verify closeout behavior so `status.md` moves to retrospective/learning closeout instead of continuing to ask for external Verify.
+- Removed the default non-blocking "no independent verifier" finding from internal Verify for bounded local slices; external Verify remains an explicit escalation choice.
+- Added status updater support for latest Verify verdict/result and expected outcome sections.
+
 ## 0.1.26
 
 - Raised `standard_plus` context cap to 36k so compact Verify packs around 29-31k estimated tokens stay out of strict mode after safety margin.

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

@@ -431,7 +431,10 @@ export function updateStatus(taskDir, updates) {
     ['humanGateSummary', 'Human Gate summary'],
     ['feedbackIntake', 'Feedback intake'],
     ['executionFeedback', 'Execution feedback intake'],
+    ['verifyVerdict', 'Latest verify verdict'],
+    ['verifyResult', 'Latest verify result'],
     ['supervisorAction', 'Последнее действие supervisor'],
+    ['expectedOutcome', 'Что ожидается на выходе текущего этапа'],
     ['nextStep', 'Следующий шаг'],
     ['humanApproval', 'Нужен ли сейчас human approval'],
   ]);

package/bin/run-verify.mjs

@@ -12,6 +12,7 @@ import {
   resolveConfigValue,
   resolveTaskDir,
   sha256,
+  updateStatus,
   validateExecutionEvidenceForPlan,
   writeTaskFile,
 } from './lib/check-context-utils.mjs';
@@ -45,6 +46,7 @@ async function runMain() {
   const taskDir = resolveTaskDir(taskArg);
   const taskId = path.basename(taskDir);
   const verifierConfig = resolveVerifierConfig(args);
+  const force = getFlag(args, 'force', false) === true;
   const runStartedAt = new Date();
   appendVerifyTimeline(taskDir, {
     event: 'verify_started',
@@ -84,6 +86,25 @@ async function runMain() {
     return;
   }
 
+  const reusableVerify = readReusableVerifyResult({ taskDir, planSha, executionSha });
+  if (reusableVerify && !force) {
+    updateStatusForVerifyResult(taskDir, reusableVerify, {
+      reused: true,
+      verifierMode: reusableVerify.verificationMode || verifierConfig.mode,
+    });
+    appendVerifyTimeline(taskDir, {
+      event: 'verify_reused',
+      verdict: reusableVerify.verdict,
+      verifierRunId: reusableVerify.verifierRunId || null,
+      timing: buildTiming(runStartedAt),
+    });
+    appendOrchestrationLog(taskDir, `verify result reused; verdict=${reusableVerify.verdict}; plan/execution unchanged; use --force to rerun`);
+    console.log(`Verifier result reused for ${taskId}: ${reusableVerify.verdict}`);
+    console.log('- reason: plan.md and execution.md hashes match existing passing verify.result.json');
+    console.log('- use --force to rerun Verify anyway');
+    return;
+  }
+
   if (verifierConfig.mode === 'internal_supervisor') {
     writeInternalSupervisorVerify({
       taskDir,
@@ -267,6 +288,10 @@ async function runMain() {
 
   writeTaskFile(taskDir, 'verify.md', verifyMarkdown);
   writeTaskFile(taskDir, 'verify.result.json', JSON.stringify(verifyResultJson, null, 2));
+  updateStatusForVerifyResult(taskDir, verifyResultJson, {
+    reused: false,
+    verifierMode: 'external_cli',
+  });
   if (finalPack) {
     recordLlmInputUsage({
       taskDir,
@@ -302,6 +327,85 @@ function buildTiming(startedAt, completedAt = new Date()) {
   };
 }
 
+function readReusableVerifyResult({ taskDir, planSha, executionSha }) {
+  const result = readOptionalJson(taskDir, 'verify.result.json');
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    return null;
+  }
+  if (!['pass', 'pass_with_notes'].includes(String(result.verdict || '').toLowerCase())) {
+    return null;
+  }
+  if (result.planSha !== planSha || result.executionSha !== executionSha) {
+    return null;
+  }
+  if (result.readyForRetrospective !== true) {
+    return null;
+  }
+  return result;
+}
+
+function updateStatusForVerifyResult(taskDir, result, { reused = false, verifierMode = null } = {}) {
+  const verdict = String(result?.verdict || 'unknown').toLowerCase();
+  const mode = verifierMode || result?.verificationMode || 'unknown';
+  const commonResult = [
+    `- \`verify.result.json\`: \`${verdict}\``,
+    `- Verification mode: \`${mode}\``,
+    `- Ready for retrospective: \`${Boolean(result?.readyForRetrospective)}\``,
+    reused ? '- Reused: `true` (plan/execution unchanged)' : null,
+  ].filter(Boolean).join('\n');
+
+  if (['pass', 'pass_with_notes'].includes(verdict)) {
+    updateStatus(taskDir, {
+      stage: 'Verify complete',
+      verifyVerdict: `\`${verdict}\``,
+      verifyResult: commonResult,
+      supervisorAction: reused
+        ? 'Existing passing Verify result reused because plan/execution hashes are unchanged.'
+        : 'Verify completed with sufficient evidence for this slice.',
+      expectedOutcome: 'Retrospective, learning closeout, then task closeout.',
+      humanApproval: 'no',
+      nextStep: 'Run learning closeout / retrospective. Do not rerun Verify unless plan/execution changes or explicit --force/human escalation applies.',
+    });
+    return;
+  }
+
+  if (verdict === 'return_to_execute') {
+    updateStatus(taskDir, {
+      stage: 'Execute',
+      verifyVerdict: '`return_to_execute`',
+      verifyResult: commonResult,
+      supervisorAction: 'Verify returned blocking execution findings.',
+      expectedOutcome: 'Address blocking Verify findings, update execution evidence, then rerun Verify.',
+      humanApproval: 'no',
+      nextStep: 'Return to Execute and fix the blocking Verify findings before another Verify run.',
+    });
+    return;
+  }
+
+  if (verdict === 'return_to_plan') {
+    updateStatus(taskDir, {
+      stage: 'Plan',
+      verifyVerdict: '`return_to_plan`',
+      verifyResult: commonResult,
+      supervisorAction: 'Verify found plan/scope mismatch.',
+      expectedOutcome: 'Revise plan/check artifacts before Execute continues.',
+      humanApproval: 'maybe',
+      nextStep: 'Return to Plan and resolve the Verify findings before Execute continues.',
+    });
+    return;
+  }
+
+  updateStatus(taskDir, {
+    stage: 'Verify',
+    verifyVerdict: `\`${verdict}\``,
+    verifyResult: commonResult,
+    supervisorAction: 'Verify did not produce a passing result.',
+    expectedOutcome: 'Resolve verifier failure or request human decision.',
+    humanApproval: 'maybe',
+    nextStep: 'Resolve Verify result before continuing.',
+  });
+}
+
 function appendVerifyTimeline(taskDir, event) {
   const timelinePath = path.join(taskDir, 'verify-timeline.json');
   let existing = [];
@@ -532,29 +636,27 @@ function writeInternalSupervisorVerify({
     readyForRetrospective: true,
     counts: {
       blockingFindings: 0,
-      nonBlockingFindings: 1,
+      nonBlockingFindings: 0,
       questions: 0,
     },
-    findings: [
-      {
-        id: 'V-001',
-        severity: 'non_blocking',
-        claimCategory: 'insufficient_evidence',
-        affectedArtifacts: ['verify.md', 'verify.result.json'],
-        claim: 'Verify used internal supervisor mode, so no independent fresh-context verifier reviewed this execution.',
-        evidenceRefs: [
-          {
-            type: 'config',
-            ref: `verifier.mode=${verifierConfig.mode}`,
-          },
-        ],
-        expectedCorrection: 'Run `corepack yarn agent:run-verify <TASK> --verify-mode external_cli` if the task risk or human decision requires independent verification.',
-      },
-    ],
+    findings: [],
   };
 
   writeTaskFile(taskDir, 'verify.md', verifyMarkdown);
   writeTaskFile(taskDir, 'verify.result.json', JSON.stringify(result, null, 2));
+  updateStatus(taskDir, {
+    stage: 'Verify complete',
+    verifyVerdict: '`pass_with_notes`',
+    verifyResult: [
+      '- `verify.result.json`: `pass_with_notes`',
+      '- Verification mode: `internal_supervisor`',
+      '- Ready for retrospective: `true`',
+    ].join('\n'),
+    supervisorAction: 'Internal Verify completed with sufficient local evidence for this bounded slice.',
+    expectedOutcome: 'Retrospective, learning closeout, then task closeout.',
+    humanApproval: 'no',
+    nextStep: 'Run learning closeout / retrospective. Do not run external Verify unless R4/R5, production/real-data/destructive/security/financial/broad-risk work, or explicit human request applies.',
+  });
   appendOrchestrationLog(taskDir, `internal supervisor verifier completed; verdict=${result.verdict}; runId=${verifierRunId}`);
 }
 
@@ -704,6 +806,10 @@ function writeVerifierFailure({
   };
   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, `external CLI verifier failed via ${verifierConfig.provider}; failureReason=${failureReason}; runId=${verifierRunId}`);
 }
 

package/package.json

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