@besales/ops-framework 0.1.27 → 0.1.28

package/CHANGELOG.md

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

package/bin/run-verify.mjs

@@ -46,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',
@@ -85,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,
@@ -268,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,
@@ -303,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 = [];
@@ -703,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.27",
+  "version": "0.1.28",
   "type": "module",
   "bin": {
     "ops-agent": "bin/ops-agent.mjs"