From 9c0d75b73d1d4fdd4e3a168fa8b2becbbb7fe90e Mon Sep 17 00:00:00 2001
From: David Smith <davidsmith@hamiltonfour.tech>
Date: Fri, 16 Oct 2026 15:52:37 -0400
Subject: [PATCH] Probeable spec: one generated version and the same test
 ladder as probeable code

Probe & Explain graded by generating five LLM code versions and showing
the EiPL panel (versions bar, Abstraction card, View Analysis). The two
probeable types now share one feedback: the ordered test ladder.

Backend
- variation_count is a handler property (5 by default, 1 for
  ProbeableSpecHandler); the generation prompt and the mock LLM honour it.
  The count-5 prompt is byte-identical to before, so EiPL and Prompt are
  unchanged.
- Scoring is a handler policy (score_generated_code): EiPL keeps the
  version pass rate, spec uses the tests-passed ratio like probeable_code.
- ProbeableSpecHandler.serialize_result emits the probeable_code shape
  (student_code, explanation, one truncated test_results entry with
  lockedCount, segmentation). Extraction and first-failure truncation live
  in one shared helper, handlers/ladder.py, used by both probeable types.
- Submission history locks after the first failure for both probeable
  types and fills comprehension_level for spec.

Frontend
- One ProbeableFeedback.vue registered for both types, wrapping
  CodeSubmissionFeedback in ladder layout. Spec shows the explanation in
  the top panel instead of code, hides the debug button, and renders the
  Abstraction card under the ladder when segmentation is enabled.
- ExplanationQuote.vue and AbstractionCard.vue are extracted from
  Feedback.vue and reused there, no duplicated markup.
- ProblemSet.vue routes both probeable types through the probeable result
  branch; the old spec wrappers and their test are deleted.

Tests: backend tests written first (19 failing, then passing); frontend
unit suite 622; E2E spec tests rewritten to the ladder shape.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 e2e/helpers/selectors.ts                      |   8 +-
 e2e/student/probeable-spec.spec.ts            | 118 +++---
 purplex/client/src/components/Feedback.vue    | 207 +---------
 .../src/components/__tests__/Feedback.test.ts |  50 +++
 .../activities/feedback/AbstractionCard.vue   | 352 ++++++++++++++++
 .../feedback/CodeSubmissionFeedback.vue       |  39 +-
 .../activities/feedback/ExplanationQuote.vue  |  77 ++++
 .../feedback/ProbeableCodeFeedback.vue        | 127 ------
 .../activities/feedback/ProbeableFeedback.vue | 160 ++++++++
 .../feedback/ProbeableSpecFeedback.vue        |  89 ----
 .../activities/feedback/TestLadder.vue        |   6 +-
 .../__tests__/AbstractionCard.test.ts         |  66 +++
 ...back.test.ts => ProbeableFeedback.test.ts} | 134 +++++-
 .../client/src/components/activities/index.ts |   7 +-
 .../src/features/problems/ProblemSet.vue      |  32 +-
 purplex/problems_app/handlers/base.py         |  21 +
 purplex/problems_app/handlers/ladder.py       |  69 ++++
 .../handlers/probeable_code/handler.py        |  46 +--
 .../handlers/probeable_spec/handler.py        |  96 ++---
 .../services/ai_generation_service.py         | 115 ++++--
 purplex/problems_app/services/mock_openai.py  |  19 +-
 purplex/problems_app/tasks/pipeline.py        |  30 +-
 .../problems_app/views/submission_views.py    |   6 +-
 .../test_probeable_result_visibility.py       | 126 +++++-
 tests/unit/test_handlers_probeable_spec.py    | 169 +++-----
 .../test_probeable_spec_single_version.py     | 388 ++++++++++++++++++
 tests/unit/test_spec_handler_dispatch.py      |  33 +-
 27 files changed, 1792 insertions(+), 798 deletions(-)
 create mode 100644 purplex/client/src/components/__tests__/Feedback.test.ts
 create mode 100644 purplex/client/src/components/activities/feedback/AbstractionCard.vue
 create mode 100644 purplex/client/src/components/activities/feedback/ExplanationQuote.vue
 delete mode 100644 purplex/client/src/components/activities/feedback/ProbeableCodeFeedback.vue
 create mode 100644 purplex/client/src/components/activities/feedback/ProbeableFeedback.vue
 delete mode 100644 purplex/client/src/components/activities/feedback/ProbeableSpecFeedback.vue
 create mode 100644 purplex/client/src/components/activities/feedback/__tests__/AbstractionCard.test.ts
 rename purplex/client/src/components/activities/feedback/__tests__/{ProbeableCodeFeedback.test.ts => ProbeableFeedback.test.ts} (50%)
 create mode 100644 purplex/problems_app/handlers/ladder.py
 create mode 100644 tests/unit/test_probeable_spec_single_version.py

diff --git a/e2e/helpers/selectors.ts b/e2e/helpers/selectors.ts
index caa1dcb5..e9cf0033 100644
--- a/e2e/helpers/selectors.ts
+++ b/e2e/helpers/selectors.ts
@@ -211,7 +211,7 @@ export const feedback = {
   scoreBadge: '.attempt-score-badge',
   /** Attempt selector dropdown trigger */
   attemptSelector: '.attempt-dropdown-trigger',
-  /** Metric cards (correctness and abstraction) */
+  /** Metric cards: correctness, and abstraction (AbstractionCard.vue, also below the probeable_spec ladder) */
   metricCard: '.metric-card',
   /** Correctness progress bar */
   correctnessBar: '.progress-bar-fill',
@@ -283,11 +283,13 @@ export const probe = {
 
 // ---------------------------------------------------------------------------
 // Code submission feedback (activities/feedback/CodeSubmissionFeedback.vue)
+// Both probeable types use it via ProbeableFeedback.vue (ladder layout);
+// probeable_spec quotes the explanation (.explanation-text) instead of the code.
 // ---------------------------------------------------------------------------
 export const codeFeedback = {
   /** Ordered test ladder (pips + ledger); rendered once grading finishes */
   ladder: '.feedback-container .test-ladder',
-  /** One pip per test, in order: .pass (button) / .fail / .lock */
+  /** One pip per test, in order: .pass / .fail / .lock */
   pip: '.test-ladder .pip',
   pipPass: '.test-ladder .pip.pass',
   pipFail: '.test-ladder .pip.fail',
@@ -304,6 +306,6 @@ export const codeFeedback = {
   attemptPanel: '.attempt-dropdown-panel[role="menu"]',
   /** One attempt in the dropdown (.attempt-tests 'passed/total') */
   attemptItem: '.attempt-item-minimal',
-  /** Debug button on the failing row */
+  /** Debug button on the failing row (not rendered for probeable_spec) */
   debugButton: '.debug-btn',
 } as const;
diff --git a/e2e/student/probeable-spec.spec.ts b/e2e/student/probeable-spec.spec.ts
index 3d3f3530..a0b04822 100644
--- a/e2e/student/probeable-spec.spec.ts
+++ b/e2e/student/probeable-spec.spec.ts
@@ -8,9 +8,14 @@
  *   pass is graded 'complete' (ProbeableSpecHandler: segmentation disabled ->
  *   complete) with no abstraction step.
  *
- * Grading in the E2E stack: CELERY_EAGER runs the EiPL pipeline inside
- * POST /api/submit/, and USE_MOCK_OPENAI returns the reference solution as
- * all 5 LLM variations, so every variation passes both tests.
+ * Grading in the E2E stack: CELERY_EAGER runs the spec pipeline inside
+ * POST /api/submit/. The explanation generates ONE code version, and
+ * USE_MOCK_OPENAI returns the reference solution for it, so it passes both
+ * tests.
+ *
+ * Feedback is the same ordered test ladder as probeable_code (see
+ * probeable-feedback.spec.ts): the top panel quotes the explanation instead of
+ * the code, and there is no debug button.
  *
  * Fresh users have no AI processing consent. probeable_spec submissions are
  * not consent-gated yet (#161); submit tests grant consent through the API up
@@ -22,7 +27,7 @@
 
 import { test, expect, Page } from '@playwright/test';
 import { setAceEditorValue } from '../helpers/ace-editor';
-import { probe, feedback, problemSet } from '../helpers/selectors';
+import { codeFeedback, probe, problemSet } from '../helpers/selectors';
 import { fillProbeArgs } from '../helpers/probe';
 import {
   FreshUser,
@@ -78,6 +83,30 @@ async function probeX(page: Page, value: string): Promise<void> {
   expect(response.status()).toBe(200);
 }
 
+/** Attempts badge: 'n/total' and the score, preceded by its status icon. */
+async function expectAttemptBadge(page: Page, attemptText: string, score: string): Promise<void> {
+  const trigger = page.locator(codeFeedback.attemptTrigger);
+  await expect(trigger.locator('.attempt-text')).toHaveText(attemptText, { timeout: GRADE_TIMEOUT });
+  await expect(trigger.locator('.attempt-score-badge')).toHaveText(new RegExp(`^\\S\\s*${score}%\\s*$`));
+}
+
+/** Both tests pass: two green pips, two passed rows, nothing failing or locked. */
+async function expectAllPassLadder(page: Page): Promise<void> {
+  await expect(page.locator(codeFeedback.pip)).toHaveCount(2);
+  await expect(page.locator(codeFeedback.pipPass)).toHaveCount(2);
+  await expect(page.locator(codeFeedback.pipFail)).toHaveCount(0);
+  await expect(page.locator(codeFeedback.pipLock)).toHaveCount(0);
+  await expect(page.locator(codeFeedback.lockedRow)).toHaveCount(0);
+  await expect(page.locator(codeFeedback.failingItem)).toHaveCount(0);
+
+  const rows = page.locator(codeFeedback.passingItem);
+  await expect(rows).toHaveCount(2);
+  await expect(rows.nth(0).locator('.test-call')).toHaveText('square(3)');
+  await expect(rows.nth(0).locator('.result')).toHaveText('9');
+  await expect(rows.nth(1).locator('.test-call')).toHaveText('square(-2)');
+  await expect(rows.nth(1).locator('.result')).toHaveText('4');
+}
+
 /** Put the explanation in #promptEditor, submit, and require a 2xx. */
 async function submitExplanation(page: Page, text: string): Promise<void> {
   await setAceEditorValue(page, problemSet.promptEditor, text);
@@ -137,51 +166,36 @@ test.describe('C24 Probeable Spec', () => {
     await expect(page.locator(probe.historyModal)).toHaveCount(0);
   });
 
-  test('C24b explanation submit grades 100% with both tests shown', async ({ page }) => {
-    // One mock-LLM grading: 5 variations x 2 tests in the Docker sandbox.
+  test('C24b explanation submit grades 100% on the test ladder', async ({ page }) => {
+    // One mock-LLM grading: 1 generated version x 2 tests in the Docker sandbox.
     test.setTimeout(GRADE_TIMEOUT + 30_000);
     expect(EXPLANATION.length).toBe(60);
     await openSpecProblem(page, 'c24b', { aiConsent: true });
 
     await submitExplanation(page, EXPLANATION);
 
-    // All 5 mock variations are the reference solution and segmentation is
+    // The generated version is the reference solution and segmentation is
     // disabled for this problem, so the grade is complete at 100%.
-    await expect(page.locator('.notification-container .notification.success')).toContainText(
-      'Problem 6: Variations: 5/5 passing',
-      { timeout: GRADE_TIMEOUT },
-    );
+    await expect(
+      page.locator('.notification-container .notification.success .notification-message'),
+    ).toHaveText('Problem 6: 2/2 tests passed', { timeout: GRADE_TIMEOUT });
+
+    await expect(page.locator(codeFeedback.ladder)).toBeVisible({ timeout: GRADE_TIMEOUT });
+    await expectAttemptBadge(page, '1/1', '100');
 
-    const container = page.locator(feedback.container);
-    await expect(container.locator(feedback.header)).toBeVisible({ timeout: GRADE_TIMEOUT });
-    await expect(container.locator('.attempt-text')).toHaveText('1/1');
-    await expect(container.locator(feedback.scoreBadge)).toHaveText('100%');
+    // Top panel quotes the explanation; the generated code is not shown.
+    const container = page.locator('.feedback-container');
     await expect(container.locator('.explanation-text')).toHaveText(EXPLANATION);
+    await expect(container.locator('.code-section')).toHaveCount(0);
 
-    const correctnessCard = container.locator(feedback.metricCard).first();
-    await expect(correctnessCard.locator('.status-metric')).toHaveText('5/5 pass');
-    await expect(correctnessCard.locator('.status-label')).toHaveText('Clear');
-
-    // Test rows live in the correctness modal. probeable_spec is outside the
-    // #165 truncation rule, so every variation lists both tests, the hidden
-    // one included.
-    await correctnessCard.click();
-    const modal = page.locator('.modal-content.correctness-modal');
-    await expect(modal).toBeVisible();
-    await expect(modal.locator('.badge-level')).toHaveText('5/5 Versions Pass');
-    await expect(modal.locator('.version-pill')).toHaveCount(5);
-
-    for (let i = 0; i < 5; i++) {
-      await modal.locator(`#version-tab-${i}`).click();
-      const panel = modal.locator(`#version-panel-${i}`);
-      await expect(panel).toBeVisible();
-      await expect(panel.locator('.details-tests .section-meta')).toHaveText('2/2');
-      const tests = panel.locator('.tests-list .test-item');
-      await expect(tests).toHaveCount(2);
-      await expect(panel.locator('.tests-list .test-item.passing')).toHaveCount(2);
-      await expect(tests.nth(0).locator('.test-call')).toHaveText('square(3)');
-      await expect(tests.nth(1).locator('.test-call')).toHaveText('square(-2)');
-    }
+    // Every test passes, so nothing is locked: both rows, the hidden one
+    // included, appear as passed one-liners.
+    await expectAllPassLadder(page);
+
+    // The student did not write the code: no debugger.
+    await expect(container.locator(codeFeedback.debugButton)).toHaveCount(0);
+    // Segmentation is disabled: no abstraction card.
+    await expect(container.locator('.metric-card')).toHaveCount(0);
   });
 
   test('C24c description length bounds gate the submit button', async ({ page }) => {
@@ -208,22 +222,21 @@ test.describe('C24 Probeable Spec', () => {
   });
 
   test('C24d resubmitting shows 2 attempts', async ({ page }) => {
-    // Two mock-LLM gradings, each 5 variations x 2 tests in the Docker sandbox.
+    // Two mock-LLM gradings, each 1 generated version x 2 tests in the Docker sandbox.
     test.setTimeout(2 * GRADE_TIMEOUT + 30_000);
     const user = await openSpecProblem(page, 'c24d', { aiConsent: true });
-    const container = page.locator(feedback.container);
 
     await submitExplanation(page, EXPLANATION);
-    await expect(container.locator('.attempt-text')).toHaveText('1/1', { timeout: GRADE_TIMEOUT });
+    await expectAttemptBadge(page, '1/1', '100');
 
     await submitExplanation(page, 'It multiplies the integer argument by itself and returns it.');
-    await expect(container.locator('.attempt-text')).toHaveText('2/2', { timeout: GRADE_TIMEOUT });
-    await expect(container.locator(feedback.scoreBadge)).toHaveText('100%');
+    await expectAttemptBadge(page, '2/2', '100');
+    await expectAllPassLadder(page);
 
-    await container.locator(feedback.attemptSelector).click();
-    const panel = container.locator('.attempt-dropdown-panel[role="menu"]');
+    await page.locator(codeFeedback.attemptTrigger).click();
+    const panel = page.locator(codeFeedback.attemptPanel);
     await expect(panel).toBeVisible();
-    const items = panel.locator('.attempt-item-minimal');
+    const items = panel.locator(codeFeedback.attemptItem);
     await expect(items).toHaveCount(2);
     await expect(items.locator('.attempt-num')).toHaveText(['2', '1']);
     await expect(items.locator('.attempt-score-minimal')).toHaveText(['100%', '100%']);
@@ -239,13 +252,14 @@ test.describe('C24 Probeable Spec', () => {
     for (const submission of data.submissions) {
       expect(submission.score).toBe(100);
       expect(submission.completion_status).toBe('complete');
-      expect(submission.variations_count).toBe(5);
-      // History counts test executions across all 5 variations: 5 x 2 tests.
-      expect(submission.tests_passed).toBe(10);
-      expect(submission.total_tests).toBe(10);
+      // One generated version, graded on both tests; nothing locked.
+      expect(submission.variations_count).toBe(1);
+      expect(submission.tests_passed).toBe(2);
+      expect(submission.total_tests).toBe(2);
+      expect(submission.locked_count).toBe(0);
     }
 
     // The dropdown shows each attempt's tests_passed/total_tests from history.
-    await expect(items.locator('.attempt-tests')).toHaveText(['10/10', '10/10']);
+    await expect(items.locator('.attempt-tests')).toHaveText(['2/2', '2/2']);
   });
 });
diff --git a/purplex/client/src/components/Feedback.vue b/purplex/client/src/components/Feedback.vue
index 97bae2c5..9fb89631 100644
--- a/purplex/client/src/components/Feedback.vue
+++ b/purplex/client/src/components/Feedback.vue
@@ -125,28 +125,10 @@
       </div>
 
       <!-- User Explanation Section -->
-      <div
+      <ExplanationQuote
         v-if="userPrompt"
-        class="explanation-section"
-        role="region"
-        aria-labelledby="explanation-heading"
-      >
-        <div class="section-label">
-          <span
-            class="label-icon"
-            aria-hidden="true"
-          >💭</span>
-          <h3
-            id="explanation-heading"
-            class="label-text"
-          >
-            {{ $t('feedback.yourExplanation') }}
-          </h3>
-        </div>
-        <p class="explanation-text">
-          {{ userPrompt }}
-        </p>
-      </div>
+        :text="userPrompt"
+      />
 
       <!-- Correctness Metric Card -->
       <button
@@ -203,69 +185,13 @@
       </button>
 
       <!-- Abstraction Metric Card -->
-      <button
-        class="metric-card"
-        :class="[abstractionClass, { 'expanded': showSegmentAnalysisModal && !isAbstractionLocked }]"
-        :aria-expanded="showSegmentAnalysisModal"
-        :aria-disabled="isAbstractionLocked"
-        :aria-haspopup="isAbstractionLocked ? undefined : 'dialog'"
-        @click="handleAbstractionClick"
-        @keydown.enter="handleAbstractionClick"
-        @keydown.space.prevent="handleAbstractionClick"
-      >
-        <div class="card-content">
-          <div
-            id="abstraction-label"
-            class="card-label"
-          >
-            {{ $t('feedback.abstraction.label') }}
-          </div>
-
-          <div
-            class="progress-bar-container"
-            role="progressbar"
-            :aria-valuenow="abstractionFill"
-            aria-valuemin="0"
-            aria-valuemax="100"
-            :aria-label="isAbstractionLocked ? ($t('feedback.abstraction.label') + ': ' + $t('feedback.abstraction.status.locked')) : ($t('feedback.abstraction.label') + ': ' + $t('feedback.abstraction.segments', { count: segmentCount }))"
-          >
-            <div
-              class="progress-bar-fill"
-              :style="{ width: abstractionFill + '%' }"
-              :class="abstractionBarClass"
-            />
-          </div>
-
-          <div class="card-status">
-            <span
-              class="status-icon"
-              aria-hidden="true"
-            >{{ abstractionStatus.icon }}</span>
-            <span class="status-label">{{ abstractionStatus.label }}</span>
-            <span
-              v-if="!isAbstractionLocked"
-              class="status-metric"
-            >
-              {{ $t('feedback.abstraction.segments', { count: segmentCount }) }}
-              <span
-                v-if="segmentCount > segmentThreshold"
-                class="metric-hint"
-              >{{ $t('feedback.abstraction.segmentThreshold', { threshold: segmentThreshold }) }}</span>
-            </span>
-          </div>
-          <div class="card-description">
-            {{ abstractionStatus.description }}
-          </div>
-        </div>
-        <div
-          v-if="!isAbstractionLocked"
-          class="card-action"
-          :class="abstractionClass"
-          :title="$t('feedback.nextStep.viewAnalysis')"
-        >
-          <span class="action-icon">→</span>
-        </div>
-      </button>
+      <AbstractionCard
+        ref="abstractionCard"
+        :segmentation="segmentation"
+        :locked="isAbstractionLocked"
+        :reference-code="referenceCode"
+        :user-prompt="userPrompt"
+      />
 
       <!-- Next Step Banner -->
       <div
@@ -323,16 +249,6 @@
       :python-tutor-url="pythonTutorUrl"
       @close="showPyTutorModal = false"
     />
-
-    <!-- Segment Analysis Modal -->
-    <SegmentAnalysisModal
-      v-if="segmentation"
-      :is-visible="showSegmentAnalysisModal"
-      :segmentation="segmentation"
-      :reference-code="referenceCode"
-      :user-prompt="userPrompt"
-      @close="showSegmentAnalysisModal = false"
-    />
   </div>
 </template>
 
@@ -340,7 +256,8 @@
 import { defineComponent, nextTick, PropType } from 'vue'
 import CorrectnessModal from '../modals/CorrectnessModal.vue'
 import PyTutorModal from '../modals/PyTutorModal.vue'
-import SegmentAnalysisModal from './segmentation/SegmentAnalysisModal.vue'
+import AbstractionCard from './activities/feedback/AbstractionCard.vue'
+import ExplanationQuote from './activities/feedback/ExplanationQuote.vue'
 import { PythonTutorService } from '@/services/pythonTutor.service'
 import { formatTestValue } from '@/utils/testValueFormatter'
 
@@ -399,7 +316,6 @@ interface SegmentationProp {
 
 interface ComponentData {
   showCorrectnessModal: boolean
-  showSegmentAnalysisModal: boolean
   showPyTutorModal: boolean
   pythonTutorUrl: string
   selectedVariant: number
@@ -414,9 +330,10 @@ interface ComponentData {
 
 export default defineComponent({
   components: {
+    AbstractionCard,
     CorrectnessModal,
-    PyTutorModal,
-    SegmentAnalysisModal
+    ExplanationQuote,
+    PyTutorModal
   },
   props: {
     progress: {
@@ -488,7 +405,6 @@ export default defineComponent({
   data(): ComponentData {
     return {
       showCorrectnessModal: false,
-      showSegmentAnalysisModal: false,
       showPyTutorModal: false,
       pythonTutorUrl: '',
       selectedVariant: 0,
@@ -564,11 +480,6 @@ export default defineComponent({
       return !this.allVariationsPass || !this.segmentationEnabled
     },
 
-    abstractionFill(): number {
-      if (this.isAbstractionLocked) {return 0}
-      if (this.segmentCount <= this.segmentThreshold) {return 100}
-      return Math.max(0, 100 - (this.segmentCount - this.segmentThreshold) * 20)
-    },
 
     correctnessStatus(): { icon: string; label: string; description: string } {
       if (this.passingVariants === 0) {
@@ -580,15 +491,6 @@ export default defineComponent({
       return { icon: '✓', label: this.$t('feedback.correctness.status.clear'), description: this.$t('feedback.correctness.status.clearDesc') }
     },
 
-    abstractionStatus(): { icon: string; label: string; description: string } {
-      if (this.isAbstractionLocked) {
-        return { icon: '🔒', label: this.$t('feedback.abstraction.status.locked'), description: this.$t('feedback.abstraction.status.lockedDesc') }
-      }
-      if (this.segmentCount <= this.segmentThreshold) {
-        return { icon: '✓', label: this.$t('feedback.abstraction.status.highLevel'), description: this.$t('feedback.abstraction.status.highLevelDesc') }
-      }
-      return { icon: '✗', label: this.$t('feedback.abstraction.status.tooDetailed'), description: this.$t('feedback.abstraction.status.tooDetailedDesc') }
-    },
 
     correctnessClass(): string {
       if (this.passingVariants === 0) {return 'status-error'}
@@ -596,11 +498,6 @@ export default defineComponent({
       return 'status-success'
     },
 
-    abstractionClass(): string {
-      if (this.isAbstractionLocked) {return 'status-locked'}
-      if (this.segmentCount <= this.segmentThreshold) {return 'status-success'}
-      return 'status-error'
-    },
 
     correctnessBarClass(): string {
       if (this.passingVariants === 0) {return 'bar-error'}
@@ -608,11 +505,6 @@ export default defineComponent({
       return 'bar-success'
     },
 
-    abstractionBarClass(): string {
-      if (this.isAbstractionLocked) {return 'bar-locked'}
-      if (this.segmentCount <= this.segmentThreshold) {return 'bar-success'}
-      return 'bar-error'
-    },
 
     nextStepAction(): string | null {
       if (this.passingVariants === 0) {
@@ -785,14 +677,6 @@ export default defineComponent({
       this.announce(this.$t('feedback.announcement.correctnessClosed'))
     },
 
-    handleAbstractionClick(): void {
-      if (this.isAbstractionLocked) {
-        this.announce(this.$t('feedback.announcement.abstractionLocked'))
-        return
-      }
-      this.showSegmentAnalysisModal = true
-      this.announce(this.$t('feedback.announcement.abstractionOpened'))
-    },
 
     handleNextStepAction(): void {
       if (this.passingVariants < this.totalVariants) {
@@ -800,7 +684,7 @@ export default defineComponent({
         this.openCorrectnessModal()
       } else if (!this.isAbstractionLocked && this.segmentCount > this.segmentThreshold) {
         // Open abstraction modal
-        this.showSegmentAnalysisModal = true
+        (this.$refs.abstractionCard as InstanceType<typeof AbstractionCard> | undefined)?.open()
       } else {
         // Navigate to next problem
         this.$emit('next-problem')
@@ -1188,46 +1072,6 @@ export default defineComponent({
   font-size: 10px;
 }
 
-/* Explanation Section */
-.explanation-section {
-  margin: var(--spacing-md) var(--spacing-lg);
-  padding: var(--spacing-md);
-  background: var(--color-bg-section);
-  border-radius: var(--radius-base);
-  border-left: 3px solid var(--color-primary);
-}
-
-.section-label {
-  display: flex;
-  align-items: center;
-  gap: var(--spacing-sm);
-  margin-bottom: var(--spacing-sm);
-}
-
-.label-icon {
-  font-size: var(--font-size-base);
-}
-
-.label-text {
-  font-size: var(--font-size-xs);
-  font-weight: 600;
-  color: var(--color-text-muted);
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-  margin: 0;
-}
-
-.explanation-text {
-  color: var(--color-text-secondary);
-  font-size: var(--font-size-sm);
-  line-height: 1.6;
-  margin: 0;
-  padding: var(--spacing-sm);
-  background: var(--color-bg-panel);
-  border-radius: var(--radius-xs);
-  font-style: italic;
-}
-
 /* Metric Cards */
 .metric-card {
   display: flex;
@@ -1273,16 +1117,6 @@ export default defineComponent({
   border-left-color: var(--color-success);
 }
 
-.metric-card.status-locked {
-  border-left-color: var(--color-bg-disabled);
-  opacity: 0.6;
-  cursor: not-allowed;
-}
-
-.metric-card.status-locked:hover {
-  background: var(--color-bg-section);
-}
-
 .card-label {
   font-size: 11px;
   font-weight: 600;
@@ -1318,10 +1152,6 @@ export default defineComponent({
   background: linear-gradient(90deg, var(--color-success), var(--color-success-dark));
 }
 
-.progress-bar-fill.bar-locked {
-  background: var(--color-bg-border);
-}
-
 /* Card Status */
 .card-status {
   display: flex;
@@ -1346,11 +1176,6 @@ export default defineComponent({
   color: var(--color-text-muted);
 }
 
-.metric-hint {
-  color: var(--color-text-muted);
-  opacity: 0.7;
-}
-
 .card-description {
   font-size: var(--font-size-sm);
   color: var(--color-text-muted);
diff --git a/purplex/client/src/components/__tests__/Feedback.test.ts b/purplex/client/src/components/__tests__/Feedback.test.ts
new file mode 100644
index 00000000..edb14aba
--- /dev/null
+++ b/purplex/client/src/components/__tests__/Feedback.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import Feedback from '../Feedback.vue'
+
+const passing = { success: true, testsPassed: 1, totalTests: 1, results: [] }
+const failing = { success: false, testsPassed: 0, totalTests: 1, results: [] }
+
+const segmentation = {
+  segment_count: 4,
+  comprehension_level: 'multi_structural',
+  threshold: 2,
+  segments: [],
+}
+
+function mountFeedback(testResults: unknown[]) {
+  return mount(Feedback, {
+    props: {
+      codeResults: testResults.map(() => 'def f(x):\n    return x'),
+      testResults: testResults as never,
+      userPrompt: 'Returns its argument.',
+      segmentation,
+      segmentationEnabled: true,
+    },
+    global: {
+      stubs: { CorrectnessModal: true, PyTutorModal: true, SegmentAnalysisModal: true },
+    },
+  })
+}
+
+describe('Feedback (EiPL) explanation and abstraction', () => {
+  it('quotes the explanation and locks abstraction until every version passes', () => {
+    const wrapper = mountFeedback([passing, failing])
+
+    expect(wrapper.find('.explanation-text').text()).toBe('Returns its argument.')
+    const cards = wrapper.findAll('.metric-card')
+    expect(cards).toHaveLength(2)
+    expect(cards[1].classes()).toContain('status-locked')
+  })
+
+  it('the next-step button opens the segment analysis when the explanation is too detailed', async () => {
+    const wrapper = mountFeedback([passing, passing])
+    const modal = () => wrapper.findComponent({ name: 'SegmentAnalysisModal' })
+
+    expect(wrapper.findAll('.metric-card')[1].classes()).toContain('status-error')
+    expect(modal().props('isVisible')).toBe(false)
+
+    await wrapper.find('.banner-button').trigger('click')
+    expect(modal().props('isVisible')).toBe(true)
+  })
+})
diff --git a/purplex/client/src/components/activities/feedback/AbstractionCard.vue b/purplex/client/src/components/activities/feedback/AbstractionCard.vue
new file mode 100644
index 00000000..2bf10786
--- /dev/null
+++ b/purplex/client/src/components/activities/feedback/AbstractionCard.vue
@@ -0,0 +1,352 @@
+<template>
+  <div class="abstraction-card">
+    <button
+      class="metric-card"
+      :class="[abstractionClass, { 'expanded': showModal && !locked }]"
+      :aria-expanded="showModal"
+      :aria-disabled="locked"
+      :aria-haspopup="locked ? undefined : 'dialog'"
+      @click="handleClick"
+      @keydown.enter="handleClick"
+      @keydown.space.prevent="handleClick"
+    >
+      <div class="card-content">
+        <div
+          id="abstraction-label"
+          class="card-label"
+        >
+          {{ $t('feedback.abstraction.label') }}
+        </div>
+
+        <div
+          class="progress-bar-container"
+          role="progressbar"
+          :aria-valuenow="abstractionFill"
+          aria-valuemin="0"
+          aria-valuemax="100"
+          :aria-label="locked ? ($t('feedback.abstraction.label') + ': ' + $t('feedback.abstraction.status.locked')) : ($t('feedback.abstraction.label') + ': ' + $t('feedback.abstraction.segments', { count: segmentCount }))"
+        >
+          <div
+            class="progress-bar-fill"
+            :style="{ width: abstractionFill + '%' }"
+            :class="abstractionBarClass"
+          />
+        </div>
+
+        <div class="card-status">
+          <span
+            class="status-icon"
+            aria-hidden="true"
+          >{{ abstractionStatus.icon }}</span>
+          <span class="status-label">{{ abstractionStatus.label }}</span>
+          <span
+            v-if="!locked"
+            class="status-metric"
+          >
+            {{ $t('feedback.abstraction.segments', { count: segmentCount }) }}
+            <span
+              v-if="segmentCount > segmentThreshold"
+              class="metric-hint"
+            >{{ $t('feedback.abstraction.segmentThreshold', { threshold: segmentThreshold }) }}</span>
+          </span>
+        </div>
+        <div class="card-description">
+          {{ abstractionStatus.description }}
+        </div>
+      </div>
+      <div
+        v-if="!locked"
+        class="card-action"
+        :class="abstractionClass"
+        :title="$t('feedback.nextStep.viewAnalysis')"
+      >
+        <span class="action-icon">→</span>
+      </div>
+    </button>
+
+    <!-- Live region for announcements -->
+    <div
+      class="sr-only"
+      role="status"
+      aria-live="polite"
+      aria-atomic="true"
+    >
+      {{ announcement }}
+    </div>
+
+    <SegmentAnalysisModal
+      v-if="segmentation"
+      :is-visible="showModal"
+      :segmentation="segmentation as never"
+      :reference-code="referenceCode"
+      :user-prompt="userPrompt"
+      @close="showModal = false"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+/**
+ * AbstractionCard - the "Abstraction" metric card and its segment analysis.
+ *
+ * Shows how many segments the student's explanation maps to (fewer = more
+ * abstract) and opens the SegmentAnalysisModal. Locked until the code built
+ * from the explanation passes every test.
+ *
+ * Used by Feedback.vue (EiPL/Prompt: locked unless all versions pass) and by
+ * ProbeableFeedback.vue for probeable_spec (locked unless the single version
+ * passes).
+ */
+import { computed, nextTick, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import SegmentAnalysisModal from '@/components/segmentation/SegmentAnalysisModal.vue'
+import type { SegmentationData } from '../types'
+
+interface Props {
+  /** Segmentation analysis of the explanation */
+  segmentation?: SegmentationData | null
+  /** Locked: the card is inert and the analysis stays hidden */
+  locked?: boolean
+  /** Reference solution, shown alongside the segments */
+  referenceCode?: string
+  /** The student's explanation */
+  userPrompt?: string
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  segmentation: null,
+  locked: false,
+  referenceCode: '',
+  userPrompt: '',
+})
+
+const { t } = useI18n()
+
+const showModal = ref(false)
+const announcement = ref('')
+
+const segmentCount = computed(() => props.segmentation?.segment_count ?? 0)
+const segmentThreshold = computed(() => props.segmentation?.threshold ?? 2)
+const isHighLevel = computed(() => segmentCount.value <= segmentThreshold.value)
+
+const abstractionFill = computed(() => {
+  if (props.locked) {return 0}
+  if (isHighLevel.value) {return 100}
+  return Math.max(0, 100 - (segmentCount.value - segmentThreshold.value) * 20)
+})
+
+const abstractionStatus = computed(() => {
+  if (props.locked) {
+    return { icon: '🔒', label: t('feedback.abstraction.status.locked'), description: t('feedback.abstraction.status.lockedDesc') }
+  }
+  if (isHighLevel.value) {
+    return { icon: '✓', label: t('feedback.abstraction.status.highLevel'), description: t('feedback.abstraction.status.highLevelDesc') }
+  }
+  return { icon: '✗', label: t('feedback.abstraction.status.tooDetailed'), description: t('feedback.abstraction.status.tooDetailedDesc') }
+})
+
+const abstractionClass = computed(() => {
+  if (props.locked) {return 'status-locked'}
+  return isHighLevel.value ? 'status-success' : 'status-error'
+})
+
+const abstractionBarClass = computed(() => {
+  if (props.locked) {return 'bar-locked'}
+  return isHighLevel.value ? 'bar-success' : 'bar-error'
+})
+
+function announce(message: string): void {
+  announcement.value = ''
+  nextTick(() => {
+    announcement.value = message
+  })
+}
+
+/** Open the segment analysis (no-op while locked). */
+function open(): void {
+  if (props.locked) {return}
+  showModal.value = true
+}
+
+function handleClick(): void {
+  if (props.locked) {
+    announce(t('feedback.announcement.abstractionLocked'))
+    return
+  }
+  open()
+  announce(t('feedback.announcement.abstractionOpened'))
+}
+
+defineExpose({ open })
+</script>
+
+<style scoped>
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+
+.metric-card {
+  display: flex;
+  align-items: stretch;
+  width: calc(100% - calc(var(--spacing-lg) * 2));
+  margin: var(--spacing-md) var(--spacing-lg);
+  padding: 0;
+  background: var(--color-bg-section);
+  border-radius: var(--radius-xs);
+  cursor: pointer;
+  transition: var(--transition-fast);
+  border: none;
+  border-left: 4px solid transparent;
+  text-align: left;
+  font-family: inherit;
+  overflow: hidden;
+}
+
+.card-content {
+  flex: 1;
+  padding: var(--spacing-sm) var(--spacing-md);
+  min-width: 0;
+}
+
+.metric-card:hover {
+  background: var(--color-bg-input);
+}
+
+.metric-card:focus {
+  outline: 2px solid var(--color-primary-gradient-start);
+  outline-offset: 2px;
+}
+
+.metric-card.status-error {
+  border-left-color: var(--color-error);
+}
+
+.metric-card.status-success {
+  border-left-color: var(--color-success);
+}
+
+.metric-card.status-locked {
+  border-left-color: var(--color-bg-disabled);
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.metric-card.status-locked:hover {
+  background: var(--color-bg-section);
+}
+
+.card-label {
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--color-text-muted);
+  letter-spacing: 0.5px;
+  margin-bottom: var(--spacing-md);
+}
+
+.progress-bar-container {
+  height: 8px;
+  background: var(--color-bg-dark);
+  border-radius: var(--radius-xs);
+  overflow: hidden;
+  margin-bottom: var(--spacing-md);
+}
+
+.progress-bar-fill {
+  height: 100%;
+  border-radius: var(--radius-xs);
+  transition: width 0.4s ease;
+}
+
+.progress-bar-fill.bar-error {
+  background: linear-gradient(90deg, var(--color-error), var(--color-error-dark));
+}
+
+.progress-bar-fill.bar-success {
+  background: linear-gradient(90deg, var(--color-success), var(--color-success-dark));
+}
+
+.progress-bar-fill.bar-locked {
+  background: var(--color-bg-border);
+}
+
+.card-status {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+  margin-bottom: var(--spacing-xs);
+}
+
+.status-icon {
+  font-size: var(--font-size-base);
+}
+
+.status-label {
+  font-weight: 600;
+  color: var(--color-text-primary);
+  font-size: var(--font-size-sm);
+}
+
+.status-metric {
+  margin-left: auto;
+  font-size: var(--font-size-sm);
+  color: var(--color-text-muted);
+}
+
+.metric-hint {
+  color: var(--color-text-muted);
+  opacity: 0.7;
+}
+
+.card-description {
+  font-size: var(--font-size-sm);
+  color: var(--color-text-muted);
+}
+
+.card-action {
+  width: 40px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  align-self: stretch;
+  border-left: 1px solid var(--color-overlay-medium);
+  transition: all 0.2s ease;
+  flex-shrink: 0;
+  margin: 0;
+}
+
+.card-action.status-success {
+  background: var(--color-success-overlay);
+  border-left-color: var(--color-success-border);
+}
+
+.card-action.status-error {
+  background: var(--color-error-overlay);
+  border-left-color: var(--color-error-border);
+}
+
+.action-icon {
+  font-size: 18px;
+  font-weight: 600;
+  transition: transform 0.2s ease;
+}
+
+.card-action.status-success .action-icon {
+  color: var(--color-success);
+}
+
+.card-action.status-error .action-icon {
+  color: var(--color-error);
+}
+
+.metric-card:hover .card-action .action-icon {
+  transform: translateX(3px);
+}
+</style>
diff --git a/purplex/client/src/components/activities/feedback/CodeSubmissionFeedback.vue b/purplex/client/src/components/activities/feedback/CodeSubmissionFeedback.vue
index 83b38199..25947d62 100644
--- a/purplex/client/src/components/activities/feedback/CodeSubmissionFeedback.vue
+++ b/purplex/client/src/components/activities/feedback/CodeSubmissionFeedback.vue
@@ -134,21 +134,23 @@
         </div>
       </div>
 
-      <!-- Code Section -->
-      <section class="code-section">
-        <div class="code-header">
-          <span>{{ $t('feedback.codeSubmission.yourSubmission') }}</span>
-        </div>
-        <Editor
-          :value="studentCode"
-          :read-only="true"
-          height="250px"
-          width="100%"
-          lang="python"
-          mode="python"
-          :show-gutter="true"
-        />
-      </section>
+      <!-- What was submitted: the code by default; probeable_spec swaps in the explanation -->
+      <slot name="submission">
+        <section class="code-section">
+          <div class="code-header">
+            <span>{{ $t('feedback.codeSubmission.yourSubmission') }}</span>
+          </div>
+          <Editor
+            :value="studentCode"
+            :read-only="true"
+            height="250px"
+            width="100%"
+            lang="python"
+            mode="python"
+            :show-gutter="true"
+          />
+        </section>
+      </slot>
 
       <!-- Test results: ordered ladder (probeable) or pass/fail groups -->
       <TestLadder
@@ -156,6 +158,7 @@
         :tests="testResults"
         :locked-count="lockedCount"
         :total-count="totalCount"
+        :can-debug="canDebug"
         @debug="openDebugger"
       />
       <template v-else>
@@ -196,6 +199,7 @@
                   </div>
                 </div>
                 <button
+                  v-if="canDebug"
                   class="debug-btn"
                   :aria-label="$t('feedback.codeSubmission.debugTestCase', { call: test.function_call })"
                   @click="openDebugger(test)"
@@ -234,6 +238,8 @@
           </details>
         </section>
       </template>
+
+      <slot name="after-results" />
     </template>
 
     <!-- Empty State -->
@@ -300,6 +306,8 @@ interface Props {
   lockedCount?: number
   /** Total test count including locked ones (ladder only) */
   totalCount?: number | null
+  /** Show the debugger button on failing tests */
+  canDebug?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -310,6 +318,7 @@ const props = withDefaults(defineProps<Props>(), {
   layout: 'groups',
   lockedCount: 0,
   totalCount: null,
+  canDebug: true,
 })
 
 const emit = defineEmits<{
diff --git a/purplex/client/src/components/activities/feedback/ExplanationQuote.vue b/purplex/client/src/components/activities/feedback/ExplanationQuote.vue
new file mode 100644
index 00000000..d0ccd572
--- /dev/null
+++ b/purplex/client/src/components/activities/feedback/ExplanationQuote.vue
@@ -0,0 +1,77 @@
+<template>
+  <div
+    class="explanation-section"
+    role="region"
+    aria-labelledby="explanation-heading"
+  >
+    <div class="section-label">
+      <span
+        class="label-icon"
+        aria-hidden="true"
+      >💭</span>
+      <h3
+        id="explanation-heading"
+        class="label-text"
+      >
+        {{ $t('feedback.yourExplanation') }}
+      </h3>
+    </div>
+    <p class="explanation-text">
+      {{ text }}
+    </p>
+  </div>
+</template>
+
+<script setup lang="ts">
+/**
+ * ExplanationQuote - the student's own explanation, quoted back in feedback.
+ *
+ * Shared by the EiPL/Prompt feedback (Feedback.vue) and the probeable_spec
+ * feedback, where it takes the place of the submitted-code panel.
+ */
+defineProps<{
+  /** The student's explanation text */
+  text: string
+}>()
+</script>
+
+<style scoped>
+.explanation-section {
+  margin: var(--spacing-md) var(--spacing-lg);
+  padding: var(--spacing-md);
+  background: var(--color-bg-section);
+  border-radius: var(--radius-base);
+  border-left: 3px solid var(--color-primary);
+}
+
+.section-label {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+  margin-bottom: var(--spacing-sm);
+}
+
+.label-icon {
+  font-size: var(--font-size-base);
+}
+
+.label-text {
+  font-size: var(--font-size-xs);
+  font-weight: 600;
+  color: var(--color-text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  margin: 0;
+}
+
+.explanation-text {
+  color: var(--color-text-secondary);
+  font-size: var(--font-size-sm);
+  line-height: 1.6;
+  margin: 0;
+  padding: var(--spacing-sm);
+  background: var(--color-bg-panel);
+  border-radius: var(--radius-xs);
+  font-style: italic;
+}
+</style>
diff --git a/purplex/client/src/components/activities/feedback/ProbeableCodeFeedback.vue b/purplex/client/src/components/activities/feedback/ProbeableCodeFeedback.vue
deleted file mode 100644
index f4bcbfda..00000000
--- a/purplex/client/src/components/activities/feedback/ProbeableCodeFeedback.vue
+++ /dev/null
@@ -1,127 +0,0 @@
-<template>
-  <CodeSubmissionFeedback
-    :student-code="studentCode"
-    :test-results="flatTestResults"
-    :submission-history="submissionHistory"
-    :is-loading="isLoading"
-    :is-navigating="isNavigating"
-    :title="effectiveTitle"
-    layout="ladder"
-    :locked-count="lockedCount"
-    :total-count="totalCount"
-    @load-attempt="$emit('load-attempt', $event)"
-  />
-</template>
-
-<script setup lang="ts">
-/**
- * ProbeableCodeFeedback - Feedback component for Probeable Code activities.
- *
- * Thin wrapper around CodeSubmissionFeedback that transforms the
- * backend data format into the flat structure expected by the component.
- *
- * Probeable Code students discover function behavior by probing, then
- * write their own implementation. The feedback shows:
- * - Their submitted implementation code
- * - An ordered ladder of tests: passes up to the first failure, that
- *   failure, and a count of the locked rest (#165)
- *
- * Note: Unlike EiPL/ProbeableSpec, there's no segmentation or AI variations
- * because the student writes actual code, not a natural language description.
- */
-import { computed } from 'vue'
-import { useI18n } from 'vue-i18n'
-import CodeSubmissionFeedback from './CodeSubmissionFeedback.vue'
-import type { CodeResult, SubmissionHistoryItem, TestResultDisplay, TestResultEntry } from '../types'
-
-const { t } = useI18n()
-
-interface Props {
-  /** Overall correctness score */
-  progress?: number
-  /** Number of notches for progress visualization */
-  notches?: number
-  /** Code variation results (single entry for probeable code) */
-  codeResults?: CodeResult[] | string[]
-  /** Test execution results */
-  testResults?: TestResultEntry[] | TestResultDisplay[]
-  /** User's implementation code */
-  userPrompt?: string
-  /** Reference solution code (usually hidden) */
-  referenceCode?: string
-  /** Loading state */
-  isLoading?: boolean
-  /** Navigation state */
-  isNavigating?: boolean
-  /** Historical submission data */
-  submissionHistory?: SubmissionHistoryItem[]
-  /** Title for the feedback section */
-  title?: string
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  progress: 0,
-  notches: 6,
-  codeResults: () => [],
-  testResults: () => [],
-  userPrompt: '',
-  referenceCode: '',
-  isLoading: false,
-  isNavigating: false,
-  submissionHistory: () => [],
-  title: '',
-})
-
-const effectiveTitle = computed(() => props.title || t('feedback.correctnessModal.testResults'))
-
-defineEmits<{
-  (e: 'load-attempt', attemptId: string): void
-}>()
-
-/**
- * Extract the student's code from codeResults.
- * For probeable code, there's only one "variation" - the student's code.
- */
-const studentCode = computed(() => {
-  if (props.codeResults.length === 0) {return ''}
-  const first = props.codeResults[0]
-  // Handle both string[] and CodeResult[] formats
-  if (typeof first === 'string') {return first}
-  return first.code || ''
-})
-
-/**
- * Flatten test results into a simple array.
- * Backend sends nested structure, but we just need flat test cases.
- */
-const flatTestResults = computed(() => {
-  if (props.testResults.length === 0) {return []}
-
-  const first = props.testResults[0] as TestResultEntry
-  // Extract test_results or results array
-  const tests = first.test_results || first.results || []
-
-  return tests.map(t => ({
-    function_call: t.function_call,
-    expected_output: t.expected_output,
-    actual_output: t.actual_output,
-    isSuccessful: t.isSuccessful ?? t.pass ?? false,
-    error: t.error,
-  }))
-})
-
-/**
- * Tests hidden after the first failure (rows stop there; see backend
- * result_visibility.truncate_to_first_failure).
- */
-const lockedCount = computed(() => {
-  if (props.testResults.length === 0) {return 0}
-  return (props.testResults[0] as TestResultEntry).lockedCount ?? 0
-})
-
-/** Total over every test, including locked ones. */
-const totalCount = computed(() => {
-  if (props.testResults.length === 0) {return null}
-  return (props.testResults[0] as TestResultEntry).totalTests ?? null
-})
-</script>
diff --git a/purplex/client/src/components/activities/feedback/ProbeableFeedback.vue b/purplex/client/src/components/activities/feedback/ProbeableFeedback.vue
new file mode 100644
index 00000000..9703e476
--- /dev/null
+++ b/purplex/client/src/components/activities/feedback/ProbeableFeedback.vue
@@ -0,0 +1,160 @@
+<template>
+  <CodeSubmissionFeedback
+    :student-code="studentCode"
+    :test-results="flatTestResults"
+    :submission-history="submissionHistory"
+    :is-loading="isLoading"
+    :is-navigating="isNavigating"
+    :title="effectiveTitle"
+    layout="ladder"
+    :locked-count="lockedCount"
+    :total-count="totalCount"
+    :can-debug="!isSpec"
+    @load-attempt="$emit('load-attempt', $event)"
+  >
+    <template
+      v-if="isSpec"
+      #submission
+    >
+      <ExplanationQuote :text="userPrompt" />
+    </template>
+    <template
+      v-if="showAbstraction"
+      #after-results
+    >
+      <AbstractionCard
+        :segmentation="segmentation"
+        :locked="!versionPassed"
+        :reference-code="referenceCode"
+        :user-prompt="userPrompt"
+      />
+    </template>
+  </CodeSubmissionFeedback>
+</template>
+
+<script setup lang="ts">
+/**
+ * ProbeableFeedback - Feedback for both probeable activity types.
+ *
+ * Students discover a function's behavior by probing it, then either write
+ * an implementation (probeable_code) or describe it in plain language and
+ * have ONE version generated from the description (probeable_spec). Both
+ * types grade a single piece of code against the same ordered tests, so both
+ * get the same ladder: passes up to the first failure, that failure, and a
+ * count of the locked rest (#165).
+ *
+ * Differences for probeable_spec:
+ * - the top panel quotes the student's explanation instead of the code
+ * - no debugger button (the student did not write the code)
+ * - the Abstraction card follows the ladder when segmentation is enabled
+ */
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import AbstractionCard from './AbstractionCard.vue'
+import CodeSubmissionFeedback from './CodeSubmissionFeedback.vue'
+import ExplanationQuote from './ExplanationQuote.vue'
+import type { CodeResult, SegmentationData, SubmissionHistoryItem, TestResultDisplay, TestResultEntry } from '../types'
+
+// FeedbackSelector forwards every feedback prop; drop the ones not declared here
+defineOptions({ inheritAttrs: false })
+
+const { t } = useI18n()
+
+interface Props {
+  /** 'probeable_code' or 'probeable_spec' */
+  problemType?: string
+  /** The single graded version (student code, or code generated from the explanation) */
+  codeResults?: CodeResult[] | string[]
+  /** Test execution results (single entry) */
+  testResults?: TestResultEntry[] | TestResultDisplay[]
+  /** The student's input: code (probeable_code) or explanation (probeable_spec) */
+  userPrompt?: string
+  /** Segmentation analysis of the explanation (probeable_spec) */
+  segmentation?: SegmentationData | null
+  /** Whether segmentation is enabled for this problem */
+  segmentationEnabled?: boolean
+  /** Reference solution code (shown in the segment analysis) */
+  referenceCode?: string
+  /** Loading state */
+  isLoading?: boolean
+  /** Navigation state */
+  isNavigating?: boolean
+  /** Historical submission data */
+  submissionHistory?: SubmissionHistoryItem[]
+  /** Title for the feedback section */
+  title?: string
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  problemType: 'probeable_code',
+  codeResults: () => [],
+  testResults: () => [],
+  userPrompt: '',
+  segmentation: null,
+  segmentationEnabled: false,
+  referenceCode: '',
+  isLoading: false,
+  isNavigating: false,
+  submissionHistory: () => [],
+  title: '',
+})
+
+defineEmits<{
+  (e: 'load-attempt', attemptId: string): void
+}>()
+
+const isSpec = computed(() => props.problemType === 'probeable_spec')
+
+const effectiveTitle = computed(() => props.title || t('feedback.correctnessModal.testResults'))
+
+/** The single graded version's code. */
+const studentCode = computed(() => {
+  if (props.codeResults.length === 0) {return ''}
+  const first = props.codeResults[0]
+  // Handle both string[] and CodeResult[] formats
+  if (typeof first === 'string') {return first}
+  return first.code || ''
+})
+
+const entry = computed(() =>
+  props.testResults.length > 0 ? (props.testResults[0] as TestResultEntry) : null
+)
+
+/**
+ * Flatten test results into a simple array.
+ * Backend sends nested structure, but we just need flat test cases.
+ */
+const flatTestResults = computed(() => {
+  if (!entry.value) {return []}
+  const tests = entry.value.test_results || entry.value.results || []
+
+  return tests.map(test => ({
+    function_call: test.function_call,
+    expected_output: test.expected_output,
+    actual_output: test.actual_output,
+    isSuccessful: test.isSuccessful ?? test.pass ?? false,
+    error: test.error,
+  }))
+})
+
+/**
+ * Tests hidden after the first failure (rows stop there; see backend
+ * result_visibility.truncate_to_first_failure).
+ */
+const lockedCount = computed(() => entry.value?.lockedCount ?? 0)
+
+/** Total over every test, including locked ones. */
+const totalCount = computed(() => entry.value?.totalTests ?? null)
+
+/** The single version passed every test, locked ones included. */
+const versionPassed = computed(() => {
+  const e = entry.value
+  if (!e) {return false}
+  if (typeof e.success === 'boolean') {return e.success}
+  return e.totalTests !== undefined && e.totalTests > 0 && e.testsPassed === e.totalTests
+})
+
+const showAbstraction = computed(() =>
+  isSpec.value && props.segmentationEnabled && props.segmentation !== null
+)
+</script>
diff --git a/purplex/client/src/components/activities/feedback/ProbeableSpecFeedback.vue b/purplex/client/src/components/activities/feedback/ProbeableSpecFeedback.vue
deleted file mode 100644
index fd24fcf6..00000000
--- a/purplex/client/src/components/activities/feedback/ProbeableSpecFeedback.vue
+++ /dev/null
@@ -1,89 +0,0 @@
-<template>
-  <Feedback
-    :progress="progress"
-    :notches="notches"
-    :code-results="codeResults"
-    :test-results="testResults"
-    :comprehension-results="comprehensionResults"
-    :user-prompt="userPrompt"
-    :segmentation="segmentation"
-    :reference-code="referenceCode"
-    problem-type="probeable_spec"
-    :segmentation-enabled="segmentationEnabled"
-    :is-loading="isLoading"
-    :is-navigating="isNavigating"
-    :submission-history="submissionHistory"
-    :title="effectiveTitle"
-    @load-attempt="$emit('load-attempt', $event)"
-  />
-</template>
-
-<script setup lang="ts">
-/**
- * ProbeableSpecFeedback - Feedback component for Probeable Spec activities.
- *
- * This is a thin wrapper around the generic Feedback component that ensures
- * the problem_type is set to 'probeable_spec'. The Feedback component handles
- * all the EiPL-like features (segmentation, variations) that Probeable Spec uses.
- *
- * The key difference from EiPL is that students discovered the function behavior
- * through probing rather than seeing the code directly.
- */
-import { computed } from 'vue'
-import { useI18n } from 'vue-i18n'
-import Feedback from '@/components/Feedback.vue'
-import type { CodeResult, SegmentationData, SubmissionHistoryItem, TestResultDisplay } from '../types'
-
-const { t } = useI18n()
-
-interface Props {
-  /** Overall correctness score */
-  progress?: number
-  /** Number of notches for progress visualization */
-  notches?: number
-  /** Code variation results */
-  codeResults?: CodeResult[]
-  /** Test execution results */
-  testResults?: TestResultDisplay[]
-  /** Comprehension analysis results */
-  comprehensionResults?: string
-  /** User's original prompt/input */
-  userPrompt?: string
-  /** Segmentation analysis data */
-  segmentation?: SegmentationData | null
-  /** Reference solution code (usually hidden for Probeable Spec) */
-  referenceCode?: string
-  /** Whether segmentation is enabled */
-  segmentationEnabled?: boolean
-  /** Loading state */
-  isLoading?: boolean
-  /** Navigation state */
-  isNavigating?: boolean
-  /** Historical submission data */
-  submissionHistory?: SubmissionHistoryItem[]
-  /** Title for the feedback section */
-  title?: string
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  progress: 0,
-  notches: 6,
-  codeResults: () => [],
-  testResults: () => [],
-  comprehensionResults: '',
-  userPrompt: '',
-  segmentation: null,
-  referenceCode: '',
-  segmentationEnabled: true,  // Probeable Spec has segmentation enabled by default
-  isLoading: false,
-  isNavigating: false,
-  submissionHistory: () => [],
-  title: '',
-})
-
-const effectiveTitle = computed(() => props.title || t('problems.problemSet.submissionResults'))
-
-defineEmits<{
-  (e: 'load-attempt', attemptId: string): void
-}>()
-</script>
diff --git a/purplex/client/src/components/activities/feedback/TestLadder.vue b/purplex/client/src/components/activities/feedback/TestLadder.vue
index d4d65d05..1c03d99a 100644
--- a/purplex/client/src/components/activities/feedback/TestLadder.vue
+++ b/purplex/client/src/components/activities/feedback/TestLadder.vue
@@ -88,6 +88,7 @@
             :aria-label="$t('feedback.tests.pipFailed', { n: i + 1 })"
           >✗</span>
           <button
+            v-if="canDebug"
             type="button"
             class="debug-btn"
             :aria-label="$t('feedback.codeSubmission.debugTestCase', { call: test.function_call })"
@@ -113,7 +114,7 @@
 
 <script setup lang="ts">
 /**
- * TestLadder - ordered test results for probeable_code feedback.
+ * TestLadder - ordered test results for probeable feedback.
  *
  * Rows arrive already truncated to the first failure (backend
  * result_visibility.truncate_to_first_failure): every passing test up to the
@@ -133,11 +134,14 @@ interface Props {
   lockedCount?: number
   /** Total test count; defaults to rows + locked */
   totalCount?: number | null
+  /** Show the debugger button on the failing row */
+  canDebug?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
   lockedCount: 0,
   totalCount: null,
+  canDebug: true,
 })
 
 defineEmits<{
diff --git a/purplex/client/src/components/activities/feedback/__tests__/AbstractionCard.test.ts b/purplex/client/src/components/activities/feedback/__tests__/AbstractionCard.test.ts
new file mode 100644
index 00000000..9db11694
--- /dev/null
+++ b/purplex/client/src/components/activities/feedback/__tests__/AbstractionCard.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import AbstractionCard from '../AbstractionCard.vue'
+
+const segmentation = (segment_count: number) => ({
+  segment_count,
+  comprehension_level: segment_count <= 2 ? 'relational' : 'multi_structural',
+  threshold: 2,
+  segments: [],
+})
+
+function mountCard(props: Record<string, unknown>) {
+  return mount(AbstractionCard, {
+    props: props as never,
+    global: { stubs: { SegmentAnalysisModal: true } },
+  })
+}
+
+describe('AbstractionCard', () => {
+  it('locked: inert, no segment count, click does not open the analysis', async () => {
+    const wrapper = mountCard({ segmentation: segmentation(1), locked: true })
+    const card = wrapper.find('.metric-card')
+
+    expect(card.classes()).toContain('status-locked')
+    expect(card.attributes('aria-disabled')).toBe('true')
+    expect(wrapper.find('.status-metric').exists()).toBe(false)
+    expect(wrapper.find('.card-action').exists()).toBe(false)
+
+    await card.trigger('click')
+    expect(wrapper.findComponent({ name: 'SegmentAnalysisModal' }).props('isVisible')).toBe(false)
+  })
+
+  it('high-level explanation: success state with the segment count', () => {
+    const wrapper = mountCard({ segmentation: segmentation(2), locked: false })
+    const card = wrapper.find('.metric-card')
+
+    expect(card.classes()).toContain('status-success')
+    expect(wrapper.find('.progress-bar-fill').attributes('style')).toContain('width: 100%')
+    expect(wrapper.find('.status-metric').text()).toContain('2')
+    expect(wrapper.find('.metric-hint').exists()).toBe(false)
+  })
+
+  it('too detailed: error state with the threshold hint', () => {
+    const wrapper = mountCard({ segmentation: segmentation(4), locked: false })
+
+    expect(wrapper.find('.metric-card').classes()).toContain('status-error')
+    expect(wrapper.find('.progress-bar-fill').attributes('style')).toContain('width: 60%')
+    expect(wrapper.find('.metric-hint').exists()).toBe(true)
+  })
+
+  it('opens the segment analysis on click and via open()', async () => {
+    const wrapper = mountCard({ segmentation: segmentation(1), locked: false })
+    const modal = () => wrapper.findComponent({ name: 'SegmentAnalysisModal' })
+
+    await wrapper.find('.metric-card').trigger('click')
+    expect(modal().props('isVisible')).toBe(true)
+
+    modal().vm.$emit('close')
+    await wrapper.vm.$nextTick()
+    expect(modal().props('isVisible')).toBe(false)
+
+    ;(wrapper.vm as unknown as { open: () => void }).open()
+    await wrapper.vm.$nextTick()
+    expect(modal().props('isVisible')).toBe(true)
+  })
+})
diff --git a/purplex/client/src/components/activities/feedback/__tests__/ProbeableCodeFeedback.test.ts b/purplex/client/src/components/activities/feedback/__tests__/ProbeableFeedback.test.ts
similarity index 50%
rename from purplex/client/src/components/activities/feedback/__tests__/ProbeableCodeFeedback.test.ts
rename to purplex/client/src/components/activities/feedback/__tests__/ProbeableFeedback.test.ts
index 34294da9..ef944c56 100644
--- a/purplex/client/src/components/activities/feedback/__tests__/ProbeableCodeFeedback.test.ts
+++ b/purplex/client/src/components/activities/feedback/__tests__/ProbeableFeedback.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { mount } from '@vue/test-utils'
-import ProbeableCodeFeedback from '../ProbeableCodeFeedback.vue'
+import ProbeableFeedback from '../ProbeableFeedback.vue'
 
 const row = (isSuccessful: boolean, i: number, error?: string) => ({
   isSuccessful,
@@ -10,23 +10,35 @@ const row = (isSuccessful: boolean, i: number, error?: string) => ({
   error,
 })
 
-function mountFeedback(entry: Record<string, unknown>) {
-  return mount(ProbeableCodeFeedback, {
+const CODE = 'def f(x):\n    return x'
+const EXPLANATION = 'Returns its argument unchanged.'
+
+function mountFeedback(entry: Record<string, unknown>, props: Record<string, unknown> = {}) {
+  return mount(ProbeableFeedback, {
     props: {
-      codeResults: ['def f(x):\n    return x'],
+      codeResults: [CODE],
       testResults: [entry] as never,
+      ...props,
     },
     global: {
-      stubs: { Editor: true, PyTutorModal: true },
+      stubs: { Editor: true, PyTutorModal: true, SegmentAnalysisModal: true },
     },
   })
 }
 
+function mountSpec(entry: Record<string, unknown>, props: Record<string, unknown> = {}) {
+  return mountFeedback(entry, {
+    problemType: 'probeable_spec',
+    userPrompt: EXPLANATION,
+    ...props,
+  })
+}
+
 function pipClasses(wrapper: ReturnType<typeof mountFeedback>): string[] {
   return wrapper.findAll('.pip').map(p => (p.classes('pass') ? 'pass' : p.classes('fail') ? 'fail' : 'lock'))
 }
 
-describe('ProbeableCodeFeedback ladder', () => {
+describe('ProbeableFeedback ladder (probeable_code)', () => {
   it('shows one pip per test and locks everything after the first failure', () => {
     const visible = [row(true, 0), row(false, 1)]
     const wrapper = mountFeedback({
@@ -141,3 +153,113 @@ describe('ProbeableCodeFeedback ladder', () => {
     expect(actual.text()).toBe('ZeroDivisionError: division by zero')
   })
 })
+
+const segmentation = {
+  segment_count: 1,
+  comprehension_level: 'relational',
+  passed: true,
+  threshold: 2,
+  segments: [{ id: 1, text: EXPLANATION, code_lines: [2] }],
+}
+
+const failingEntry = () => {
+  const visible = [row(true, 0), row(false, 1)]
+  return {
+    success: false,
+    testsPassed: 1,
+    totalTests: 4,
+    test_results: visible,
+    results: visible,
+    lockedCount: 2,
+    visibleCount: 2,
+  }
+}
+
+const passingEntry = () => {
+  const visible = [row(true, 0), row(true, 1)]
+  return {
+    success: true,
+    testsPassed: 2,
+    totalTests: 2,
+    test_results: visible,
+    results: visible,
+    lockedCount: 0,
+    visibleCount: 2,
+  }
+}
+
+describe('ProbeableFeedback (probeable_code) top panel', () => {
+  it('shows the submitted code, no explanation and no abstraction card', () => {
+    const wrapper = mountFeedback(failingEntry(), { segmentation, segmentationEnabled: true })
+
+    expect(wrapper.find('.code-section').exists()).toBe(true)
+    expect(wrapper.find('.explanation-section').exists()).toBe(false)
+    expect(wrapper.find('.metric-card').exists()).toBe(false)
+    expect(wrapper.find('.ledger-row.fail .debug-btn').exists()).toBe(true)
+  })
+})
+
+describe('ProbeableFeedback (probeable_spec)', () => {
+  it('quotes the explanation instead of the code editor', () => {
+    const wrapper = mountSpec(failingEntry())
+
+    expect(wrapper.find('.code-section').exists()).toBe(false)
+    expect(wrapper.find('.explanation-section .explanation-text').text()).toBe(EXPLANATION)
+  })
+
+  it('has no debug button on the failing row', () => {
+    const wrapper = mountSpec(failingEntry())
+
+    expect(wrapper.find('.ledger-row.fail').exists()).toBe(true)
+    expect(wrapper.find('.debug-btn').exists()).toBe(false)
+  })
+
+  it('renders the same ladder as probeable_code for the same rows', () => {
+    const code = mountFeedback(failingEntry())
+    const spec = mountSpec(failingEntry())
+
+    expect(pipClasses(spec)).toEqual(['pass', 'fail', 'lock', 'lock'])
+    expect(pipClasses(spec)).toEqual(pipClasses(code))
+    expect(spec.find('.ledger-row.lock').text()).toBe(code.find('.ledger-row.lock').text())
+    expect(spec.findAll('.ledger-row.pass').map((r) => r.text())).toEqual(
+      code.findAll('.ledger-row.pass').map((r) => r.text()),
+    )
+    const specFail = spec.find('.ledger-row.fail')
+    const codeFail = code.find('.ledger-row.fail')
+    for (const sel of ['.test-call', '.expected', '.actual']) {
+      expect(specFail.find(sel).text()).toBe(codeFail.find(sel).text())
+    }
+  })
+
+  it('shows an unlocked abstraction card below the ladder when the version passes', () => {
+    const wrapper = mountSpec(passingEntry(), { segmentation, segmentationEnabled: true })
+
+    const card = wrapper.find('.metric-card')
+    expect(card.exists()).toBe(true)
+    expect(card.classes()).toContain('status-success')
+    expect(card.attributes('aria-disabled')).toBe('false')
+    // The card follows the ladder
+    const html = wrapper.html()
+    expect(html.indexOf('test-ladder')).toBeLessThan(html.indexOf('metric-card'))
+  })
+
+  it('locks the abstraction card when the version fails a test', () => {
+    const wrapper = mountSpec(failingEntry(), { segmentation, segmentationEnabled: true })
+
+    const card = wrapper.find('.metric-card')
+    expect(card.classes()).toContain('status-locked')
+    expect(card.attributes('aria-disabled')).toBe('true')
+  })
+
+  it('has no abstraction card without segmentation data', () => {
+    const wrapper = mountSpec(passingEntry(), { segmentation: null, segmentationEnabled: true })
+
+    expect(wrapper.find('.metric-card').exists()).toBe(false)
+  })
+
+  it('has no abstraction card when segmentation is disabled', () => {
+    const wrapper = mountSpec(passingEntry(), { segmentation, segmentationEnabled: false })
+
+    expect(wrapper.find('.metric-card').exists()).toBe(false)
+  })
+})
diff --git a/purplex/client/src/components/activities/index.ts b/purplex/client/src/components/activities/index.ts
index b062d649..2a72bfe8 100644
--- a/purplex/client/src/components/activities/index.ts
+++ b/purplex/client/src/components/activities/index.ts
@@ -30,6 +30,9 @@ export * from './types'
  * 2. Create feedback component in ./feedback/
  * 3. Add entry here with lazy loaders
  */
+// Both probeable types share one feedback component (the ordered test ladder)
+const probeableFeedback = () => import('./feedback/ProbeableFeedback.vue')
+
 const ACTIVITY_COMPONENTS: ActivityComponentRegistry = {
   eipl: {
     input: () => import('./inputs/EiplInput.vue'),
@@ -53,11 +56,11 @@ const ACTIVITY_COMPONENTS: ActivityComponentRegistry = {
   },
   probeable_code: {
     input: () => import('./inputs/ProbeableCodeInput.vue'),
-    feedback: () => import('./feedback/ProbeableCodeFeedback.vue'),
+    feedback: probeableFeedback,
   },
   probeable_spec: {
     input: () => import('./inputs/ProbeableSpecInput.vue'),
-    feedback: () => import('./feedback/ProbeableSpecFeedback.vue'),
+    feedback: probeableFeedback,
   },
 }
 
diff --git a/purplex/client/src/features/problems/ProblemSet.vue b/purplex/client/src/features/problems/ProblemSet.vue
index 1d616c20..834a043e 100644
--- a/purplex/client/src/features/problems/ProblemSet.vue
+++ b/purplex/client/src/features/problems/ProblemSet.vue
@@ -397,6 +397,9 @@ import { sseService } from '@/services/sseService'
 import { submissionService } from '@/services/submissionService'
 import { ref } from 'vue'
 
+/** Both probeable types grade one version and share the probeable result shape. */
+const isProbeableType = (type) => type === 'probeable_code' || type === 'probeable_spec'
+
 export default {
     name: 'ProblemSet',
     components: {
@@ -756,8 +759,8 @@ export default {
                     let codeResults = [];
                     let testResults = [];
 
-                    if (problemType === 'probeable_code') {
-                        // Probeable code stores student_code instead of variations
+                    if (isProbeableType(problemType)) {
+                        // Probeable types store the single graded version as student_code
                         if (submissionData.student_code) {
                             codeResults = [{ code: submissionData.student_code }];
                         }
@@ -1364,11 +1367,16 @@ export default {
                             } else {
                                 this.notify.warning(message);
                             }
-                        } else if (problemType === 'probeable_code') {
-                            // Probeable code processing - extracts student_code and test_results
+                        } else if (isProbeableType(problemType)) {
+                            // Probeable code/spec processing - one graded version (student_code)
+                            // and its truncated test ladder; spec also carries segmentation
                             const probeableResult = unifiedResult.result || {};
                             const studentCode = probeableResult.student_code || '';
                             const testResults = probeableResult.test_results || [];
+                            const segmentation = probeableResult.segmentation ?? null;
+                            const submittedProblem = this.problems.find(p => p.slug === currentProblemSlug);
+                            const showSegmentation = submittedProblem?.feedback_config?.show_segmentation === true;
+                            const segmentationPassed = segmentation?.passed ?? null;
 
                             // Calculate test statistics
                             let totalTestsPassed = 0;
@@ -1389,7 +1397,7 @@ export default {
                                     promptCorrectness: unifiedResult.score ?? 0,
                                     userPrompt: unifiedResult.user_input ?? rawInput,
                                     comprehensionResults: '',
-                                    segmentationData: null,
+                                    segmentationData: showSegmentation ? segmentation : null,
                                     mcqResult: null
                                 });
                                 this.promptEditorValue = unifiedResult.user_input ?? rawInput;
@@ -1399,7 +1407,10 @@ export default {
                             const score = totalTestsRun > 0
                                 ? Math.round((totalTestsPassed / totalTestsRun) * 100)
                                 : (unifiedResult.score ?? 0);
-                            const finalStatus = score >= 100 ? 'completed' : 'in_progress';
+                            // With segmentation on (probeable_spec), completion also needs a high-level explanation
+                            const finalStatus = score >= 100 && (!showSegmentation || segmentationPassed === true)
+                                ? 'completed'
+                                : 'in_progress';
 
                             // Update problem status
                             this.problemStatuses = {
@@ -1407,7 +1418,8 @@ export default {
                                 [currentProblemSlug]: {
                                     status: finalStatus,
                                     score: score,
-                                    attempts: (this.problemStatuses[currentProblemSlug]?.attempts || 0) + 1
+                                    attempts: (this.problemStatuses[currentProblemSlug]?.attempts || 0) + 1,
+                                    segmentationPassed: segmentationPassed
                                 }
                             };
 
@@ -1421,13 +1433,15 @@ export default {
                                 has_submission: true,
                                 student_code: studentCode,
                                 results: testResults,
-                                user_prompt: unifiedResult.user_input
+                                user_prompt: unifiedResult.user_input,
+                                segmentation: segmentation
                             });
 
                             // Show notification
                             const allPassed = totalTestsRun > 0 && totalTestsPassed === totalTestsRun;
                             const message = this.$t('problems.problemSet.notify.testsPassed', { problem: problemIdentifier, passed: totalTestsPassed, total: totalTestsRun });
-                            if (allPassed) {
+                            // A too-detailed explanation (probeable_spec) keeps the problem open: warn
+                            if (allPassed && finalStatus === 'completed') {
                                 this.notify.success(message);
                             } else {
                                 this.notify.warning(message);
diff --git a/purplex/problems_app/handlers/base.py b/purplex/problems_app/handlers/base.py
index f721fad2..6fef6b84 100644
--- a/purplex/problems_app/handlers/base.py
+++ b/purplex/problems_app/handlers/base.py
@@ -247,6 +247,27 @@ def requires_ai_consent(self) -> bool:
         """
         return False
 
+    # ─── Generated-Code Policy (types run by execute_eipl_pipeline) ──
+
+    #: How many code versions the LLM writes from the student's description.
+    variation_count: int = 5
+
+    def score_generated_code(self, test_results: list[dict[str, Any]]) -> int:
+        """
+        Score the LLM-generated versions of a description, 0-100.
+
+        Default: the share of versions that pass every test. Handlers whose
+        single version is graded like student code override this.
+
+        Args:
+            test_results: One dict per version with ``success``,
+                ``testsPassed`` and ``totalTests``.
+        """
+        if not test_results:
+            return 0
+        passing = sum(1 for r in test_results if r.get("success", False))
+        return int(passing / len(test_results) * 100)
+
     # ─── Optional Hooks ─────────────────────────────────────────
 
     def on_submission_created(self, submission: "Submission") -> None:
diff --git a/purplex/problems_app/handlers/ladder.py b/purplex/problems_app/handlers/ladder.py
new file mode 100644
index 00000000..d5c08db2
--- /dev/null
+++ b/purplex/problems_app/handlers/ladder.py
@@ -0,0 +1,69 @@
+"""Student-facing test ladder shared by the probeable activity types.
+
+``probeable_code`` (the student's code) and ``probeable_spec`` (one version the
+LLM wrote from the student's explanation) both grade a single piece of code and
+show its tests as one ordered ladder: rows up to and including the first
+failure are visible, the rest are locked (see ``truncate_to_first_failure``).
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from .base import ActivityHandler
+from .result_visibility import truncate_to_first_failure
+
+if TYPE_CHECKING:
+    from purplex.problems_app.models import Problem
+    from purplex.submissions.models import Submission
+
+
+def build_test_ladder(
+    submission: "Submission", problem: "Problem"
+) -> list[dict[str, Any]]:
+    """Return the single-entry ladder for a submission's graded code.
+
+    Pass counts cover every test; only the visible rows are truncated.
+
+    Returns:
+        ``[]`` when the submission has no code variation, otherwise one dict
+        with ``success``, ``testsPassed``, ``totalTests``, ``test_results``
+        (and its alias ``results``), ``lockedCount`` and ``visibleCount``.
+    """
+    if (
+        not hasattr(submission, "code_variations")
+        or not submission.code_variations.exists()
+    ):
+        return []
+
+    variation = submission.code_variations.first()
+    if not variation:
+        return []
+
+    rows = []
+    test_execs = variation.test_executions.all().order_by("execution_order")
+    if test_execs.exists():
+        for test_exec in test_execs:
+            rows.append(
+                {
+                    "isSuccessful": test_exec.passed,
+                    "function_call": ActivityHandler._format_function_call(
+                        problem.function_name, test_exec.input_values
+                    ),
+                    "expected_output": test_exec.expected_output,
+                    "actual_output": test_exec.actual_output,
+                    "error": test_exec.error_message,
+                }
+            )
+
+    visible, locked = truncate_to_first_failure(rows, passed_key="isSuccessful")
+    return [
+        {
+            "success": variation.tests_passed == variation.tests_total
+            and variation.tests_total > 0,
+            "testsPassed": variation.tests_passed,
+            "totalTests": variation.tests_total,
+            "test_results": visible,
+            "results": visible,  # Duplicate for frontend compatibility
+            "lockedCount": locked,
+            "visibleCount": len(visible),
+        }
+    ]
diff --git a/purplex/problems_app/handlers/probeable_code/handler.py b/purplex/problems_app/handlers/probeable_code/handler.py
index 12f4e079..4897ef3d 100644
--- a/purplex/problems_app/handlers/probeable_code/handler.py
+++ b/purplex/problems_app/handlers/probeable_code/handler.py
@@ -23,7 +23,7 @@
     SubmissionOutcome,
     ValidationResult,
 )
-from ..result_visibility import truncate_to_first_failure
+from ..ladder import build_test_ladder
 
 if TYPE_CHECKING:
     from purplex.problems_app.models import Problem
@@ -134,49 +134,7 @@ def extract_test_results(
         the first failure are returned; the rest are reported as
         ``lockedCount`` (see ``truncate_to_first_failure``).
         """
-        results = []
-
-        # Check if we have code variations (reusing EiPL's data structure)
-        if (
-            hasattr(submission, "code_variations")
-            and submission.code_variations.exists()
-        ):
-            variation = submission.code_variations.first()
-            if variation:
-                test_execs = variation.test_executions.all().order_by("execution_order")
-                var_results = []
-
-                if test_execs.exists():
-                    for test_exec in test_execs:
-                        var_results.append(
-                            {
-                                "isSuccessful": test_exec.passed,
-                                "function_call": self._format_function_call(
-                                    problem.function_name, test_exec.input_values
-                                ),
-                                "expected_output": test_exec.expected_output,
-                                "actual_output": test_exec.actual_output,
-                                "error": test_exec.error_message,
-                            }
-                        )
-
-                visible, locked = truncate_to_first_failure(
-                    var_results, passed_key="isSuccessful"
-                )
-                results.append(
-                    {
-                        "success": variation.tests_passed == variation.tests_total
-                        and variation.tests_total > 0,
-                        "testsPassed": variation.tests_passed,
-                        "totalTests": variation.tests_total,
-                        "test_results": visible,
-                        "results": visible,  # Duplicate for frontend compatibility
-                        "lockedCount": locked,
-                        "visibleCount": len(visible),
-                    }
-                )
-
-        return results
+        return build_test_ladder(submission, problem)
 
     def count_variations(self, submission: "Submission") -> int:
         """Count total variations (always 1 for Probeable Code)."""
diff --git a/purplex/problems_app/handlers/probeable_spec/handler.py b/purplex/problems_app/handlers/probeable_spec/handler.py
index 9ad938da..79731c9a 100644
--- a/purplex/problems_app/handlers/probeable_spec/handler.py
+++ b/purplex/problems_app/handlers/probeable_spec/handler.py
@@ -12,6 +12,9 @@
 5. LLM generates code from explanation (reuses EiPL pipeline)
 6. Code tested against test cases
 
+The LLM writes ONE version (``variation_count = 1``), shown as the same ordered
+test ladder as probeable_code and scored by tests passed.
+
 Grading: Test pass + comprehension level (reuses EiPL logic)
 """
 
@@ -24,6 +27,7 @@
     SubmissionOutcome,
     ValidationResult,
 )
+from ..ladder import build_test_ladder
 
 if TYPE_CHECKING:
     from purplex.problems_app.models import Problem
@@ -57,6 +61,9 @@ class ProbeableSpecHandler(ActivityHandler):
     MIN_INPUT_LENGTH = 10
     MAX_INPUT_LENGTH = 1000
 
+    # One version, graded and shown like probeable_code's student code.
+    variation_count = 1
+
     @property
     def type_name(self) -> str:
         return "probeable_spec"
@@ -174,62 +181,12 @@ def extract_variations(self, submission: "Submission") -> list[str]:
     def extract_test_results(
         self, submission: "Submission", problem: "Problem"
     ) -> list[dict[str, Any]]:
-        """Transform TestExecution objects to frontend format."""
-        results = []
-
-        # Group test results by code variation
-        variations = submission.code_variations.all().order_by("variation_index")
-        for variation in variations:
-            test_execs = variation.test_executions.all().order_by("execution_order")
-            var_results = []
-
-            # If we have TestExecution records, use them
-            if test_execs.exists():
-                for test_exec in test_execs:
-                    var_results.append(
-                        {
-                            "isSuccessful": test_exec.passed,
-                            "function_call": self._format_function_call(
-                                problem.function_name, test_exec.input_values
-                            ),
-                            "expected_output": test_exec.expected_output,
-                            "actual_output": test_exec.actual_output,
-                            "error": test_exec.error_message,
-                        }
-                    )
-            # Fallback: If no TestExecution records exist but we have summary data
-            elif variation.tests_total > 0:
-                # Create placeholder results based on the summary
-                for i in range(variation.tests_total):
-                    is_passed = i < variation.tests_passed
-                    var_results.append(
-                        {
-                            "isSuccessful": is_passed,
-                            "function_call": f"{problem.function_name}(test_case_{i + 1})",
-                            "expected_output": "Test details not available",
-                            "actual_output": "Passed" if is_passed else "Failed",
-                            "error": (
-                                ""
-                                if is_passed
-                                else "Test failed (details not available)"
-                            ),
-                        }
-                    )
-
-            results.append(
-                {
-                    "success": (
-                        variation.tests_passed == variation.tests_total
-                        and variation.tests_total > 0
-                    ),
-                    "testsPassed": variation.tests_passed,
-                    "totalTests": variation.tests_total,
-                    "test_results": var_results,
-                    "results": var_results,  # Duplicate for frontend compatibility
-                }
-            )
+        """Return the generated version's tests as the probeable ladder.
 
-        return results
+        Same shape and locking as ``probeable_code``: pass counts cover every
+        test, rows after the first failure are reported as ``lockedCount``.
+        """
+        return build_test_ladder(submission, problem)
 
     def count_variations(self, submission: "Submission") -> int:
         """Count total variations for submission."""
@@ -303,27 +260,18 @@ def get_problem_config(self, problem: "Problem") -> dict[str, Any]:
         }
 
     def serialize_result(self, submission: "Submission") -> dict[str, Any]:
-        """Serialize submission result for API response (same as EiPL)."""
+        """Serialize like ``probeable_code``, plus the explanation and segmentation.
+
+        ``student_code`` is the one version the LLM wrote from the student's
+        explanation; ``explanation`` is what the student wrote.
+        """
         result = {
-            "variations": [],
+            "student_code": submission.processed_code or "",
+            "explanation": submission.raw_input or "",
             "test_results": [],
             "segmentation": None,
         }
 
-        # Serialize variations
-        if hasattr(submission, "code_variations"):
-            result["variations"] = [
-                {
-                    "code": v.generated_code,
-                    "score": v.score,
-                    "tests_passed": v.tests_passed,
-                    "tests_total": v.tests_total,
-                    "is_selected": v.is_selected,
-                }
-                for v in submission.code_variations.all()
-            ]
-
-        # Serialize test results using extract_test_results
         if hasattr(submission, "problem") and submission.problem:
             result["test_results"] = self.extract_test_results(
                 submission, submission.problem
@@ -379,6 +327,12 @@ def requires_ai_consent(self) -> bool:
         """The student's description goes through the same LLM call as EiPL."""
         return True
 
+    def score_generated_code(self, test_results: list[dict[str, Any]]) -> int:
+        """Share of tests passed, the rule ``probeable_code`` uses."""
+        passed = sum(r.get("testsPassed", 0) for r in test_results)
+        total = sum(r.get("totalTests", 0) for r in test_results)
+        return int(passed / total * 100) if total > 0 else 0
+
     def submit(
         self,
         submission: "Submission",
diff --git a/purplex/problems_app/services/ai_generation_service.py b/purplex/problems_app/services/ai_generation_service.py
index 22d8d091..a5f0f7af 100644
--- a/purplex/problems_app/services/ai_generation_service.py
+++ b/purplex/problems_app/services/ai_generation_service.py
@@ -7,6 +7,65 @@
 
 logger = logging.getLogger(__name__)
 
+_NUMBER_WORDS = {
+    1: "one",
+    2: "two",
+    3: "three",
+    4: "four",
+    5: "five",
+    6: "six",
+    7: "seven",
+    8: "eight",
+    9: "nine",
+    10: "ten",
+}
+
+
+def _variation_system_prompt(function_name: str, count: int) -> str:
+    """Build the system prompt asking the LLM for ``count`` implementations.
+
+    The mock LLM (``mock_openai.py``) recognises this prompt by its
+    ``implementation(s) of a function called`` wording and returns one version
+    per ``# implementation`` stub, so keep the two in step. For ``count=5``
+    the text is the original EiPL prompt, unchanged.
+    """
+    if count < 1:
+        raise ValueError(f"count must be at least 1, got {count}")
+    number = _NUMBER_WORDS.get(count, str(count))
+    if count == 1:
+        request = (
+            f"Create exactly one implementation of a function called {function_name}"
+        )
+        guidelines = [
+            "Make the code beginner-friendly and avoid unnecessary built-in functions",
+            f"The function MUST be named exactly: {function_name}. If it is not the grading mechanism will fail.",
+            "Return only the function implementation, no additional text or comments",
+        ]
+    else:
+        request = f"Create {number} different implementations of a function called {function_name}"
+        guidelines = [
+            "Each implementation MUST be different",
+            "Make the code beginner-friendly and avoid unnecessary built-in functions",
+            f"Each function MUST be named exactly: {function_name}. If it is not the grading mechanism will fail.",
+            "Return only the function implementations, no additional text or comments",
+        ]
+    numbered = "\n".join(f"{i}. {g}" for i, g in enumerate(guidelines, start=1))
+    labels = (
+        ["implementation"]
+        if count == 1
+        else [f"implementation {i}" for i in range(1, count + 1)]
+    )
+    stubs = "".join(
+        f"```python\ndef {function_name}(...):\n    # {label}\n```\n"
+        for label in labels
+    )
+    return (
+        f"\n{request} based on the user's description.\n"
+        "The function should match this problem:\n\n"
+        f"Guidelines:\n{numbered}\n\n"
+        f"Format your response as:\n{stubs}"
+    )
+
 
 class AITestGenerationService:
     """
@@ -70,9 +129,11 @@ def _call_ai(self, messages, max_tokens=2000, temperature=0):
             logger.error(f"❌ AI call failed: {str(e)}")
             raise
 
-    def _generate_eipl_variations(self, problem, user_prompt: str) -> dict[str, Any]:
+    def _generate_eipl_variations(
+        self, problem, user_prompt: str, count: int = 5
+    ) -> dict[str, Any]:
         """
-        Generate code variations for EiPL problems.
+        Generate ``count`` code versions of the user's description.
         Uses synchronous client - gevent handles I/O concurrency automatically.
         """
         if not self.client:
@@ -84,39 +145,7 @@ def _generate_eipl_variations(self, problem, user_prompt: str) -> dict[str, Any]
             }
 
         try:
-            # Create a system prompt specific to the problem
-            system_prompt = f"""
-Create five different implementations of a function called {problem.function_name} based on the user's description.
-The function should match this problem:
-
-Guidelines:
-1. Each implementation MUST be different
-2. Make the code beginner-friendly and avoid unnecessary built-in functions
-3. Each function MUST be named exactly: {problem.function_name}. If it is not the grading mechanism will fail.
-4. Return only the function implementations, no additional text or comments
-
-Format your response as:
-```python
-def {problem.function_name}(...):
-    # implementation 1
-```
-```python
-def {problem.function_name}(...):
-    # implementation 2
-```
-```python
-def {problem.function_name}(...):
-    # implementation 3
-```
-```python
-def {problem.function_name}(...):
-    # implementation 4
-```
-```python
-def {problem.function_name}(...):
-    # implementation 5
-```
-"""
+            system_prompt = _variation_system_prompt(problem.function_name, count)
 
             # Build messages for AI API call
             messages = [
@@ -158,17 +187,17 @@ def {problem.function_name}(...):
                 if f"def {problem.function_name}" in code:
                     valid_variations.append(code.strip())
 
-            # Require exactly 5 variations for a successful generation
-            if len(valid_variations) < 5:
+            # Require exactly ``count`` variations for a successful generation
+            if len(valid_variations) < count:
                 logger.warning(
-                    f"Insufficient variations generated: {len(valid_variations)}/5. "
+                    f"Insufficient variations generated: {len(valid_variations)}/{count}. "
                     f"User prompt length: {len(user_prompt)} chars"
                 )
                 return {
                     "success": False,
                     "error": (
                         f"Could not generate enough code variations from your description "
-                        f"({len(valid_variations)}/5 generated). Please try again with a more "
+                        f"({len(valid_variations)}/{count} generated). Please try again with a more "
                         "detailed explanation of the code's behavior."
                     ),
                     "variations": valid_variations,
@@ -177,7 +206,7 @@ def {problem.function_name}(...):
 
             return {
                 "success": True,
-                "variations": valid_variations[:5],
+                "variations": valid_variations[:count],
                 "error": None,
                 "model": self.model_name,
             }
@@ -191,7 +220,9 @@ def {problem.function_name}(...):
                 "model": self.model_name,
             }
 
-    def generate_eipl_variations(self, problem, user_prompt: str) -> dict[str, Any]:
+    def generate_eipl_variations(
+        self, problem, user_prompt: str, count: int = 5
+    ) -> dict[str, Any]:
         """
         Public entry point for EiPL variation generation.
 
@@ -199,4 +230,4 @@ def generate_eipl_variations(self, problem, user_prompt: str) -> dict[str, Any]:
         Works seamlessly with both gevent (production) and prefork (development) workers.
         Gevent automatically handles I/O concurrency via monkey patching.
         """
-        return self._generate_eipl_variations(problem, user_prompt)
+        return self._generate_eipl_variations(problem, user_prompt, count)
diff --git a/purplex/problems_app/services/mock_openai.py b/purplex/problems_app/services/mock_openai.py
index 85cbb4eb..e06630d0 100644
--- a/purplex/problems_app/services/mock_openai.py
+++ b/purplex/problems_app/services/mock_openai.py
@@ -20,6 +20,11 @@
 
 logger = logging.getLogger(__name__)
 
+# Matches the variation prompt from ai_generation_service._variation_system_prompt;
+# the prompt lists one "# implementation" stub per requested version.
+_VARIATION_REQUEST = re.compile(r"implementations? of a function called (\w+)")
+_VARIATION_STUB = re.compile(r"^\s*# implementation\b", re.MULTILINE)
+
 
 class _MockMessage:
     """Mimics openai.types.chat.ChatCompletionMessage."""
@@ -59,7 +64,7 @@ def create(self, *, model, messages, **kwargs):
                 system_content = msg.get("content", "")
                 break
 
-        if "Create five different implementations" in system_content:
+        if _VARIATION_REQUEST.search(system_content):
             content = self._variation_response(messages, system_content)
         elif "ONE-TO-ONE MAPPING RULES" in system_content:
             content = self._segmentation_response(messages, system_content)
@@ -70,7 +75,11 @@ def create(self, *, model, messages, **kwargs):
         return _MockCompletion(content)
 
     def _variation_response(self, messages, system_content) -> str:
-        """Return 5 code variations using the reference solution.
+        """Return as many code variations as the prompt asks for.
+
+        The count is the number of ``# implementation`` stubs in the prompt
+        built by ``_variation_system_prompt`` (five for EiPL and Prompt, one
+        for Probeable Spec). Each variation is the reference solution.
 
         The reference solution is injected as a developer/mock_context message
         by _generate_eipl_variations when mock mode is active.
@@ -80,9 +89,9 @@ def _variation_response(self, messages, system_content) -> str:
             if msg.get("role") == "developer" and msg.get("name") == "mock_context":
                 reference_solution = msg.get("content", "")
 
-        # Extract function name from system prompt
-        match = re.search(r"function called (\w+)", system_content)
+        match = _VARIATION_REQUEST.search(system_content)
         func_name = match.group(1) if match else "unknown"
+        count = len(_VARIATION_STUB.findall(system_content)) or 1
 
         if reference_solution:
             code = reference_solution.strip()
@@ -90,7 +99,7 @@ def _variation_response(self, messages, system_content) -> str:
             code = f"def {func_name}(*args, **kwargs):\n    pass"
 
         blocks = []
-        for i in range(5):
+        for i in range(count):
             comment = f"# variation {i + 1}\n" if i > 0 else ""
             blocks.append(f"```python\n{comment}{code}\n```")
         return "\n\n".join(blocks)
diff --git a/purplex/problems_app/tasks/pipeline.py b/purplex/problems_app/tasks/pipeline.py
index 46b63770..4b500a4a 100644
--- a/purplex/problems_app/tasks/pipeline.py
+++ b/purplex/problems_app/tasks/pipeline.py
@@ -267,9 +267,13 @@ def _build_cached_mcq_result(submission: "Submission") -> dict[str, Any]:
 
 
 def generate_variations_helper(
-    problem_id: int, user_prompt: str, user_id: int | None = None
+    problem_id: int, user_prompt: str, user_id: int | None = None, count: int = 5
 ) -> list[str]:
-    """Helper function to generate code variations using repository layer."""
+    """Generate ``count`` code versions of the user's description.
+
+    ``count`` is the activity handler's ``variation_count`` (five for EiPL and
+    Prompt, one for Probeable Spec).
+    """
     # AI consent gate: block generation if user hasn't consented
     if user_id is not None:
         from django.conf import settings as django_settings
@@ -299,7 +303,7 @@ def generate_variations_helper(
         raise Exception(f"Problem {problem_id} not found or not active")
 
     ai_service = AITestGenerationService()
-    result = ai_service.generate_eipl_variations(problem, user_prompt)
+    result = ai_service.generate_eipl_variations(problem, user_prompt, count=count)
 
     if not result["success"]:
         raise Exception(f"AI generation failed: {result.get('error', 'Unknown error')}")
@@ -823,8 +827,20 @@ def execute_eipl_pipeline(
             span = None
 
         try:
+            # The activity's handler decides how many versions to generate
+            # and how to score them (Probeable Spec: one, scored by tests).
+            from purplex.problems_app.handlers import get_handler
+
+            problem = ProblemRepository.get_by_id(problem_id)
+            if not problem:
+                raise Exception(f"Problem {problem_id} not found")
+            code_handler = get_handler(problem.problem_type)
+
             variations = generate_variations_helper(
-                problem_id, user_prompt, user_id=user_id
+                problem_id,
+                user_prompt,
+                user_id=user_id,
+                count=code_handler.variation_count,
             )
             variation_count = len(variations)
             logger.info(
@@ -974,11 +990,7 @@ def execute_eipl_pipeline(
         # Step 3: Aggregate results (70-80% progress)
         logger.info(f"⏱️  STEP 3: Aggregating results (task {task_id})")
         publish_progress(task_id, 70, "Aggregating test results...")
-        score = int(
-            (successful_variations / variation_count * 100)
-            if variation_count > 0
-            else 0
-        )
+        score = code_handler.score_generated_code(test_results)
         logger.info(
             f"📊 Score calculated: {score}% ({successful_variations}/{variation_count} passed)"
         )
diff --git a/purplex/problems_app/views/submission_views.py b/purplex/problems_app/views/submission_views.py
index 878c96f3..50b9251b 100644
--- a/purplex/problems_app/views/submission_views.py
+++ b/purplex/problems_app/views/submission_views.py
@@ -239,7 +239,7 @@ def get(self, request):
 
 
 def _lock_after_first_failure(submission_data: dict) -> None:
-    """Hide probeable_code test rows after the first failure (papers' rule).
+    """Hide probeable test rows after the first failure (papers' rule).
 
     Counts (``tests_passed``/``total_tests``) keep reflecting every test; only
     the visible rows are truncated and the hidden remainder is reported as
@@ -407,7 +407,7 @@ def get(self, request, problem_slug):
                 "variations_count": variations.count(),
                 "comprehension_level": (
                     submission.comprehension_level
-                    if submission.submission_type == "eipl"
+                    if submission.submission_type in ("eipl", "probeable_spec")
                     else None
                 ),
                 "segmentation": segmentation_data,  # Include segmentation data
@@ -506,7 +506,7 @@ def get(self, request, problem_slug):
                 ),
             }
 
-            if submission.submission_type == "probeable_code":
+            if submission.submission_type in ("probeable_code", "probeable_spec"):
                 _lock_after_first_failure(submission_data)
 
             submission_history.append(submission_data)
diff --git a/tests/integration/test_probeable_result_visibility.py b/tests/integration/test_probeable_result_visibility.py
index 18c260bb..b77d79f7 100644
--- a/tests/integration/test_probeable_result_visibility.py
+++ b/tests/integration/test_probeable_result_visibility.py
@@ -1,11 +1,14 @@
-"""Integration tests for student-facing truncation of probeable_code results.
+"""Integration tests for student-facing truncation of probeable results.
 
 Students see test rows only up to and including the first failure; the rest
 are locked (Denny et al. ITiCSE 2025 Section 4.2; Tang et al. ACE 2026
 Section 3.1.5). Instructor/admin views must still see every test.
 """
 
+from unittest.mock import MagicMock, patch
+
 import pytest
+from django.test import override_settings
 from rest_framework import status
 
 from tests.factories import (
@@ -19,6 +22,8 @@
 
 pytestmark = [pytest.mark.integration, pytest.mark.django_db]
 
+PIPELINE = "purplex.problems_app.tasks.pipeline"
+
 
 def _submission_with_three_tests(user, problem, submission_type):
     """A submission whose tests ran [pass, fail, fail] in one variation."""
@@ -134,9 +139,30 @@ def test_last_submission_locks_tests_after_first_failure(
         assert entry["totalTests"] == 3
         assert entry["lockedCount"] == 1
 
+    def test_spec_last_submission_locks_tests_after_first_failure(
+        self, authenticated_client, user
+    ):
+        submission = _submission_with_three_tests(
+            user, ProbeableSpecProblemFactory(), "probeable_spec"
+        )
+
+        response = authenticated_client.get(
+            f"/api/last-submission/{submission.problem.slug}/"
+        )
+        assert response.status_code == status.HTTP_200_OK
+
+        entries = response.data["results"]
+        assert len(entries) == 1
+        assert [r["isSuccessful"] for r in entries[0]["test_results"]] == [True, False]
+        assert entries[0]["lockedCount"] == 1
+
 
-class TestOtherTypesUntruncated:
-    def test_probeable_spec_history_shows_every_test(self, authenticated_client, user):
+class TestProbeableSpecHistory:
+    """Spec submissions get the same ladder rules as probeable_code."""
+
+    def test_probeable_spec_history_locks_tests_after_first_failure(
+        self, authenticated_client, user
+    ):
         submission = _submission_with_three_tests(
             user, ProbeableSpecProblemFactory(), "probeable_spec"
         )
@@ -147,14 +173,94 @@ def test_probeable_spec_history_shows_every_test(self, authenticated_client, use
         assert response.status_code == status.HTTP_200_OK
 
         attempt = response.data["submissions"][0]
-        assert "locked_count" not in attempt
+        assert attempt["tests_passed"] == 1
+        assert attempt["total_tests"] == 3
+        assert attempt["locked_count"] == 1
         variation = attempt["data"]["variations"][0]
-        assert [r["passed"] for r in variation["test_results"]] == [
-            True,
-            False,
-            False,
-        ]
-        assert "locked_count" not in variation
+        assert [r["passed"] for r in variation["test_results"]] == [True, False]
+        assert variation["locked_count"] == 1
+
+        entry = attempt["type_specific"]["test_results"][0]
+        assert len(entry["test_results"]) == 2
+        assert entry["lockedCount"] == 1
+
+    def test_probeable_spec_history_reports_comprehension_level(
+        self, authenticated_client, user
+    ):
+        problem = ProbeableSpecProblemFactory()
+        SubmissionFactory(
+            user=user,
+            problem=problem,
+            submission_type="probeable_spec",
+            comprehension_level="high-level",
+        )
+
+        response = authenticated_client.get(f"/api/submissions/history/{problem.slug}/")
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["submissions"][0]["comprehension_level"] == "high-level"
+
+    def test_spec_pipeline_attempt_counts_one_version(self, authenticated_client, user):
+        """Two tests and one generated version read 2/2, not 10/10 (five versions).
+
+        Runs the real pipeline against the dev mock LLM so the mock's version
+        count is exercised too; Docker and Redis are mocked.
+        """
+        from purplex.problems_app.tasks.pipeline import execute_eipl_pipeline
+
+        problem = ProbeableSpecProblemFactory(
+            is_active=True, requires_highlevel_comprehension=False
+        )
+        for order in range(2):
+            TestCaseFactory(
+                problem=problem, inputs=[order], expected_output=order**2, order=order
+            )
+        submission = SubmissionFactory(
+            user=user,
+            problem=problem,
+            submission_type="probeable_spec",
+            raw_input="It squares its argument.",
+        )
+        docker_result = {
+            "testsPassed": 2,
+            "totalTests": 2,
+            "success": True,
+            "results": [
+                {"pass": True, "inputs": [i], "expected_output": i**2} for i in range(2)
+            ],
+        }
+
+        with (
+            override_settings(
+                USE_MOCK_OPENAI=True, PRIVACY_ENABLE_AI_CONSENT_GATE=False
+            ),
+            patch(f"{PIPELINE}.SharedDockerServiceContext") as mock_ctx,
+            patch(f"{PIPELINE}.publish_progress"),
+            patch(f"{PIPELINE}.publish_completion"),
+            patch("purplex.submissions.services.ProgressService.process_submission"),
+        ):
+            service = MagicMock()
+            service.test_solution.return_value = docker_result
+            mock_ctx.return_value.__enter__.return_value = service
+            execute_eipl_pipeline.apply(
+                args=[
+                    problem.id,
+                    submission.raw_input,
+                    user.id,
+                    submission.problem_set_id,
+                    None,
+                    str(submission.submission_id),
+                ]
+            ).get()
+
+        assert service.test_solution.call_count == 1
+
+        response = authenticated_client.get(f"/api/submissions/history/{problem.slug}/")
+        assert response.status_code == status.HTTP_200_OK
+        attempt = response.data["submissions"][0]
+        assert attempt["tests_passed"] == 2
+        assert attempt["total_tests"] == 2
+        assert attempt["variations_count"] == 1
+        assert attempt["locked_count"] == 0
 
 
 class TestStaffViewUntruncated:
diff --git a/tests/unit/test_handlers_probeable_spec.py b/tests/unit/test_handlers_probeable_spec.py
index 396cd664..6abdd147 100644
--- a/tests/unit/test_handlers_probeable_spec.py
+++ b/tests/unit/test_handlers_probeable_spec.py
@@ -246,8 +246,36 @@ def test_count_passing_variations_none(self, handler):
         assert handler.count_passing_variations(submission) == 0
 
 
+def _variations_with(test_execs, tests_passed, tests_total):
+    """Mock ``submission.code_variations`` holding one variation."""
+    mock_test_execs = MagicMock()
+    mock_test_execs.order_by.return_value = mock_test_execs
+    mock_test_execs.exists.return_value = bool(test_execs)
+    mock_test_execs.__iter__ = lambda self: iter(test_execs)
+
+    variation = MagicMock()
+    variation.tests_passed = tests_passed
+    variation.tests_total = tests_total
+    variation.test_executions.all.return_value = mock_test_execs
+
+    mock_cv = MagicMock()
+    mock_cv.exists.return_value = True
+    mock_cv.first.return_value = variation
+    return mock_cv
+
+
+def _test_exec(passed, value=1):
+    test_exec = MagicMock()
+    test_exec.passed = passed
+    test_exec.input_values = [value]
+    test_exec.expected_output = str(value)
+    test_exec.actual_output = str(value) if passed else "0"
+    test_exec.error_message = None
+    return test_exec
+
+
 class TestProbeableSpecExtractTestResults:
-    """Tests for Probeable Spec test result extraction."""
+    """Spec shows its one generated version as the probeable_code ladder."""
 
     @pytest.fixture
     def handler(self):
@@ -255,29 +283,8 @@ def handler(self):
 
     def test_extract_test_results_with_test_executions(self, handler):
         """Should format test execution records."""
-        test_exec = MagicMock()
-        test_exec.passed = True
-        test_exec.input_values = [5]
-        test_exec.expected_output = "10"
-        test_exec.actual_output = "10"
-        test_exec.error_message = None
-
-        mock_test_execs = MagicMock()
-        mock_test_execs.order_by.return_value = mock_test_execs
-        mock_test_execs.exists.return_value = True
-        mock_test_execs.__iter__ = lambda self: iter([test_exec])
-
-        variation = MagicMock()
-        variation.variation_index = 0
-        variation.tests_passed = 1
-        variation.tests_total = 1
-        variation.test_executions.all.return_value = mock_test_execs
-
-        mock_qs = MagicMock()
-        mock_qs.order_by.return_value = [variation]
-
         submission = MagicMock()
-        submission.code_variations.all.return_value = mock_qs
+        submission.code_variations = _variations_with([_test_exec(True, 5)], 1, 1)
 
         problem = MagicMock()
         problem.function_name = "double"
@@ -288,44 +295,30 @@ def test_extract_test_results_with_test_executions(self, handler):
         assert results[0]["testsPassed"] == 1
         assert results[0]["totalTests"] == 1
         assert results[0]["test_results"][0]["isSuccessful"] is True
+        assert results[0]["test_results"][0]["function_call"] == "double(5)"
+        assert results[0]["lockedCount"] == 0
 
-    def test_extract_test_results_fallback_placeholder(self, handler):
-        """Should create placeholder results when no TestExecution records exist."""
-        mock_test_execs = MagicMock()
-        mock_test_execs.order_by.return_value = mock_test_execs
-        mock_test_execs.exists.return_value = False
-
-        variation = MagicMock()
-        variation.variation_index = 0
-        variation.tests_passed = 2
-        variation.tests_total = 3
-        variation.test_executions.all.return_value = mock_test_execs
-
-        mock_qs = MagicMock()
-        mock_qs.order_by.return_value = [variation]
-
+    def test_extract_test_results_locks_after_first_failure(self, handler):
+        """Rows after the first failure are locked; counts still cover all."""
         submission = MagicMock()
-        submission.code_variations.all.return_value = mock_qs
-
+        submission.code_variations = _variations_with(
+            [_test_exec(True), _test_exec(False), _test_exec(True)], 2, 3
+        )
         problem = MagicMock()
-        problem.function_name = "solve"
+        problem.function_name = "f"
 
-        results = handler.extract_test_results(submission, problem)
-        assert len(results) == 1
-        assert results[0]["success"] is False  # 2/3 != all
-        assert len(results[0]["test_results"]) == 3
-        # First 2 should be passing (tests_passed=2), last should fail
-        assert results[0]["test_results"][0]["isSuccessful"] is True
-        assert results[0]["test_results"][1]["isSuccessful"] is True
-        assert results[0]["test_results"][2]["isSuccessful"] is False
+        entry = handler.extract_test_results(submission, problem)[0]
+        assert [r["isSuccessful"] for r in entry["test_results"]] == [True, False]
+        assert entry["testsPassed"] == 2
+        assert entry["totalTests"] == 3
+        assert entry["success"] is False
+        assert entry["lockedCount"] == 1
+        assert entry["visibleCount"] == 2
 
     def test_extract_test_results_empty(self, handler):
         """Should return empty list when no variations."""
-        mock_qs = MagicMock()
-        mock_qs.order_by.return_value = []
-
         submission = MagicMock()
-        submission.code_variations.all.return_value = mock_qs
+        submission.code_variations.exists.return_value = False
 
         problem = MagicMock()
         results = handler.extract_test_results(submission, problem)
@@ -333,30 +326,8 @@ def test_extract_test_results_empty(self, handler):
 
     def test_extract_test_results_duplicate_keys(self, handler):
         """Should include both 'test_results' and 'results' keys."""
-        test_exec = MagicMock()
-        test_exec.passed = True
-        test_exec.input_values = [1]
-        test_exec.expected_output = "1"
-        test_exec.actual_output = "1"
-        test_exec.error_message = None
-
-        mock_test_execs = MagicMock()
-        mock_test_execs.order_by.return_value = mock_test_execs
-        mock_test_execs.exists.return_value = True
-        mock_test_execs.__iter__ = lambda self: iter([test_exec])
-
-        variation = MagicMock()
-        variation.variation_index = 0
-        variation.tests_passed = 1
-        variation.tests_total = 1
-        variation.test_executions.all.return_value = mock_test_execs
-
-        mock_qs = MagicMock()
-        mock_qs.order_by.return_value = [variation]
-
         submission = MagicMock()
-        submission.code_variations.all.return_value = mock_qs
-
+        submission.code_variations = _variations_with([_test_exec(True)], 1, 1)
         problem = MagicMock()
         problem.function_name = "f"
 
@@ -462,24 +433,9 @@ def mock_submission(self):
         submission.problem.get_segmentation_threshold = 2
         submission.problem.function_name = "solve"
 
-        # Mock variations
-        var1 = MagicMock()
-        var1.generated_code = "def solve(x): return x"
-        var1.score = 100
-        var1.tests_passed = 3
-        var1.tests_total = 3
-        var1.is_selected = True
-
-        mock_test_execs = MagicMock()
-        mock_test_execs.order_by.return_value = mock_test_execs
-        mock_test_execs.exists.return_value = False
-        mock_test_execs.__iter__ = lambda self: iter([])
-        var1.test_executions.all.return_value = mock_test_execs
-
-        mock_qs = MagicMock()
-        mock_qs.order_by.return_value = [var1]
-        mock_qs.__iter__ = lambda self: iter([var1])
-        submission.code_variations.all.return_value = mock_qs
+        submission.processed_code = "def solve(x): return x"
+        submission.raw_input = "It returns its argument."
+        submission.code_variations = _variations_with([_test_exec(True)], 1, 1)
 
         # Mock segmentation
         seg = MagicMock()
@@ -497,15 +453,19 @@ def mock_submission(self):
 
     def test_serialize_result_structure(self, handler, mock_submission):
         result = handler.serialize_result(mock_submission)
-        assert "variations" in result
-        assert "test_results" in result
-        assert "segmentation" in result
-
-    def test_serialize_result_variations(self, handler, mock_submission):
+        assert set(result) == {
+            "student_code",
+            "explanation",
+            "test_results",
+            "segmentation",
+        }
+
+    def test_serialize_result_code_and_explanation(self, handler, mock_submission):
         result = handler.serialize_result(mock_submission)
-        assert len(result["variations"]) == 1
-        assert result["variations"][0]["code"] == "def solve(x): return x"
-        assert result["variations"][0]["score"] == 100
+        assert result["student_code"] == "def solve(x): return x"
+        assert result["explanation"] == "It returns its argument."
+        assert len(result["test_results"]) == 1
+        assert result["test_results"][0]["lockedCount"] == 0
 
     def test_serialize_result_segmentation(self, handler, mock_submission):
         result = handler.serialize_result(mock_submission)
@@ -520,10 +480,7 @@ def test_serialize_result_no_segmentation(self, handler):
         submission.problem = MagicMock()
         submission.problem.function_name = "f"
 
-        mock_qs = MagicMock()
-        mock_qs.order_by.return_value = []
-        mock_qs.__iter__ = lambda self: iter([])
-        submission.code_variations.all.return_value = mock_qs
+        submission.code_variations.exists.return_value = False
 
         del submission.segmentation
 
diff --git a/tests/unit/test_probeable_spec_single_version.py b/tests/unit/test_probeable_spec_single_version.py
new file mode 100644
index 00000000..a686d852
--- /dev/null
+++ b/tests/unit/test_probeable_spec_single_version.py
@@ -0,0 +1,388 @@
+"""
+Probeable Spec generates one code version and shows the probeable test ladder.
+
+``probeable_spec`` shares ``execute_eipl_pipeline`` with EiPL and Prompt, but the
+student is explaining a function they discovered by probing, so the LLM turns
+the explanation into a single implementation. That implementation is graded and
+shown exactly like a ``probeable_code`` submission: one ordered ladder, rows up
+to the first failure visible, the rest locked (#165), score = tests passed.
+EiPL and Prompt keep five versions and the variation pass-rate score.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from django.test import override_settings
+
+from purplex.problems_app.handlers import get_handler
+from purplex.problems_app.services.ai_generation_service import (
+    AITestGenerationService,
+)
+from purplex.problems_app.services.mock_openai import MockOpenAIClient
+from tests.factories import (
+    CodeVariationFactory,
+    EiplProblemFactory,
+    ProbeableCodeProblemFactory,
+    ProbeableSpecProblemFactory,
+    ProblemSetFactory,
+    SubmissionFactory,
+    TestCaseFactory,
+    TestExecutionFactory,
+    UserFactory,
+    UserProfileFactory,
+)
+
+pytestmark = [pytest.mark.unit, pytest.mark.django_db]
+
+PIPELINE = "purplex.problems_app.tasks.pipeline"
+
+
+# ─── 1. Variation count is a handler property ────────────────────────────────
+
+
+class TestVariationCount:
+    @pytest.mark.parametrize(
+        "type_name,expected",
+        [("probeable_spec", 1), ("eipl", 5), ("prompt", 5)],
+    )
+    def test_handler_variation_count(self, type_name, expected):
+        assert get_handler(type_name).variation_count == expected
+
+
+def _system_prompt_for(count):
+    """Run _generate_eipl_variations with the LLM call captured."""
+    problem = MagicMock()
+    problem.function_name = "double"
+    problem.reference_solution = "def double(x):\n    return x * 2"
+
+    service = AITestGenerationService.__new__(AITestGenerationService)
+    service.client = object()
+    service.model_name = "test-model"
+    reply = "\n".join(
+        "```python\ndef double(x):\n    return x * 2\n```" for _ in range(count)
+    )
+    with (
+        override_settings(USE_MOCK_OPENAI=False),
+        patch.object(service, "_call_ai", return_value=reply) as call,
+    ):
+        result = service.generate_eipl_variations(problem, "doubles x", count=count)
+    return call.call_args.kwargs["messages"][0]["content"], result
+
+
+class TestGenerationPrompt:
+    def test_count_five_prompt_is_unchanged(self):
+        prompt, result = _system_prompt_for(5)
+        assert "Create five different implementations" in prompt
+        assert "Each implementation MUST be different" in prompt
+        assert prompt.count("def double(...)") == 5
+        assert result["success"] is True
+        assert len(result["variations"]) == 5
+
+    def test_count_one_prompt_asks_for_exactly_one(self):
+        prompt, result = _system_prompt_for(1)
+        assert "Create exactly one implementation" in prompt
+        assert "five" not in prompt
+        assert "different implementations" not in prompt
+        assert "MUST be different" not in prompt
+        assert prompt.count("def double(...)") == 1
+        assert result["success"] is True
+        assert len(result["variations"]) == 1
+
+    def test_default_count_is_five(self):
+        problem = MagicMock()
+        problem.function_name = "double"
+        service = AITestGenerationService.__new__(AITestGenerationService)
+        service.client = object()
+        service.model_name = "test-model"
+        with (
+            override_settings(USE_MOCK_OPENAI=False),
+            patch.object(service, "_call_ai", return_value="") as call,
+        ):
+            service.generate_eipl_variations(problem, "doubles x")
+        assert (
+            "Create five different" in call.call_args.kwargs["messages"][0]["content"]
+        )
+
+
+class TestMockLlmHonoursCount:
+    @pytest.mark.parametrize("count", [1, 5])
+    def test_mock_returns_requested_number_of_versions(self, count):
+        problem = MagicMock()
+        problem.function_name = "double"
+        problem.reference_solution = "def double(x):\n    return x * 2"
+
+        service = AITestGenerationService.__new__(AITestGenerationService)
+        service.client = MockOpenAIClient()
+        service.model_name = "mock-gpt"
+        with override_settings(USE_MOCK_OPENAI=True):
+            result = service.generate_eipl_variations(problem, "doubles", count=count)
+
+        assert result["success"] is True
+        assert len(result["variations"]) == count
+
+
+# ─── Pipeline harness ────────────────────────────────────────────────────────
+
+
+def _user():
+    user = UserFactory()
+    UserProfileFactory(user=user)
+    return user
+
+
+def _docker_result(passes):
+    return {
+        "testsPassed": sum(passes),
+        "totalTests": len(passes),
+        "success": all(passes),
+        "results": [
+            {"pass": p, "inputs": [i], "expected_output": i, "actual_output": i}
+            for i, p in enumerate(passes)
+        ],
+    }
+
+
+def _run_pipeline(problem, user, variations, docker_by_code):
+    """Run execute_eipl_pipeline synchronously; LLM, Docker, Redis mocked.
+
+    Returns (result, ai_service_mock, progress_messages).
+    """
+    from purplex.problems_app.tasks.pipeline import execute_eipl_pipeline
+
+    problem_set = ProblemSetFactory()
+    submission = SubmissionFactory(
+        user=user,
+        problem=problem,
+        problem_set=problem_set,
+        submission_type=problem.problem_type,
+    )
+
+    with (
+        override_settings(PRIVACY_ENABLE_AI_CONSENT_GATE=False),
+        patch(f"{PIPELINE}.AITestGenerationService") as mock_ai_cls,
+        patch(f"{PIPELINE}.SharedDockerServiceContext") as mock_ctx,
+        patch(f"{PIPELINE}.publish_progress") as mock_progress,
+        patch(f"{PIPELINE}.publish_completion"),
+        patch(f"{PIPELINE}.segment_prompt_helper", return_value=None),
+        patch("purplex.submissions.services.ProgressService.process_submission"),
+    ):
+        mock_ai_cls.return_value.generate_eipl_variations.return_value = {
+            "success": True,
+            "variations": variations,
+            "error": None,
+            "model": "test",
+        }
+        service = MagicMock()
+        service.test_solution.side_effect = lambda code, *_a, **_k: docker_by_code[code]
+        mock_ctx.return_value.__enter__.return_value = service
+
+        result = execute_eipl_pipeline.apply(
+            args=[
+                problem.id,
+                "Explain the function in words",
+                user.id,
+                problem_set.id,
+                None,
+                str(submission.submission_id),
+            ]
+        ).get()
+
+    messages = [c.args[2] for c in mock_progress.call_args_list]
+    return result, mock_ai_cls.return_value, messages
+
+
+def _with_tests(problem, n):
+    for i in range(n):
+        TestCaseFactory(problem=problem, inputs=[i], expected_output=i, order=i)
+    return problem
+
+
+class TestPipelineRequestsHandlerCount:
+    @pytest.mark.parametrize(
+        "factory,expected",
+        [(ProbeableSpecProblemFactory, 1), (EiplProblemFactory, 5)],
+    )
+    def test_pipeline_requests_handler_variation_count(self, factory, expected):
+        problem = _with_tests(
+            factory(is_active=True, requires_highlevel_comprehension=False), 1
+        )
+        codes = [f"def f(x):\n    return x  # {i}" for i in range(expected)]
+        _, ai, _ = _run_pipeline(
+            problem, _user(), codes, {c: _docker_result([True]) for c in codes}
+        )
+        ai.generate_eipl_variations.assert_called_once()
+        assert ai.generate_eipl_variations.call_args.kwargs["count"] == expected
+
+
+# ─── 3. Scoring policy ───────────────────────────────────────────────────────
+
+
+class TestPipelineScore:
+    def test_spec_scores_tests_passed_ratio(self):
+        problem = _with_tests(
+            ProbeableSpecProblemFactory(
+                is_active=True, requires_highlevel_comprehension=False
+            ),
+            4,
+        )
+        code = "def discover(x):\n    return x"
+        result, _, messages = _run_pipeline(
+            problem,
+            _user(),
+            [code],
+            {code: _docker_result([True, True, True, False])},
+        )
+
+        assert result["score"] == 75
+        assert "Submission complete! Score: 75%" in messages
+
+    def test_eipl_scores_variation_pass_rate(self):
+        problem = _with_tests(
+            EiplProblemFactory(is_active=True, requires_highlevel_comprehension=False),
+            4,
+        )
+        codes = [f"def test_func(x):\n    return x  # {i}" for i in range(5)]
+        docker = {
+            c: _docker_result([True] * 4 if i < 2 else [False] * 4)
+            for i, c in enumerate(codes)
+        }
+        result, _, messages = _run_pipeline(problem, _user(), codes, docker)
+
+        assert "Submission complete! Score: 40%" in messages
+        assert result["score"] == 40
+
+    def test_handler_score_policies(self):
+        two_of_five = [
+            {"success": True, "testsPassed": 4, "totalTests": 4},
+            {"success": True, "testsPassed": 4, "totalTests": 4},
+            {"success": False, "testsPassed": 3, "totalTests": 4},
+            {"success": False, "testsPassed": 3, "totalTests": 4},
+            {"success": False, "testsPassed": 3, "totalTests": 4},
+        ]
+        assert get_handler("eipl").score_generated_code(two_of_five) == 40
+        assert get_handler("prompt").score_generated_code(two_of_five) == 40
+        assert get_handler("probeable_spec").score_generated_code(two_of_five) == 85
+        assert get_handler("probeable_spec").score_generated_code([]) == 0
+
+
+# ─── 2. Spec payload is the probeable_code ladder ────────────────────────────
+
+
+def _submission_with_ladder(problem, submission_type, passes, hidden=()):
+    """One variation whose tests ran in order with the given pass pattern."""
+    code = "def discover(x):\n    return x"
+    submission = SubmissionFactory(
+        problem=problem,
+        submission_type=submission_type,
+        raw_input="It returns its argument unchanged.",
+        processed_code=code,
+    )
+    variation = CodeVariationFactory(
+        submission=submission,
+        variation_index=0,
+        generated_code=code,
+        tests_passed=sum(passes),
+        tests_total=len(passes),
+    )
+    for order, passed in enumerate(passes):
+        test_case = TestCaseFactory(
+            problem=problem,
+            inputs=[100 + order],
+            expected_output=order,
+            order=order,
+            is_hidden=order in hidden,
+        )
+        TestExecutionFactory(
+            submission=submission,
+            code_variation=variation,
+            test_case=test_case,
+            execution_order=order,
+            passed=passed,
+            input_values=[100 + order],
+            expected_output=order,
+            actual_output=order if passed else -1,
+        )
+    return submission
+
+
+class TestSpecLadder:
+    @pytest.fixture
+    def handler(self):
+        return get_handler("probeable_spec")
+
+    def test_first_failure_visible_later_tests_locked(self, handler):
+        submission = _submission_with_ladder(
+            ProbeableSpecProblemFactory(), "probeable_spec", (True, False, False)
+        )
+        entries = handler.extract_test_results(submission, submission.problem)
+
+        assert len(entries) == 1
+        entry = entries[0]
+        assert [r["isSuccessful"] for r in entry["test_results"]] == [True, False]
+        assert entry["results"] is entry["test_results"]
+        assert entry["testsPassed"] == 1
+        assert entry["totalTests"] == 3
+        assert entry["success"] is False
+        assert entry["lockedCount"] == 1
+        assert entry["visibleCount"] == 2
+
+    def test_hidden_test_after_first_failure_is_withheld(self, handler):
+        submission = _submission_with_ladder(
+            ProbeableSpecProblemFactory(),
+            "probeable_spec",
+            (False, True, False),
+            hidden=(2,),
+        )
+        payload = handler.serialize_result(submission)
+
+        assert "102" not in str(payload["test_results"])
+        assert payload["test_results"][0]["lockedCount"] == 2
+
+    def test_all_pass_locks_nothing(self, handler):
+        submission = _submission_with_ladder(
+            ProbeableSpecProblemFactory(), "probeable_spec", (True, True)
+        )
+        entry = handler.extract_test_results(submission, submission.problem)[0]
+
+        assert entry["success"] is True
+        assert entry["lockedCount"] == 0
+        assert entry["visibleCount"] == 2
+
+    def test_ladder_matches_probeable_code(self, handler):
+        passes = (True, True, False, True)
+        spec = _submission_with_ladder(
+            ProbeableSpecProblemFactory(), "probeable_spec", passes
+        )
+        code = _submission_with_ladder(
+            ProbeableCodeProblemFactory(function_name="discover"),
+            "probeable_code",
+            passes,
+        )
+
+        assert handler.extract_test_results(spec, spec.problem) == get_handler(
+            "probeable_code"
+        ).extract_test_results(code, code.problem)
+
+    def test_serialize_result_has_probeable_code_shape(self, handler):
+        submission = _submission_with_ladder(
+            ProbeableSpecProblemFactory(), "probeable_spec", (True, False)
+        )
+        payload = handler.serialize_result(submission)
+
+        assert set(payload) == {
+            "student_code",
+            "explanation",
+            "test_results",
+            "segmentation",
+        }
+        assert payload["student_code"] == "def discover(x):\n    return x"
+        assert payload["explanation"] == "It returns its argument unchanged."
+        assert payload["segmentation"] is None
+        assert len(payload["test_results"]) == 1
+        assert payload["test_results"][0]["lockedCount"] == 0
+
+    def test_no_variation_yields_empty_ladder(self, handler):
+        submission = SubmissionFactory(
+            problem=ProbeableSpecProblemFactory(), submission_type="probeable_spec"
+        )
+        assert handler.extract_test_results(submission, submission.problem) == []
diff --git a/tests/unit/test_spec_handler_dispatch.py b/tests/unit/test_spec_handler_dispatch.py
index e8fc379a..cd3c0703 100644
--- a/tests/unit/test_spec_handler_dispatch.py
+++ b/tests/unit/test_spec_handler_dispatch.py
@@ -30,10 +30,21 @@
 
 PIPELINE = "purplex.problems_app.tasks.pipeline"
 
-# (problem factory, expected handler type, handler class whose serializer must run)
+# (problem factory, expected handler type, handler class whose serializer must run,
+#  keys that serializer's payload carries)
 PIPELINE_TYPES = [
-    pytest.param(ProbeableSpecProblemFactory, "probeable_spec", ProbeableSpecHandler),
-    pytest.param(EiplProblemFactory, "eipl", EiPLHandler),
+    pytest.param(
+        ProbeableSpecProblemFactory,
+        "probeable_spec",
+        ProbeableSpecHandler,
+        {"student_code", "explanation", "test_results", "segmentation"},
+    ),
+    pytest.param(
+        EiplProblemFactory,
+        "eipl",
+        EiPLHandler,
+        {"variations", "test_results", "segmentation"},
+    ),
 ]
 
 
@@ -99,10 +110,10 @@ class TestPipelineCompletionEnvelopeHandler:
     """The live pipeline must dispatch on the submission's real type."""
 
     @pytest.mark.parametrize(
-        "problem_factory,expected_type,handler_cls", PIPELINE_TYPES
+        "problem_factory,expected_type,handler_cls,result_keys", PIPELINE_TYPES
     )
     def test_envelope_uses_submission_handler(
-        self, problem_factory, expected_type, handler_cls
+        self, problem_factory, expected_type, handler_cls, result_keys
     ):
         user = _make_user()
         problem = _make_problem(problem_factory)
@@ -128,9 +139,7 @@ def test_envelope_uses_submission_handler(
         assert result["problem_type"] == expected_type
         assert published["problem_type"] == expected_type
         assert spy.call_count == 1
-        assert {"variations", "test_results", "segmentation"} <= set(
-            result["result"].keys()
-        )
+        assert result_keys <= set(result["result"].keys())
 
     def test_spec_without_submission_id_records_spec_type(self):
         """Legacy path (pipeline creates the row) must not label spec as eipl."""
@@ -150,10 +159,10 @@ class TestCachedResultEnvelopeHandler:
     """The idempotent-retry twin must dispatch the same way as the live path."""
 
     @pytest.mark.parametrize(
-        "problem_factory,expected_type,handler_cls", PIPELINE_TYPES
+        "problem_factory,expected_type,handler_cls,result_keys", PIPELINE_TYPES
     )
     def test_cached_envelope_uses_submission_handler(
-        self, problem_factory, expected_type, handler_cls
+        self, problem_factory, expected_type, handler_cls, result_keys
     ):
         from purplex.problems_app.tasks.pipeline import _build_cached_eipl_result
 
@@ -176,9 +185,7 @@ def test_cached_envelope_uses_submission_handler(
 
         assert result["problem_type"] == expected_type
         assert spy.call_count == 1
-        assert {"variations", "test_results", "segmentation"} <= set(
-            result["result"].keys()
-        )
+        assert result_keys <= set(result["result"].keys())
 
 
 class TestRequiresAiConsent: