fix(loops): normalize advisory deliverable fields — an authored omission cannot poison the next generation

src/runtime/strategy-evolution.ts

@@ -329,7 +329,7 @@ const compactLosses = (report: BenchmarkReport, detail: 'exact' | 'binary'): str
                     score: r2(c.score),
                     resolved: c.resolved,
                     usd: Math.round(c.usd * 10000) / 10000,
-                    progression: c.progression.map(r2),
+                    progression: (c.progression ?? []).map(r2),
                   },
             ]),
           ),

src/runtime/strategy.ts

@@ -842,10 +842,20 @@ export function defineStrategy(
         }
         const r = await run(ctx)
         // Override the body's self-reported score/resolved with the harness-verified
-        // values. The body's progression/completions/shots are advisory (display only).
+        // values. The body's progression/completions/shots are advisory (display only) —
+        // but NORMALIZED: an authored body that omits them must not poison downstream
+        // consumers (losses tables, anytime curves) with undefined.
         return {
           kind: 'done',
-          deliverable: { mode: name, ...r, score: verifiedBest, resolved: verifiedResolved },
+          deliverable: {
+            mode: name,
+            ...r,
+            progression: Array.isArray(r.progression) ? r.progression : [],
+            completions: typeof r.completions === 'number' ? r.completions : 0,
+            shots: typeof r.shots === 'number' ? r.shots : 0,
+            score: verifiedBest,
+            resolved: verifiedResolved,
+          },
         }
       },
     }),

tests/loops/strategy-suite.test.ts

@@ -660,3 +660,26 @@ describe('consult', () => {
     expect(reply).toBe('DONE')
   })
 })
+
+describe('advisory-field normalization', () => {
+  it('a body omitting progression/completions/shots yields a well-formed cell', async () => {
+    stubRouter()
+    const surface = fixtureSurface(() => ({ passes: 1, total: 2 }))
+    const sloppy = defineStrategy('sloppy', async ({ shot }) => {
+      await shot()
+      // An authored body returning only the verified-overridden fields.
+      return { score: 0, resolved: false } as never
+    })
+    const report = await runBenchmark({
+      environment: surface,
+      tasks: [task],
+      worker,
+      strategies: [sloppy],
+      budget: 1,
+      concurrency: 1,
+    })
+    const cell = report.perTask[0]?.cells?.sloppy
+    expect(cell?.progression).toEqual([])
+    expect(cell?.score).toBeCloseTo(0.5)
+  })
+})