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

package/CHANGELOG.md

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

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.14",
+    "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.14"
+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

@@ -53,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.',
@@ -437,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',
@@ -1533,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"
+                        }`,
                     }),
                 }),
             })
@@ -1807,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

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
@@ -219,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. ' +
@@ -259,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,
@@ -274,6 +307,7 @@ export const rolePrompt = ({
     ticket,
     refactor,
     bad_test,
+    bad_test_by,
     sections,
     run_notes,
 }: {
@@ -282,6 +316,7 @@ export const rolePrompt = ({
     ticket: TicketSnapshot
     refactor?: boolean
     bad_test?: BadTest | null
+    bad_test_by?: BadTestSource
     sections?: string[]
     run_notes?: PromptRunNote[]
 }): string =>
@@ -303,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/config/config-reload.ts

@@ -20,6 +20,8 @@ import type { EngineConfig } from './engine-config'
  *   one counts from the next prepare run.
  * - `test_timeout_ms`: how long each test command may run (#542). Each run
  *   of a test command reads it then, so a new one counts from the next.
+ * - `test_case_timeout_ms`: how long one fast test may take (#580). Each run
+ *   of a fast test command reads it then, so a new one counts from the next.
  * - `leftover_allow`: more new markdown the leftover scan lets through
  *   (#520). Each scan reads it then, so a run stuck on a leftover can be
  *   unstuck by allowing the file and resuming.
@@ -29,6 +31,7 @@ export const RELOADED_FIELDS = [
     'prepare_timeout_ms',
     'prepare_concurrency',
     'test_timeout_ms',
+    'test_case_timeout_ms',
     'leftover_allow',
 ] as const
 
@@ -47,6 +50,10 @@ export const RELOADED_FIELDS = [
  * - `test_file_patterns`: which files are tests decides the red check, the
  *   role rules, and which commits were the test-writer's.
  * - `test_setup_files`: part of what the tests are, as `checks` is.
+ * - `feature_map`: says which test files belong to which feature (#583), as
+ *   `test_file_patterns` says which files are tests: the red check holds a
+ *   ticket's new test files to it, and the role rules let the test-writer
+ *   edit it.
  * - `rule_files`: the rules lens judges against them; tickets already
  *   reviewed were judged on the old ones.
  * - `muninn`: the run's memory vault is fixed at start (`run_started.memory`).
@@ -59,6 +66,7 @@ export const FROZEN_FIELDS = [
     'checks',
     'test_file_patterns',
     'test_setup_files',
+    'feature_map',
     'rule_files',
     'muninn',
     'run_budget_tokens',
@@ -94,6 +102,11 @@ export const ConfigChangeSchema = z.discriminatedUnion('field', [
         from: positiveInt,
         to: positiveInt,
     }),
+    z.object({
+        field: z.literal('test_case_timeout_ms'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
     z.object({
         field: z.literal('leftover_allow'),
         from: patterns,
@@ -140,6 +153,11 @@ export const configChanges = ({
             from: current.test_timeout_ms ?? null,
             to: next.test_timeout_ms ?? null,
         },
+        {
+            field: 'test_case_timeout_ms',
+            from: current.test_case_timeout_ms ?? null,
+            to: next.test_case_timeout_ms ?? null,
+        },
         {
             field: 'leftover_allow',
             from: current.leftover_allow ?? null,
@@ -173,6 +191,10 @@ const applyChange = ({
             return change.to === null
                 ? omit(config, 'test_timeout_ms')
                 : { ...config, test_timeout_ms: change.to }
+        case 'test_case_timeout_ms':
+            return change.to === null
+                ? omit(config, 'test_case_timeout_ms')
+                : { ...config, test_case_timeout_ms: change.to }
         case 'leftover_allow':
             return change.to === null
                 ? omit(config, 'leftover_allow')

package/engine/config/engine-config.ts

@@ -1,4 +1,4 @@
-import { join } from 'node:path'
+import { isAbsolute, join, normalize } from 'node:path'
 
 import { z } from 'zod'
 
@@ -34,6 +34,12 @@ const TestCommandEntrySchema = z.union([
     }),
 ])
 
+/** A test command setting: one command, or a list of them (see `testCommands`). */
+const TestCommandsSchema = z.union([
+    z.string().min(1),
+    z.array(TestCommandEntrySchema),
+])
+
 /** The config's `muninn` block. */
 export const MuninnConfigSchema = z.object({
     /** The project's memory vault. */
@@ -49,6 +55,22 @@ export const DecisionModelConfigSchema = z.object({
     model: DecisionModelIdSchema.default(DEFAULT_DECISION_MODEL),
 })
 
+/**
+ * Whether a config path names a file inside the repo (#583): not absolute,
+ * not ending in `/` (a folder), and, once cleaned (`normalize`), neither the
+ * repo root nor a path that climbs out of it with `..`.
+ */
+const isFileInsideRepo = (path: string): boolean => {
+    const clean = normalize(path)
+    return (
+        !isAbsolute(path) &&
+        !path.endsWith('/') &&
+        clean !== '.' &&
+        clean !== '..' &&
+        !clean.startsWith('../')
+    )
+}
+
 /**
  * The per-repo engine config: the gate commands, where tests live, the rule
  * files for the rules lens, the project's memory vault, the decision model,
@@ -59,14 +81,19 @@ export const DecisionModelConfigSchema = z.object({
  * The test command is optional here on purpose. A config without it still
  * loads, and intake refuses the run with a clear message instead.
  * `checks.test` is one command or a list of them (see `testCommands`); it is
- * kept as written.
+ * kept as written. `checks.slow_test` has the same shape (see
+ * `slowTestCommands`, #563).
  */
 export const EngineConfigSchema = z.object({
     checks: z
         .object({
-            test: z
-                .union([z.string().min(1), z.array(TestCommandEntrySchema)])
-                .optional(),
+            test: TestCommandsSchema.optional(),
+            /**
+             * The slow tests (#563): the tests `test` leaves out, run only at
+             * the final review. Same shape as `test`. Left out, nothing
+             * changes.
+             */
+            slow_test: TestCommandsSchema.optional(),
             types: z.string().min(1).optional(),
             lint: z.string().min(1).optional(),
         })
@@ -92,12 +119,33 @@ export const EngineConfigSchema = z.object({
      * engine's default (`DEFAULT_COMMAND_TIMEOUT_MS`, 5 minutes).
      */
     test_timeout_ms: z.number().int().positive().optional(),
+    /**
+     * How long one fast test may take, in milliseconds (#580): passed to every
+     * `bun` command of `checks.test` as `--timeout`, and checked on a ticket's
+     * own test files by their measured time. Left out, no limit.
+     */
+    test_case_timeout_ms: z.number().int().positive().optional(),
     /**
      * Glob patterns for more new markdown the leftover scan lets through,
      * beyond doc folders, READMEs, and files the repo names (#520), such as
      * `design/*.md`; left out, none.
      */
     leftover_allow: z.array(z.string().min(1)).optional(),
+    /**
+     * A markdown file listing each feature and the test files that prove it
+     * (#583), relative to the repo root: a file inside the repo, so not an
+     * absolute path, not one that climbs out with `..`, and not a folder (no
+     * trailing `/`). The red check refuses a new test file it doesn't list,
+     * and the test-writer may edit it. Left out, no map.
+     */
+    feature_map: z
+        .string()
+        .min(1)
+        .refine(isFileInsideRepo, {
+            message:
+                'must be a file inside the repo, relative to its root: not an absolute path, not one that leaves the repo with "..", and not a folder',
+        })
+        .optional(),
     test_file_patterns: z.array(z.string()).default(['**/*.test.ts']),
     test_setup_files: z.array(z.string()).default([]),
     rule_files: z.array(z.string()).default([]),
@@ -191,6 +239,19 @@ export const isBunTestCommand = (run: string): boolean =>
 const defaultResults = (run: string): TestResults =>
     isBunTestCommand(run) ? 'bun' : 'pass_fail'
 
+/** Reads a test command setting (`checks.test` or `checks.slow_test`) into commands. */
+const commandsOf = (value: EngineConfig['checks']['test']): TestCommand[] => {
+    if (value === undefined) return []
+    return (typeof value === 'string' ? [value] : value).map((entry) =>
+        typeof entry === 'string'
+            ? { run: entry, results: defaultResults(entry) }
+            : {
+                  run: entry.run,
+                  results: entry.results ?? defaultResults(entry.run),
+              }
+    )
+}
+
 /**
  * Every test command in the config, in order, each with its results kind.
  * A missing `results` is `bun` for a `bun test` command, else `pass_fail`.
@@ -204,20 +265,76 @@ export const testCommands = ({
     config,
 }: {
     config: EngineConfig
-}): TestCommand[] => {
-    const { test } = config.checks
-    if (test === undefined) return []
-    return (typeof test === 'string' ? [test] : test).map((entry) =>
-        typeof entry === 'string'
-            ? { run: entry, results: defaultResults(entry) }
-            : {
-                  run: entry.run,
-                  results: entry.results ?? defaultResults(entry.run),
-              }
-    )
+}): TestCommand[] => commandsOf(config.checks.test)
+
+/**
+ * Every slow test command (#563), in order, each with its results kind, like
+ * `testCommands`. Empty when the config has none.
+ *
+ * @example
+ * slowTestCommands({ config: { ...config, checks: { test: 'bun test src', slow_test: 'bun test .e2e.test' } } })
+ * // [{ run: 'bun test .e2e.test', results: 'bun' }]
+ */
+export const slowTestCommands = ({
+    config,
+}: {
+    config: EngineConfig
+}): TestCommand[] => commandsOf(config.checks.slow_test)
+
+/** Whether the config has a slow test command (#563). */
+export const hasSlowTests = ({ config }: { config: EngineConfig }): boolean =>
+    slowTestCommands({ config }).length > 0
+
+/** The fast test speed limit (#580), or `null` with none. */
+export const caseLimitOf = ({
+    config,
+}: {
+    config: EngineConfig
+}): number | null => config.test_case_timeout_ms ?? null
+
+/**
+ * The feature map's path (#583), in the form a worktree-relative path takes
+ * everywhere else (`normalize`, no leading `./`), or `null` with no map.
+ * `./docs/feature-map.md` and `docs//feature-map.md` are both
+ * `docs/feature-map.md`. The role rules, the permission rules, the prompts,
+ * and the red check all read the map's path here, so they agree on it
+ * whatever way the config spells it.
+ *
+ * @example
+ * featureMapPath({ config: { ...config, feature_map: './docs/feature-map.md' } }) // 'docs/feature-map.md'
+ */
+export const featureMapPath = ({
+    config,
+}: {
+    config: EngineConfig
+}): string | null =>
+    config.feature_map === undefined
+        ? null
+        : normalize(config.feature_map).replace(/^\.\//, '')
+
+/**
+ * A fast `bun` test command with the speed limit (#580): `--timeout=<n>` at
+ * its end, or the command as written with no limit.
+ *
+ * @example
+ * fastBunCommand({ run: 'bun test src', config: { ...config, test_case_timeout_ms: 2000 } }) // 'bun test src --timeout=2000'
+ */
+export const fastBunCommand = ({
+    run,
+    config,
+}: {
+    run: string
+    config: EngineConfig
+}): string => {
+    const limit = caseLimitOf({ config })
+    return limit === null ? run : `${run} --timeout=${limit}`
 }
 
-/** The test commands whose per-test results the engine reads. */
+/**
+ * The test commands whose per-test results the engine reads, each with the
+ * fast test speed limit (#580) when the config has one. Used by the baseline,
+ * the red check and the already-done check; `testCommands` stays as written.
+ */
 export const bunTestCommands = ({
     config,
 }: {
@@ -225,7 +342,7 @@ export const bunTestCommands = ({
 }): string[] =>
     testCommands({ config })
         .filter(({ results }) => results === 'bun')
-        .map(({ run }) => run)
+        .map(({ run }) => fastBunCommand({ run, config }))
 
 export type LoadEngineConfigResult =
     | { ok: true; config: EngineConfig }