ctx-cc 4.0.0 → 4.1.1

package/src/review-gate.js

@@ -7,19 +7,21 @@ import { runAgent } from './runner.js';
 const MAX_REVIEW_CYCLES = 3;
 
 /**
- * Run the two-stage review gate.
+ * Run the three-stage review gate.
  *
  * Stage 1: ctx-reviewer checks spec compliance (acceptance criteria)
- * Stage 2: ctx-auditor checks code quality (security, performance, style)
+ * Stage 2: ctx-reviewer (quality framing) checks code quality (security, performance, style)
+ * Stage 3: ctx-codex-reviewer performs cross-model review via OpenAI Codex MCP
+ *          (only runs if Stages 1 and 2 pass, and `config.codexReview !== false`).
  *
- * If either fails, returns feedback for re-execution.
+ * If any stage fails, returns feedback for re-execution.
  * Max cycles before requiring human intervention.
  *
  * Options:
  *   ctxDir, projectDir, agentsDir, streaming, timeout, config
  *
  * Returns:
- *   { passed: boolean, stage1: {...}, stage2: {...}, cycle: number, feedback: string|null }
+ *   { passed, stage1, stage2, stage3, cycle, feedback, escalated }
  */
 export async function runReviewGate({ ctxDir, projectDir, agentsDir, streaming = true, timeout = 300000, config = {} }) {
   const state = readState(ctxDir);
@@ -49,19 +51,49 @@ export async function runReviewGate({ ctxDir, projectDir, agentsDir, streaming =
     ctxDir, projectDir, agentsDir, streaming, timeout,
   });
 
-  // Stage 2: Code quality (auditor) — only if Stage 1 passes
+  // Stage 2: Code quality — only if Stage 1 passes. Reuses ctx-reviewer with quality framing;
+  // ctx-auditor is an audit-trail agent, not a code reviewer, so using it here was a miscast.
   let stage2 = null;
   if (stage1.passed) {
     stage2 = await runReviewStage({
       stageName: 'code-quality',
-      agentFile: 'ctx-auditor.md',
-      agentCommand: 'audit',
+      agentFile: 'ctx-reviewer.md',
+      agentCommand: 'review',
       prompt: buildReviewPrompt(state, 'quality'),
       ctxDir, projectDir, agentsDir, streaming, timeout,
     });
   }
 
-  const passed = stage1.passed && (stage2 ? stage2.passed : false);
+  // Stage 3: Cross-model review via Codex — only if Stages 1 and 2 pass and not disabled.
+  // The agent may return VERDICT: SKIP (trivial changes, MCP unavailable, rate-limited);
+  // SKIP is treated as pass-through so infrastructure issues never block the gate.
+  // Across retry cycles we pipe the prior Codex threadId forward so the agent can
+  // reuse the cheaper codex-reply path instead of starting a fresh session.
+  let stage3 = null;
+  if (stage1.passed && stage2 && stage2.passed && config.codexReview !== false) {
+    const priorThreadId = priorCodexThreadId(reviewState);
+    stage3 = await runReviewStage({
+      stageName: 'codex-review',
+      agentFile: 'ctx-codex-reviewer.md',
+      agentCommand: 'review',
+      prompt: buildReviewPrompt(state, 'codex', { priorThreadId }),
+      ctxDir, projectDir, agentsDir, streaming, timeout,
+    });
+    const { skipped, threadId } = parseStage3Markers(stage3.output);
+    stage3.threadId = threadId;
+    if (skipped) {
+      stage3.passed = true;
+      stage3.skipped = true;
+      stage3.issues = null;
+    }
+  }
+
+  // stage2 defaults to false when null (stage1 failed → never ran → not passed).
+  // stage3 defaults to true when null (disabled or earlier stage failed → absence is not a fail).
+  const passed =
+    stage1.passed &&
+    (stage2 ? stage2.passed : false) &&
+    (stage3 ? stage3.passed : true);
 
   // Build feedback for re-execution if failed
   let feedback = null;
@@ -69,15 +101,26 @@ export async function runReviewGate({ ctxDir, projectDir, agentsDir, streaming =
     const issues = [];
     if (!stage1.passed) issues.push(`Spec compliance: ${stage1.issues}`);
     if (stage2 && !stage2.passed) issues.push(`Code quality: ${stage2.issues}`);
+    if (stage3 && !stage3.passed) issues.push(`Codex review: ${stage3.issues}`);
     feedback = issues.join('\n');
   }
 
+  const stage3History = stage3
+    ? {
+        passed: stage3.passed,
+        issues: stage3.issues,
+        skipped: stage3.skipped || false,
+        threadId: stage3.threadId || null,
+      }
+    : null;
+
   // Record in state
   reviewState.history.push({
     cycle: reviewState.cycle,
     timestamp: new Date().toISOString(),
     stage1: { passed: stage1.passed, issues: stage1.issues },
     stage2: stage2 ? { passed: stage2.passed, issues: stage2.issues } : null,
+    stage3: stage3History,
     result: passed ? 'pass' : 'fail',
   });
 
@@ -91,6 +134,7 @@ export async function runReviewGate({ ctxDir, projectDir, agentsDir, streaming =
     passed,
     stage1: { passed: stage1.passed, issues: stage1.issues },
     stage2: stage2 ? { passed: stage2.passed, issues: stage2.issues } : null,
+    stage3: stage3History,
     cycle: reviewState.cycle,
     feedback,
     escalated: false,
@@ -104,6 +148,22 @@ export function isReviewGateEnabled(config) {
   return config.reviewGate !== false;
 }
 
+/**
+ * Parse Stage 3 output markers.
+ * - `skipped` is true when the agent emitted `VERDICT: SKIP` (trivial change,
+ *   MCP unavailable, auth expired, rate-limited).
+ * - `threadId` is the value after `THREAD: <id>`, used to resume cheaper
+ *   `codex-reply` sessions across review cycles.
+ *
+ * Exported for unit testing; consumed by runReviewGate internally.
+ */
+export function parseStage3Markers(output) {
+  const text = output || '';
+  const skipped = /verdict:\s*skip/i.test(text);
+  const threadMatch = /THREAD:\s*([^\s]+)/i.exec(text);
+  return { skipped, threadId: threadMatch ? threadMatch[1] : null };
+}
+
 /**
  * Get review history from state.
  */
@@ -130,6 +190,14 @@ export function formatReviewResult(result) {
     const s2Icon = result.stage2.passed ? '✓' : '✗';
     lines.push(`    ${s2Icon} Stage 2 (code quality): ${result.stage2.passed ? 'pass' : result.stage2.issues || 'fail'}`);
   }
+  if (result.stage3) {
+    if (result.stage3.skipped) {
+      lines.push(`    ○ Stage 3 (codex review): skipped`);
+    } else {
+      const s3Icon = result.stage3.passed ? '✓' : '✗';
+      lines.push(`    ${s3Icon} Stage 3 (codex review): ${result.stage3.passed ? 'pass' : result.stage3.issues || 'fail'}`);
+    }
+  }
 
   if (result.escalated) {
     lines.push('');
@@ -182,7 +250,17 @@ async function runReviewStage({ stageName, agentFile, agentCommand, prompt, ctxD
   }
 }
 
-function buildReviewPrompt(state, type) {
+function priorCodexThreadId(reviewState) {
+  const hist = reviewState?.history;
+  if (!Array.isArray(hist)) return null;
+  for (let i = hist.length - 1; i >= 0; i--) {
+    const tid = hist[i]?.stage3?.threadId;
+    if (tid) return tid;
+  }
+  return null;
+}
+
+function buildReviewPrompt(state, type, opts = {}) {
   if (type === 'spec') {
     return [
       'Review the recent code changes for SPEC COMPLIANCE.',
@@ -197,6 +275,22 @@ function buildReviewPrompt(state, type) {
     ].join('\n');
   }
 
+  if (type === 'codex') {
+    const lines = [
+      'Stage 3 — cross-model review via OpenAI Codex.',
+      'Stages 1 (spec) and 2 (quality) already passed under Claude review.',
+      `Active story: ${state.activeStory || 'unknown'}`,
+    ];
+    if (opts.priorThreadId) {
+      lines.push(`Prior Codex thread: ${opts.priorThreadId} — reuse via mcp__codex__codex-reply if context is still relevant.`);
+    }
+    lines.push(
+      '',
+      'Run your playbook and output VERDICT: PASS | FAIL | SKIP on the final line. Append `THREAD: <id>` if a new thread was opened.',
+    );
+    return lines.join('\n');
+  }
+
   return [
     'Review the recent code changes for CODE QUALITY.',
     'Check: security vulnerabilities, performance issues, code style, error handling.',

package/templates/config.json

@@ -91,6 +91,9 @@
 
   "activeProfile": "balanced",
 
+  "reviewGate": true,
+  "codexReview": true,
+
   "git": {
     "autoCommit": true,
     "commitPerTask": true,