popeye-cli 2.2.0 → 2.7.0

package/src/pipeline/cr-lifecycle.ts

@@ -0,0 +1,103 @@
+/**
+ * CR Lifecycle helpers — resolution after QA pass, stagnation detection.
+ * Extracted from orchestrator to keep it under 500 lines.
+ * v2.4.9
+ */
+
+import { createHash } from 'node:crypto';
+import type { PipelineState } from './types.js';
+
+/** Number of identical loop signatures before declaring stagnation */
+export const STAGNATION_THRESHOLD = 3;
+
+/**
+ * Resolve the active CR after its routed phase (e.g. QA_VALIDATION) passes.
+ * Sets CR status to 'resolved', clears activeChangeRequestId.
+ * For config CRs: sets baselineSnapshotOverride to accept the drift.
+ *
+ * Args:
+ *   pipeline: The current pipeline state (mutated in place).
+ *   onProgress: Optional progress callback for logging.
+ */
+export function resolveActiveCR(
+  pipeline: PipelineState,
+  onProgress?: (message: string) => void,
+): void {
+  const activeCRId = pipeline.activeChangeRequestId;
+  if (!activeCRId) return;
+
+  const pending = pipeline.pendingChangeRequests;
+  if (!pending) return;
+
+  const cr = pending.find((c) => c.cr_id === activeCRId);
+  if (!cr) return;
+
+  cr.status = 'resolved';
+  pipeline.activeChangeRequestId = undefined;
+
+  // Advance baseline to accept the resolved drift (all CR types).
+  // Reason: prevents REVIEW from re-detecting the same drift on the next pass.
+  if (pipeline.latestRepoSnapshot) {
+    pipeline.baselineSnapshotOverride = { ...pipeline.latestRepoSnapshot };
+    onProgress?.(`CR ${cr.cr_id} resolved (${cr.change_type}) — baseline advanced to latest snapshot`);
+  } else {
+    onProgress?.(`CR ${cr.cr_id} resolved (${cr.change_type})`);
+  }
+}
+
+/**
+ * Compute a loop signature for stagnation detection.
+ * Captures the essential state that should change between iterations.
+ *
+ * Args:
+ *   pipeline: The current pipeline state.
+ *
+ * Returns:
+ *   A 16-char hex string fingerprinting the current loop state.
+ */
+export function computeLoopSignature(pipeline: PipelineState): string {
+  // Reason: Use boolean (not count) so signature stays stable even as CRs accumulate
+  const hasPendingActive = pipeline.pendingChangeRequests
+    ?.some((cr) => cr.status === 'proposed' || cr.status === 'approved') ?? false;
+
+  const input = [
+    pipeline.pipelinePhase,
+    pipeline.baselineSnapshotOverride?.artifact_id ?? 'none',
+    pipeline.latestRepoSnapshot?.artifact_id ?? 'none',
+    hasPendingActive ? 'pending' : 'clear',
+    pipeline.activeChangeRequestId ? 'active' : 'none',
+  ].join('|');
+
+  return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+
+/**
+ * Check for stagnation and update the rolling signature window.
+ * Returns true if stagnation is detected (pipeline should transition to STUCK).
+ *
+ * Args:
+ *   pipeline: The current pipeline state (mutated: lastSignatures updated).
+ *   onProgress: Optional progress callback for logging.
+ *
+ * Returns:
+ *   true if the same loop signature repeated STAGNATION_THRESHOLD times.
+ */
+export function checkStagnation(
+  pipeline: PipelineState,
+  onProgress?: (message: string) => void,
+): boolean {
+  const loopSig = computeLoopSignature(pipeline);
+  if (!pipeline.lastSignatures) pipeline.lastSignatures = [];
+  pipeline.lastSignatures.push(loopSig);
+  if (pipeline.lastSignatures.length > STAGNATION_THRESHOLD) {
+    pipeline.lastSignatures = pipeline.lastSignatures.slice(-STAGNATION_THRESHOLD);
+  }
+  if (
+    pipeline.lastSignatures.length === STAGNATION_THRESHOLD &&
+    pipeline.lastSignatures.every((s) => s === pipeline.lastSignatures![0])
+  ) {
+    onProgress?.(`Stagnation detected: identical loop signature ${loopSig} repeated ${STAGNATION_THRESHOLD} times`);
+    return true;
+  }
+  return false;
+}

package/src/pipeline/gate-engine.ts

@@ -4,6 +4,8 @@
  * All 14 phases with specific required artifacts and checks per phase.
  */
 
+import logging from 'node:console';
+
 import type {
   PipelinePhase,
   PipelineState,
@@ -32,6 +34,7 @@ export interface GateResult {
   missingArtifacts: ArtifactType[];
   failedChecks: GateCheckType[];
   consensusScore?: number;
+  finalStatus?: string;    // v2.4.3: 'APPROVED' | 'REJECTED' | 'ARBITRATED'
   timestamp: string;
 }
 
@@ -47,7 +50,7 @@ const GATE_DEFINITIONS: Record<PipelinePhase, GateDefinition> = {
   },
   CONSENSUS_MASTER_PLAN: {
     phase: 'CONSENSUS_MASTER_PLAN',
-    requiredArtifacts: ['master_plan', 'consensus'],
+    requiredArtifacts: ['consensus'],
     requiredChecks: [],
     consensusThreshold: 0.95,
     minReviewers: 2,
@@ -63,7 +66,7 @@ const GATE_DEFINITIONS: Record<PipelinePhase, GateDefinition> = {
   },
   CONSENSUS_ARCHITECTURE: {
     phase: 'CONSENSUS_ARCHITECTURE',
-    requiredArtifacts: ['architecture', 'consensus'],
+    requiredArtifacts: ['consensus'],
     requiredChecks: [],
     consensusThreshold: 0.95,
     minReviewers: 2,
@@ -79,8 +82,8 @@ const GATE_DEFINITIONS: Record<PipelinePhase, GateDefinition> = {
   },
   CONSENSUS_ROLE_PLANS: {
     phase: 'CONSENSUS_ROLE_PLANS',
-    requiredArtifacts: ['role_plan', 'consensus'],
-    requiredChecks: [],
+    requiredArtifacts: ['consensus'],
+    requiredChecks: ['skill_coverage'],
     consensusThreshold: 0.95,
     minReviewers: 2,
     allowedTransitions: ['IMPLEMENTATION'],
@@ -117,7 +120,7 @@ const GATE_DEFINITIONS: Record<PipelinePhase, GateDefinition> = {
   PRODUCTION_GATE: {
     phase: 'PRODUCTION_GATE',
     requiredArtifacts: ['production_readiness'],
-    requiredChecks: ['build', 'test', 'lint', 'typecheck'],
+    requiredChecks: ['build', 'test', 'lint', 'typecheck', 'skill_coverage'],
     allowedTransitions: ['DONE'],
     failTransition: 'RECOVERY_LOOP',
   },
@@ -210,7 +213,8 @@ export class GateEngine {
     // Check required check results
     const phaseChecks = pipeline.gateChecks[phase] ?? [];
     for (const requiredCheck of gateDef.requiredChecks) {
-      const checkResult = phaseChecks.find((c) => c.check_type === requiredCheck);
+      // v2.4.6: Use last check result (not first) — old failed results accumulate on retry
+      const checkResult = phaseChecks.findLast((c) => c.check_type === requiredCheck);
       if (!checkResult) {
         failedChecks.push(requiredCheck);
         blockers.push(`Missing check result: ${requiredCheck}`);
@@ -226,7 +230,18 @@ export class GateEngine {
       const consensusArtifact = findLatestConsensusForPhase(pipeline, phase);
       if (consensusArtifact) {
         consensusScore = parseConsensusScore(pipeline, phase);
-        if (consensusScore !== undefined && consensusScore < gateDef.consensusThreshold) {
+
+        // v2.4.3: Read finalStatus from phase handler's gateResult
+        const finalStatus = parseConsensusFinalStatus(pipeline, phase);
+        const isArbitrated = finalStatus === 'ARBITRATED';
+
+        if (isArbitrated) {
+          // Arbitration approved — skip threshold check
+          logging.log(
+            `[gate] Phase ${phase}: ARBITRATED overrides score check ` +
+            `(score=${consensusScore?.toFixed(2)}, threshold=${gateDef.consensusThreshold})`,
+          );
+        } else if (consensusScore !== undefined && consensusScore < gateDef.consensusThreshold) {
           blockers.push(
             `Consensus score ${consensusScore.toFixed(2)} below threshold ${gateDef.consensusThreshold}`,
           );
@@ -345,3 +360,16 @@ function parseConsensusScore(
 
   return undefined;
 }
+
+/**
+ * Read finalStatus from phase handler's stored gate result.
+ * v2.4.3: Enables gate engine to respect ARBITRATED status
+ * set by consensus phase handlers.
+ */
+function parseConsensusFinalStatus(
+  pipeline: PipelineState,
+  phase: PipelinePhase,
+): string | undefined {
+  const gateResult = pipeline.gateResults[phase];
+  return gateResult?.finalStatus;
+}