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: