v1.91.7.0 feat: add functional QA and pre-publication docs checks (#2983)

* feat: add surface-aware exploratory QA and ship documentation gates

* test: preserve delegated QA setup authority after main integration

* fix(qa): clarify exploration order and preserve report artifacts

* test(qa): follow the shared setup reference directly

* refactor(ship): make verification and recovery routes explicit

* test(ship): align evidence and review guards with explicit routes

* fix(workflows): clarify ship recovery and functional QA evidence

* fix(workflows): clarify approval recovery and full QA coverage

* refactor(workflows): order review transactions and clarify ship state

* fix(ship): clarify final verification and fail closed at publication

* fix(evals): attribute native atomic documentation writes

* fix(ship): clarify recovery and documentation lifecycle guidance

* fix(test): preserve observed native placeholder styling in CI

* fix(codex): report watchdog timeouts without a process-exit race

* Checkpoint functional QA implementation and workflow validation repairs

* Fix documentation and shared-review fixture contracts

* docs: clarify judge reuse and evaluation supervision

* test: align review evidence and selected case contracts

* test: verify append-only documentation checkpoints and recovery

* fix: qualify QA workflows and CI validation repairs

* fix: launch shared-libs fixture scripts on Windows

* fix: qualify QA deadlines, fixture isolation, and shard cleanup

* fix: preserve qualified QA and cancellation repairs

* fix: enforce functional fixture authority and share strict event decoding

* fix: retain free-test evidence and explain recovery

* fix: reject malformed native evidence after decoder consolidation

* test: use reliable capture for telemetry privacy filters

* test: refresh measured quick coverage and document validation costs

* Fix native fixture receipts and preserve VM validation evidence

* Align negative judge controls with upstream clarity policy

* Fix report-only QA preparation and public evidence handling

* Clarify QA-only preparation and current-report preservation

* Stream Ship quality judgments with an explicit 64k response contract

* Validate compact judge reasoning locally with supported wire schema

* Align functional QA fixture instructions with evidence acceptance

* Bind native browser diagnostics to execution evidence and align review verdicts

* Preserve native diagnostic line boundaries

* Serialize functional QA evidence from native captures

* Keep large QA evidence fixture payload out of Windows argv

test/skill-e2e-review.test.ts

@@ -76,12 +76,12 @@ Write your review findings to ${reviewDir}/review-output.md`,
     });
 
     logCost('/review', result);
-    recordE2E(evalCollector, '/review SQL injection', 'Review skill E2E', result);
-    expect(result.exitReason).toBe('success');
-
-    // Verify the review output mentions SQL injection-related findings
-    const reviewOutputPath = path.join(reviewDir, 'review-output.md');
-    if (fs.existsSync(reviewOutputPath)) {
+    let passed = false;
+    try {
+      expect(result.exitReason).toBe('success');
+      expect(result.browseErrors).toEqual([]);
+      const reviewOutputPath = path.join(reviewDir, 'review-output.md');
+      expect(fs.existsSync(reviewOutputPath)).toBe(true);
       const reviewContent = fs.readFileSync(reviewOutputPath, 'utf-8').toLowerCase();
       const hasSqlContent =
         reviewContent.includes('sql') ||
@@ -92,6 +92,9 @@ Write your review findings to ${reviewDir}/review-output.md`,
         reviewContent.includes('user_input') ||
         reviewContent.includes('unsanitized');
       expect(hasSqlContent).toBe(true);
+      passed = true;
+    } finally {
+      recordE2E(evalCollector, '/review SQL injection', 'Review skill E2E', result, { passed });
     }
   }, CAPTURE_MS + REVIEW_FINALIZE_MS);
 });
@@ -139,19 +142,22 @@ describeIfSelected('Review enum completeness E2E', ['review-enum-completeness'],
   });
 
   testConcurrentIfSelected('review-enum-completeness', async () => {
+    const attempt = ++enumCaptureSequence;
+    for (const f of fs.readdirSync(enumDir)) if (/^review-output.*\.md$/.test(f)) fs.rmSync(path.join(enumDir, f));
+    const reviewPath = path.join(enumDir, `review-output-${attempt}.md`);
     const result = await runSkillTest({
-      prompt: `You are in a git repo on branch feature/add-returned-status with changes against main.
-Read review-SKILL.md for the review workflow instructions.
-Also read review-checklist.md and apply it — pay special attention to the Enum & Value Completeness section.
-Run /review on the current diff (git diff main...HEAD).
-Write your review findings to ${enumDir}/review-output.md
+      prompt: `You are in a git repo on branch feature/add-returned-status with changes against main. This is a focused, read-only core review: run only the checklist's static Enum & Value Completeness check on this diff. Do not run the full /review lifecycle, QA or exploratory probes (for example Step 4.7), Greptile, hosting/PR/review-log setup, or any command that is not a git read or a file read.
+This fixture provides only static Ruby source with no configured runnable application, dependencies or runtime/test harness; base main is local and there is no remote or PR. Do not fetch, install, run, or probe an app or dependencies, and any tools that happen to be installed on the host do not expand this scope.
+Read review-SKILL.md for the review workflow instructions, then read review-checklist.md and apply its Enum & Value Completeness section.
+Statically inspect the change: read git diff main...HEAD, then grep the sibling status values through the actual authored source and read every match in full, including unchanged consumers, checking whether each handles the new value.
+Write your review findings once to ${reviewPath} and then stop with a brief final response. Do not re-run the review, reuse a prior report, or invent runtime checks.
 
 The diff adds a new "returned" status to the Order model. Your job is to check if all consumers handle it.`,
       workingDirectory: enumDir,
       maxTurns: 15,
       timeout: JUDGE_MS,
       testName: 'review-enum-completeness',
-      runId: `${process.env.EVALS_RUN_ID ?? runId}-review-enum-${process.pid}-${++enumCaptureSequence}`,
+      runId: `${process.env.EVALS_RUN_ID ?? runId}-review-enum-${process.pid}-${attempt}`,
       publicStreamDiagnostics: true,
     });
 
@@ -161,16 +167,13 @@ The diff adds a new "returned" status to the Order model. Your job is to check i
       expect(result.exitReason).toBe('success');
 
       // Verify the review caught the missing enum handlers
-      const reviewPath = path.join(enumDir, 'review-output.md');
-      if (fs.existsSync(reviewPath)) {
-        const review = fs.readFileSync(reviewPath, 'utf-8');
-        // Should mention the missing "returned" handling in at least one of the methods
-        const mentionsReturned = review.toLowerCase().includes('returned');
-        const mentionsEnum = review.toLowerCase().includes('enum') || review.toLowerCase().includes('status');
-        const mentionsCritical = review.toLowerCase().includes('critical');
-        expect(mentionsReturned).toBe(true);
-        expect(mentionsEnum || mentionsCritical).toBe(true);
-      }
+      expect(fs.existsSync(reviewPath)).toBe(true);
+      const review = fs.readFileSync(reviewPath, 'utf-8');
+      const mentionsReturned = review.toLowerCase().includes('returned');
+      const mentionsEnum = review.toLowerCase().includes('enum') || review.toLowerCase().includes('status');
+      const mentionsCritical = review.toLowerCase().includes('critical');
+      expect(mentionsReturned).toBe(true);
+      expect(mentionsEnum || mentionsCritical).toBe(true);
       passed = result.browseErrors.length === 0;
     } finally {
       recordE2E(evalCollector, '/review enum completeness', 'Review enum completeness E2E', result, { passed });