@alecsibilia/luca 14.0.0-alpha.13 → 14.0.0-alpha.15

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.15
+
+No changes in this release.
+
+## 14.0.0-alpha.14
+
+No changes in this release.
+
 ## 14.0.0-alpha.13
 
 No changes in this release.

package/board/client/board-look.ts

@@ -73,7 +73,11 @@ export const stageColor = ({
     switch (stage) {
         case 'building':
         case 'reviewing':
+        case 'testing':
+        case 'joining':
             return theme.colors.accent
+        case 'fixing':
+            return theme.colors.statusWarning
         case 'stuck':
             return theme.colors.statusDanger
         case 'done':

package/board/client/board-panel.tsx

@@ -55,8 +55,9 @@ import { postedText, type PostedReply } from '../shared/reply-actions'
 /**
  * The side panel: one run of this workspace, top to bottom. Plan usage, a
  * limit-wait banner, "Needs you" pinned on top, the tickets as a stack of
- * stages (Blocked → Building → Reviewing → Done → Skipped) with step dots,
- * then the final review's 5 lenses as a second stack. It polls `board.read`.
+ * stages (Blocked → Building → Reviewing → Testing → Fixing → Joining → Done
+ * → Skipped) with step dots, then the final review's 5 lenses as a second
+ * stack. It polls `board.read`.
  */
 
 type StackStage = Exclude<TicketStage, 'stuck'>
@@ -78,17 +79,38 @@ const TICKET_STAGES: {
     {
         stage: 'building',
         title: 'Building',
-        hint: 'tests, red check, code, checks',
+        hint: 'the first tests and code',
         icon: 'Hammer',
         folded: false,
     },
     {
         stage: 'reviewing',
         title: 'Reviewing',
-        hint: 'a fresh ticket review and its fix rounds',
+        hint: 'a reviewer reads the ticket',
         icon: 'ScanSearch',
         folded: false,
     },
+    {
+        stage: 'testing',
+        title: 'Testing',
+        hint: 'the red check or the checks running',
+        icon: 'FlaskConical',
+        folded: false,
+    },
+    {
+        stage: 'fixing',
+        title: 'Fixing',
+        hint: 'a fix round after the checks, a review or a join',
+        icon: 'Wrench',
+        folded: false,
+    },
+    {
+        stage: 'joining',
+        title: 'Joining',
+        hint: 'joining the run branch and its checks there',
+        icon: 'GitMerge',
+        folded: false,
+    },
     {
         stage: 'done',
         title: 'Done',

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.13",
+    "version": "14.0.0-alpha.15",
     "private": true,
     "type": "module"
 }

package/board/server/luca-version.ts

@@ -1,2 +1,2 @@
 /** The Luca version of this board, stamped when the package was packed. */
-export const LUCA_VERSION: string = "14.0.0-alpha.13"
+export const LUCA_VERSION: string = "14.0.0-alpha.15"

package/board/server/make-rows.ts

@@ -394,6 +394,21 @@ export const describeRecord = ({
                       tone: 'info',
                   })
         case 'gates_run': {
+            const failed = record.content.checks
+                .filter((check) => !check.ok)
+                .map((check) => check.name)
+            // The final review's slow tests, after round 1's lenses (#563).
+            if (record.content.target === 'final_slow') {
+                return record.content.ok
+                    ? event({
+                          text: 'Final review: slow tests passed.',
+                          tone: 'success',
+                      })
+                    : event({
+                          text: `Final review: slow tests failed: ${failed.join(', ') || 'no detail'}.`,
+                          tone: 'danger',
+                      })
+            }
             const where =
                 record.ticket === null
                     ? ' on the fixes'
@@ -401,9 +416,6 @@ export const describeRecord = ({
                       ? ' after joining'
                       : ''
             const who = record.ticket === null ? 'Final review: ' : at
-            const failed = record.content.checks
-                .filter((check) => !check.ok)
-                .map((check) => check.name)
             return record.content.ok
                 ? event({
                       text: `${who}checks passed${where}.`,

package/board/server/reduce-board.ts

@@ -21,6 +21,7 @@ import {
     type RunInfo,
     type RunStatus,
     type TicketCard,
+    type TicketStage,
     type Usage,
 } from '../shared/board-state'
 import {
@@ -52,7 +53,8 @@ const STUCK_REASONS: Record<string, string> = {
     leftovers_found:
         'The leftover scan found files that must not be committed.',
     gates_failed: 'The checks failed.',
-    bad_test: 'The implementer sent back a bad test.',
+    bad_test:
+        'A test was sent back as bad, by the implementer or because it checks nothing.',
     changes_requested: 'The ticket review asked for changes.',
     join_failed: "The ticket couldn't join the run branch.",
     join_gates_failed: 'The checks failed after the ticket joined.',
@@ -436,6 +438,7 @@ const STEP_WORDS: Record<string, string> = {
     run_red_check: 'running the red check',
     run_gates: 'running the checks',
     run_final_gates: 'running the checks',
+    run_final_slow_tests: 'running the slow tests',
     join_run_branch: 'joining the run branch',
     push_run_branch: 'pushing the run branch',
     push_final_fixes: 'pushing the run branch',
@@ -494,9 +497,40 @@ const withoutSteps = ({ state }: { state: BoardState }): BoardState =>
         run_steps: [],
     })
 
+/** The stages a step doesn't move a ticket out of. */
+const SETTLED_STAGES = new Set<TicketStage>(['stuck', 'done', 'skipped'])
+
 /**
- * A step began: it is its ticket's current step, or one of the run's.
- * A new step on the same key (a crash's redo) replaces the one before it.
+ * The stage a ticket's step puts it in (#549): the red check and the checks
+ * are testing, but the checks after joining are still joining; joining and
+ * pushing the run branch are joining. Any other step, or a stuck, done or
+ * skipped ticket, keeps its stage.
+ */
+const stepStage = ({
+    card,
+    step,
+}: {
+    card: TicketCard
+    step: string
+}): TicketStage => {
+    if (SETTLED_STAGES.has(card.stage)) return card.stage
+    switch (step) {
+        case 'run_red_check':
+            return 'testing'
+        case 'run_gates':
+            return card.stage === 'joining' ? 'joining' : 'testing'
+        case 'join_run_branch':
+        case 'push_run_branch':
+            return 'joining'
+        default:
+            return card.stage
+    }
+}
+
+/**
+ * A step began: it is its ticket's current step, or one of the run's, and
+ * it sets the ticket's stage. A new step on the same key (a crash's redo)
+ * replaces the one before it.
  */
 const stepStarted = ({
     state,
@@ -506,7 +540,7 @@ const stepStarted = ({
     record: Extract<BoardRecord, { kind: 'step_started' }>
 }): BoardState => {
     // A replayed journal of an engine that ended has no step running.
-    if (state.run.engine_ended !== null) return state
+    const ended = state.run.engine_ended !== null
     const current_step = {
         text: stepText({ step: record.content.step }),
         since: record.time,
@@ -515,9 +549,14 @@ const stepStarted = ({
         return updateTicket({
             state,
             number: record.ticket,
-            update: (card) => ({ ...card, current_step }),
+            update: (card) => ({
+                ...card,
+                stage: stepStage({ card, step: record.content.step }),
+                current_step: ended ? card.current_step : current_step,
+            }),
         })
     }
+    if (ended) return state
     const { key } = record.content
     return withRunSteps({
         state,
@@ -1096,6 +1135,7 @@ const applyKind = ({
                 number: ticket,
                 update: (card) => ({
                     ...card,
+                    stage: 'building',
                     step: 0,
                     fix_round: 0,
                     open_check: null,
@@ -1177,11 +1217,13 @@ const applyKind = ({
             return updateTicket({
                 state,
                 number: ticket,
+                // Joined, it is done once its checks there pass and the run
+                // branch is pushed.
                 update: (card) =>
                     record.content.ok
                         ? {
                               ...card,
-                              stage: 'done',
+                              stage: 'joining',
                               step: ALL_STEPS_DONE,
                               role: null,
                               activity: 'joined',
@@ -1203,6 +1245,7 @@ const applyKind = ({
                 number: ticket,
                 update: (card) => ({
                     ...card,
+                    stage: 'fixing',
                     step: 0,
                     role: null,
                     activity: 'updating tests for the run branch',
@@ -1217,8 +1260,8 @@ const applyKind = ({
                 state,
                 number: ticket,
                 update: (card) =>
-                    card.stage === 'done'
-                        ? { ...card, activity: 'pushed' }
+                    card.stage === 'joining' || card.stage === 'done'
+                        ? { ...card, stage: 'done', activity: 'pushed' }
                         : card,
             })
         case 'ticket_stuck': {
@@ -1492,7 +1535,16 @@ const applyKind = ({
                     fix_round: record.content.round,
                     tried: withTried({
                         tried: review.tried,
-                        line: `Fix round ${record.content.round}/${LOOP_CAP} on the lenses' findings`,
+                        // Every lens finished clean: only failed slow tests
+                        // open a fix round then (#563).
+                        line: `Fix round ${record.content.round}/${LOOP_CAP} on ${
+                            review.lenses.length > 0 &&
+                            review.lenses.every(
+                                (lens) => lens.state === 'clean'
+                            )
+                                ? 'the failed slow tests'
+                                : "the lenses' findings"
+                        }`,
                     }),
                 }),
             })
@@ -1553,7 +1605,7 @@ const OPEN_CHECK_TEXT = {
 /**
  * A fixer's start in a review fix round. The round is the review's round (a
  * round follows each review that asked for changes); only the round's first
- * fixer adds its "tried" line. The card stays in Reviewing at its step.
+ * fixer adds its "tried" line. The card is fixing, at its step.
  */
 const reviewFixStarted = ({
     card,
@@ -1570,7 +1622,7 @@ const reviewFixStarted = ({
         ...card,
         started: true,
         role,
-        stage: 'reviewing',
+        stage: 'fixing',
         review_fix_round: round,
         activity: `fixing the review's findings (${round}/${LOOP_CAP})`,
         tried:
@@ -1613,15 +1665,19 @@ const agentStarted = ({
                       })
                     : card.tried
             const fixing = kind === 'fix' || kind === 'resent'
+            // A writer answering an open check, or fixing on top of the run
+            // branch, is fixing; its first pass is building.
+            const stage =
+                card.open_check !== null || card.stage === 'fixing'
+                    ? 'fixing'
+                    : 'building'
             if (role === 'test-writer') {
-                // During a ticket review (a retried review fixer) the card
-                // stays in Reviewing at its step.
-                const reviewing = card.stage === 'reviewing'
+                // A retried review fixer stays at its step.
                 return {
                     ...started,
                     tried,
-                    stage: reviewing ? 'reviewing' : 'building',
-                    step: reviewing ? card.step : 0,
+                    stage,
+                    step: card.open_check === 'review' ? card.step : 0,
                     activity: fixing
                         ? `fixing tests (${fix_round}/${LOOP_CAP})`
                         : kind === 'retry'
@@ -1633,8 +1689,7 @@ const agentStarted = ({
                 return {
                     ...started,
                     tried,
-                    stage:
-                        card.stage === 'reviewing' ? 'reviewing' : 'building',
+                    stage,
                     step: 2,
                     activity: fixing
                         ? `fixing (${fix_round}/${LOOP_CAP})`
@@ -1724,9 +1779,12 @@ const agentFinished = ({
                         }),
                     done.tried
                 )
+                // Approved, it joins the run branch next; else a review fix
+                // round follows.
                 return result.verdict === 'approve'
                     ? {
                           ...done,
+                          stage: 'joining',
                           step: ALL_STEPS_DONE,
                           findings,
                           open_check: null,
@@ -1735,6 +1793,7 @@ const agentFinished = ({
                       }
                     : {
                           ...done,
+                          stage: 'fixing',
                           findings,
                           open_check: 'review',
                           tried: ruled,
@@ -1759,6 +1818,15 @@ const gatesRun = ({
         .map((check) => check.name)
         .join(', ')
     const afterJoin = target === 'run_branch'
+    // The final review's slow tests, after round 1's lenses (#563).
+    if (target === 'final_slow') {
+        return ok
+            ? state
+            : finalTried({
+                  state,
+                  line: `The final review's slow tests failed: ${failed || 'no detail'}`,
+              })
+    }
     // The final review's fixes are checked on the run branch, with no ticket.
     if (record.ticket === null) {
         return ok
@@ -1828,9 +1896,9 @@ export const testsSentBackText = ({
 }
 
 /**
- * A ticket sent back onto the run branch builds again: its tests first if
- * test files clashed, else its code; then the checks and a fresh review,
- * whose fix rounds count from zero again.
+ * A ticket sent back onto the run branch is fixed on top of it: its tests
+ * first if test files clashed, else its code; then the checks and a fresh
+ * review, whose fix rounds count from zero again.
  */
 const ticketRebased = ({
     state,
@@ -1844,7 +1912,7 @@ const ticketRebased = ({
         number: record.ticket,
         update: (card) => ({
             ...card,
-            stage: 'building',
+            stage: 'fixing',
             step: record.content.tests.length > 0 ? 0 : 2,
             role: null,
             fix_round: 0,
@@ -2054,11 +2122,18 @@ export const unfinishedBlockers = ({
         return blocker !== undefined && blocker.stage !== 'done'
     })
 
+/** The stages of a ticket the engine is working on. */
+const ACTIVE_STAGES = new Set<TicketStage>([
+    'building',
+    'reviewing',
+    'testing',
+    'fixing',
+    'joining',
+])
+
 const isActive = ({ state }: { state: BoardState }): boolean =>
     state.tickets.some(
-        (ticket) =>
-            ticket.started &&
-            (ticket.stage === 'building' || ticket.stage === 'reviewing')
+        (ticket) => ticket.started && ACTIVE_STAGES.has(ticket.stage)
     ) ||
     state.final_review.state === 'reviewing' ||
     state.final_review.state === 'fixing'

package/board/shared/board-state.ts

@@ -177,10 +177,20 @@ export const RunPhaseSchema = z.enum([
 
 export type RunPhase = z.infer<typeof RunPhaseSchema>
 
+/**
+ * What a ticket is really doing (#549): `building` its first test-writer and
+ * implementer pass, `reviewing` only while a reviewer works, `testing` the red
+ * check or the checks, `fixing` any fix round, `joining` the run branch and
+ * the checks there. Every older stage is still one, so a stored board state
+ * from before still parses.
+ */
 export const TicketStageSchema = z.enum([
     'blocked',
     'building',
     'reviewing',
+    'testing',
+    'fixing',
+    'joining',
     'stuck',
     'done',
     'skipped',

package/engine/agents/role-instructions.ts

@@ -1,6 +1,13 @@
 import { lensOf, type AgentRole, type LensName } from './role-results'
 
-import { testCommands, type EngineConfig } from '../config/engine-config'
+import {
+    caseLimitOf,
+    featureMapPath,
+    slowTestCommands,
+    testCommands,
+    type EngineConfig,
+} from '../config/engine-config'
+import { MAX_TESTS_PER_CRITERION } from '../core/loop-caps'
 import {
     checkCommands,
     guardRoleOf,
@@ -74,6 +81,20 @@ Sometimes other tickets joined the run branch after this ticket's tests were wri
 - Every criterion still needs a test. Your updated tests may pass now, since the code is there; that is fine. The engine runs every test in the gates after the implementer's turn.
 - Answer "tests_written" with the full criterion mapping again.`
 
+/** The test-writer's lines about the feature map (#583), or nothing without one. */
+const featureMapLines = ({ config }: { config: EngineConfig }): string => {
+    const path = featureMapPath({ config })
+    return path === null
+        ? ''
+        : `- Read ${path} first: it lists each feature and the test files that prove it.\n- Put new tests in a feature's existing test files when you can. A new test file must be listed under its feature in ${path}; you may edit that file.\n`
+}
+
+/** What the test-writer's "ONLY test files" line adds for the feature map, or nothing. */
+const featureMapClause = ({ config }: { config: EngineConfig }): string => {
+    const path = featureMapPath({ config })
+    return path === null ? '' : ` and the feature map ${path}`
+}
+
 const TEST_WRITER = ({
     config,
 }: {
@@ -82,10 +103,11 @@ const TEST_WRITER = ({
 
 You write the failing tests for ONE ticket, before any code exists.
 
-- Create or edit ONLY test files (${config.test_file_patterns.join(', ')}). No other file: no implementation, no package.json, no config, no notes, and not the test setup files.
+- Create or edit ONLY test files (${config.test_file_patterns.join(', ')})${featureMapClause({ config })}. No other file: no implementation, no package.json, no config, no notes, and not the test setup files.
 - Your new tests must FAIL right now, because the code does not exist yet. That is expected. Do not create or stub the module under test.
 - Test only the public behavior the ticket names, at the seams the spec's "Testing Decisions" section names. No mocks unless the spec asks. No tautological asserts.
-- Every acceptance criterion needs at least one test. Old tests must keep passing.
+${featureMapLines({ config })}- Every acceptance criterion needs at least one test, and at most ${MAX_TESTS_PER_CRITERION}: write the fewest tests that prove it. Old tests must keep passing.
+- Map every test you add. The red check refuses a new test your criterion mapping doesn't name.
 - Give every test a plain string-literal name (no test.each, no template names), so the engine can find each one before the module exists.
 
 Your result (structured output):
@@ -111,6 +133,25 @@ const testFileRule = ({
         ? `- You may follow renames and moves into test files (${config.test_file_patterns.join(', ')}), but never change what a test checks. Never touch a test setup file${setupFiles({ config })}.`
         : `- Never create, edit, or delete a test file (${config.test_file_patterns.join(', ')}) or a test setup file${setupFiles({ config })}.`
 
+/** The implementer's line about the slow tests (#563), or nothing without them. */
+const slowLine = ({ config }: { config: EngineConfig }): string => {
+    const slow = slowTestCommands({ config }).map(({ run }) => `\`${run}\``)
+    return slow.length === 0
+        ? ''
+        : ` The slow tests (${slow.join(', ')}) run at the final review, and the ticket's gates also run the slow test files it added or changed; you may run them yourself.`
+}
+
+/**
+ * The implementer's line about the fast test limit (#580), or nothing without
+ * one.
+ */
+const limitLine = ({ config }: { config: EngineConfig }): string => {
+    const limit = caseLimitOf({ config })
+    return limit === null
+        ? ''
+        : `- Each fast test must finish within ${limit} ms. If one of the ticket's tests can't, answer "bad_test".\n`
+}
+
 const IMPLEMENTER = ({
     config,
     may_edit_tests,
@@ -128,8 +169,8 @@ You write the code that makes ONE ticket's failing tests pass. Another agent wro
 ]
     .filter((command) => command !== undefined)
     .map((command) => `\`${command}\``)
-    .join(', ')}.
-${testFileRule({ config, may_edit_tests })}
+    .join(', ')}.${slowLine({ config })}
+${limitLine({ config })}${testFileRule({ config, may_edit_tests })}
 - If a test is wrong (it contradicts the ticket or spec, or no correct code can pass it), don't work around it: answer outcome "bad_test" with the test and your reason.
 - If the gates can't pass without a change to a test setup file${setupFiles({ config })}, don't work around it: answer outcome "needs_setup_change", with the file and why in "setup_change". The user makes the change.
 - Follow the spec's Implementation Decisions. Keep the change small: no extra features, and no new dependencies unless the spec says so.

package/engine/agents/role-prompts.ts

@@ -1,4 +1,4 @@
-import type { AgentRole, BadTest, Finding } from './role-results'
+import type { AgentRole, BadTest, BadTestSource, Finding } from './role-results'
 
 import type { SpecSnapshot, TicketSnapshot } from '../intake/intake-schemas'
 import type { RejoinCause } from '../journal/journal-record'
@@ -137,11 +137,21 @@ const REFACTOR_TASK =
     'Make every gate pass. You may follow renames and moves into test files, but you must not change what a test checks. ' +
     'If a test is wrong, answer "bad_test" with your reason.'
 
-/** What a fresh test-writer is told when it replaces a bad test. */
-const badTestSection = ({ bad_test }: { bad_test: BadTest }): string =>
+/**
+ * What a fresh test-writer is told when it replaces a bad test: the
+ * implementer sent it back, or the engine found it passes with no
+ * `expect()`, so it checks nothing (#581).
+ */
+const badTestSection = ({
+    bad_test,
+    by,
+}: {
+    bad_test: BadTest
+    by: BadTestSource
+}): string =>
     [
         '## A test was sent back as a bad test',
-        `The implementer says this test is wrong:\n\n- File: ${bad_test.file}\n- Test: ${bad_test.name}\n- Reason: ${bad_test.reason}`,
+        `${by === 'engine' ? 'The engine found this test checks nothing' : 'The implementer says this test is wrong'}:\n\n- File: ${bad_test.file}\n- Test: ${bad_test.name}\n- Reason: ${bad_test.reason}`,
         'Fix or replace it so it checks what its criterion asks. Keep the other tests unless they are wrong too. ' +
             'Answer with the full criterion mapping again: every criterion, the kept tests included.',
     ].join('\n\n')
@@ -190,6 +200,26 @@ export const prepareSection = ({ command }: { command: string }): string =>
             "If the engine's prepare command fails after your turn, its output comes back to you like a failed check.",
     ].join('\n\n')
 
+/**
+ * The section a test-writer gets when the repo has a feature map (#583): the
+ * one file besides test files it may edit. It comes after the task's "Edit
+ * test files only", so it reads as that line's exception.
+ *
+ * @param path - The map's path, as `featureMapPath` gives it.
+ *
+ * @example
+ * featureMapSection({ path: 'docs/feature-map.md' })
+ * // '## The feature map\n\nBesides test files, you may edit the feature map, `docs/feature-map.md`. ...'
+ */
+export const featureMapSection = ({ path }: { path: string }): string =>
+    [
+        '## The feature map',
+        `Besides test files, you may edit the feature map, \`${path}\`. ` +
+            'Read it first: it lists each feature and the test files that prove it. ' +
+            "Put new tests in a feature's existing test files when you can; " +
+            'a new test file must be listed under its feature in the map.',
+    ].join('\n\n')
+
 /**
  * The section a test-writer or implementer (a ticket's or the final
  * review's fixers) gets in a repo with changesets: the engine writes the
@@ -203,8 +233,9 @@ export const CHANGESETS_SECTION = [
 ].join('\n\n')
 
 /**
- * The section the rules lens gets in a repo with changesets, so a rule like
- * "every PR needs a changeset" raises no finding.
+ * The section every reviewer (the ticket-reviewer and each lens) gets in a
+ * repo with changesets, so a rule like "every PR needs a changeset" raises
+ * no finding.
  */
 export const CHANGESETS_LENS_SECTION = [
     '## The engine writes the changeset',
@@ -218,8 +249,8 @@ const LENS_TASK_TEXT =
 
 const ROLE_TASKS: Record<AgentRole, string> = {
     'test-writer':
-        'Write failing tests for every acceptance criterion below. Edit test files only. ' +
-        'Map each criterion id to the tests that check it.',
+        'Write failing tests for every acceptance criterion below: the fewest that prove each one. Edit test files only. ' +
+        'Map every test you add to the criterion it checks.',
     implementer:
         'Make every gate pass. Never edit a test file. ' +
         'If a test is wrong, answer "bad_test" with your reason. ' +
@@ -258,7 +289,10 @@ export const roleTask = ({ role }: { role: AgentRole }): string =>
  * @param refactor - The ticket is a refactor ticket: the implementer gets
  *   the refactor task (no new behavior; it may follow renames into tests).
  * @param bad_test - For a fresh test-writer after a bad-test bounce: the
- *   test the implementer sent back, and why.
+ *   test the implementer sent back, or the engine found checks nothing
+ *   (#581), and why.
+ * @param bad_test_by - Who sent `bad_test` back: the implementer (the
+ *   default) or the engine.
  * @param sections - More sections for the end, such as a reviewer's diff
  *   and gate results, or a review fixer's findings.
  * @param run_notes - Notes earlier agents in the run left, oldest first,
@@ -273,6 +307,7 @@ export const rolePrompt = ({
     ticket,
     refactor,
     bad_test,
+    bad_test_by,
     sections,
     run_notes,
 }: {
@@ -281,6 +316,7 @@ export const rolePrompt = ({
     ticket: TicketSnapshot
     refactor?: boolean
     bad_test?: BadTest | null
+    bad_test_by?: BadTestSource
     sections?: string[]
     run_notes?: PromptRunNote[]
 }): string =>
@@ -302,7 +338,7 @@ export const rolePrompt = ({
         '## Acceptance criteria',
         ticket.criteria.map(({ id, text }) => `- ${id}: ${text}`).join('\n'),
         ...(role === 'test-writer' && bad_test
-            ? [badTestSection({ bad_test })]
+            ? [badTestSection({ bad_test, by: bad_test_by ?? 'implementer' })]
             : []),
         ...(sections ?? []),
         // Recalled memories (#370) are added after these by the decision step.

package/engine/agents/role-results.ts

@@ -175,6 +175,12 @@ export const BadTestSchema = z.object({
 
 export type BadTest = z.infer<typeof BadTestSchema>
 
+/**
+ * Who sent a test back as bad: the implementer, who says it is wrong, or the
+ * engine, which found a mapped test that passes with no `expect()` (#581).
+ */
+export type BadTestSource = 'implementer' | 'engine'
+
 /**
  * The implementer's result. `bad_test` sends a wrong test back;
  * `needs_setup_change` says the gates can't pass without a change to a test

package/engine/cli/run-modes.ts

@@ -218,8 +218,11 @@ const driveRun = async ({
 }
 
 /** A value of a reloaded config field in a log line; `null` is "none". */
-const fieldValue = (value: string | number | null): string =>
-    value === null ? 'none' : String(value)
+const fieldValue = (value: string | number | string[] | null): string => {
+    if (value === null) return 'none'
+    if (Array.isArray(value)) return `[${value.join(', ')}]`
+    return String(value)
+}
 
 /**
  * The log line for a resume's `config_reloaded` or `config_reload_refused`