@alecsibilia/luca 14.0.0-alpha.25 → 14.0.0-alpha.27

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.27
+
+No changes in this release.
+
+## 14.0.0-alpha.26
+
+### Patch Changes
+
+- 075d3a4: Spec: /luca-spec-check, a cold read of a spec by three fresh readers before ready-for-agent ([#678](https://github.com/asibilia/luca-framework/issues/678))
+
 ## 14.0.0-alpha.25
 
 No changes in this release.

package/README.md

@@ -35,7 +35,7 @@ This is Luca v14, in alpha. Old Luca (v13) is still on npm; see [Coming from v13
 3. Check what `luca setup` wrote to `.luca/config.json`. It names your repo's GitHub name (like `tmnb`) as its memory vault in `muninn.vault`; change it if you want another.
 
 4. In Claude Code, in your repo, run `/setup-matt-pocock-skills` so the planning skills know your repo.
-5. Write a spec with `/to-spec`, then split it into tickets with `/to-tickets`.
+5. Write a spec with `/to-spec`, then split it into tickets with `/to-tickets`. Before you add `ready-for-agent`, type `/luca-spec-check <spec number>` in Claude Code: three fresh readers give the spec a cold read and list what an agent would have to guess.
 6. In a Paseo chat, type `/luca-run <spec number>`. The board shows the run in the side panel, and the run ends in one pull request.
 
 If a ticket gets stuck, Luca comments on the spec and waits for your one-word reply. Type `/luca-unstick` in Claude Code or a Paseo chat, in the repo: it reads why, says what to do, and posts the reply once you say yes.
@@ -46,7 +46,7 @@ After a run, type `/luca-retro` the same way to look back on it: it reads the ru
 
 | Command | What it does |
 | ------- | ------------ |
-| `luca init` | Sets up this computer, once (safe to run again): MuninnDB and its Claude Code entry, the board in Paseo with its engine and Bun paths, the planning skills (`to-spec`, `to-tickets`, `setup-matt-pocock-skills`, `grilling`, `domain-modeling`), and Luca's own `/luca-unstick` and `/luca-retro` skills. It asks before turning on Paseo's plugins, and leaves skills you already have alone (it only replaces its own two). `--skip-skills` skips the planning skills. Inside a git repo, it then runs `luca setup` for that repo. |
+| `luca init` | Sets up this computer, once (safe to run again): MuninnDB and its Claude Code entry, the board in Paseo with its engine and Bun paths, the planning skills (`to-spec`, `to-tickets`, `setup-matt-pocock-skills`, `grilling`, `domain-modeling`), and Luca's own `/luca-unstick`, `/luca-retro` and `/luca-spec-check` skills. It asks before turning on Paseo's plugins, and leaves skills you already have alone (it only replaces its own). `--skip-skills` skips the planning skills. Inside a git repo, it then runs `luca setup` for that repo. |
 | `luca setup` | Gets the repo in this folder ready: the labels a run needs (and the `release:*` labels when the repo uses changesets), `.luca/config.json` (a new one gets the repo's GitHub name as its vault; an existing vault is kept), and a check of GitHub sub-issues and dependencies. `--base <branch>` names the base branch. |
 | `luca doctor` | Checks this computer, this repo when you're in one, and what v13 left behind. Each problem comes with its exact fix. `luca doctor --fix` fixes what's safe without asking: it never deletes (v13 files go to a dated backup folder) and never commits, and it lists the repo files to commit. |
 | `luca upgrade` | Moves to the newest Luca on your channel: `alpha` stays on `alpha`, and it never goes back to v13. It refuses while any run is going (stuck runs and limit waits count) and lists them. A run that crashed, with no engine running it, doesn't stop it: upgrade says how to resume it on the new version. Then the version it just installed finishes the job with its own code: it reloads the board, copies its skills (every one it ships, new ones included), and says when to run `/reload-skills`. |
@@ -92,7 +92,7 @@ This is the one package that goes to npm. It's TypeScript source with no build a
 | ------ | ---------- |
 | `engine/` | The engine's source, from [`packages/engine/src`](../engine/src). Both bins point into it. |
 | `board/` | The board plugin's folder, from [`packages/board`](../board): `paseo-plugin.json`, its entry points, its client, server, and shared code, and its own `package.json`, so Paseo can install it as a folder source. |
-| `skills/` | Luca's own Claude Code skills, `luca-unstick` and `luca-retro`, from [`packages/engine/skills`](../engine/skills). `luca init` and `luca upgrade` copy every folder in it with a `SKILL.md` to `~/.claude/skills`. |
+| `skills/` | Luca's own Claude Code skills, `luca-unstick`, `luca-retro` and `luca-spec-check`, from [`packages/engine/skills`](../engine/skills). `luca init` and `luca upgrade` copy every folder in it with a `SKILL.md` to `~/.claude/skills`. |
 | `LICENSE` | The repo's license. |
 
 Test files and test helpers stay out. The engine and the board stay private workspace packages, and this package lists every package they import at runtime as its own dependency.

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.25",
+    "version": "14.0.0-alpha.27",
     "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.25"
+export const LUCA_VERSION: string = "14.0.0-alpha.27"

package/engine/agents/agent-launcher.ts

@@ -103,7 +103,9 @@ export type LauncherFailure = z.infer<typeof LauncherFailureSchema>
  * of the model session, for the journal. `session_gone` marks a follow-up
  * that found its session closed or unknown (#521): no agent ran, and the
  * engine hands the follow-up's message to a fresh agent. `out_of_turns`
- * marks a turn that reached its role's turn limit (#543).
+ * marks a turn that reached its role's turn limit (#543). `session_closed`
+ * marks a turn interrupted for running past its time limit (#685): the
+ * launcher closed its session, so no follow-up can reach it.
  */
 export type AgentTurn =
     | {
@@ -120,6 +122,7 @@ export type AgentTurn =
           session?: AgentSession
           session_gone?: boolean
           out_of_turns?: boolean
+          session_closed?: boolean
       }
 
 /**
@@ -178,6 +181,12 @@ export type AgentLauncher = {
          * session's follow-ups run at it too.
          */
         effort: EffortLevel
+        /**
+         * The turn limit for this launch (#684), in place of its role's: a
+         * lens whose last try ran out of turns gets twice its role's. Left
+         * out, the role's limit.
+         */
+        max_turns?: number
         /**
          * Hears the turn's live progress (#628) each time it changes, before
          * the turn ends, for the engine's live file. Left out, nothing hears it.

package/engine/agents/claude-messages.ts

@@ -105,6 +105,8 @@ export type Failed = {
     error: string
     /** The turn reached its role's turn limit (#543). */
     out_of_turns?: boolean
+    /** The turn ran past its time limit, and its session was closed (#685). */
+    session_closed?: boolean
 }
 
 export type Outcome = { ok: true; structured_output: unknown } | Failed

package/engine/agents/claude-options.ts

@@ -16,6 +16,7 @@ import {
     TicketReviewResultSchema,
     type AgentRole,
 } from './role-results'
+import { MAX_TURNS } from './role-turns'
 
 import {
     DEFAULT_MODEL,
@@ -27,29 +28,14 @@ import { HELPER_TYPE, SEARCHER } from '../guards/helper-rules'
 import { guardRoleOf, permissionRules } from '../guards/role-rules'
 import { sandboxSettings } from '../guards/sandbox-settings'
 
+export { MAX_TURNS } from './role-turns'
+
 /** The models an agent may launch on, by short name (`ModelNameSchema`). */
 export const MODEL_NAMES = ModelNameSchema.options
 
 /** The model reviewers run on, and every agent the decision model doesn't route (#603). */
 export const CLAUDE_MODEL = DEFAULT_MODEL
 
-/**
- * How many model turns one agent gets before its try ends. The integration
- * lens reads how every ticket fits together on the whole branch, so it gets
- * more than the other lenses.
- */
-export const MAX_TURNS: Record<AgentRole, number> = {
-    'test-writer': 80,
-    implementer: 150,
-    'ticket-reviewer': 60,
-    'architecture-lens': 60,
-    'simplification-lens': 60,
-    'security-lens': 60,
-    'integration-lens': 100,
-    'rules-lens': 60,
-    learner: 40,
-}
-
 /**
  * Why a model may not launch an agent, or `null` if it may: exactly one of
  * `MODEL_NAMES`. Every other short name is refused, since some (such as
@@ -181,6 +167,7 @@ export const agentOptions = ({
     cwd,
     model,
     effort,
+    max_turns,
     claude_path,
     config,
     common_git_dir,
@@ -199,6 +186,8 @@ export const agentOptions = ({
     cwd: string
     model: string
     effort: EffortLevel
+    /** The launch's own turn limit (#684), in place of the role's; left out, the role's. */
+    max_turns?: number
     /** The real path of the installed `claude` binary. */
     claude_path: string
     config: EngineConfig
@@ -264,7 +253,7 @@ export const agentOptions = ({
         // Streamed chunks only feed the live file's heartbeat (#631); the
         // launcher keeps nothing of them.
         includePartialMessages: true,
-        maxTurns: MAX_TURNS[role],
+        maxTurns: max_turns ?? MAX_TURNS[role],
         hooks: {
             PreToolUse: [{ hooks: [guard_hook] }],
             ...(delivery_hook === null

package/engine/agents/launch-session.ts

@@ -80,6 +80,7 @@ export const createLaunch = ({
         messaging,
         model,
         effort,
+        max_turns,
         on_progress,
     }) => {
         const refused = checkLaunchModel({ model })
@@ -117,6 +118,7 @@ export const createLaunch = ({
             model,
             // Kept in the session's options, so its follow-ups run at it too.
             effort,
+            max_turns,
             claude_path: claudePath,
             config,
             common_git_dir: gitDir,

package/engine/agents/refactor-update-prompts.ts

@@ -0,0 +1,62 @@
+/**
+ * The texts of a refactor test update (#686): the section a fresh
+ * test-writer gets in place of the rejoin's test update section, the
+ * follow-up the implementer gets once it answered, and what the
+ * ticket-reviewer is told once it closed.
+ */
+
+/**
+ * The section a test-writer gets when a refactor ticket's implementer sent
+ * a test back as bad: why, and that it may change only that file.
+ *
+ * @example
+ * refactorUpdateSection({ file: 'src/rows.test.ts', reason: 'It pins the old order.' })
+ */
+export const refactorUpdateSection = ({
+    file,
+    reason,
+}: {
+    file: string
+    reason: string
+}): string =>
+    [
+        "## A refactor ticket's test was sent back as bad",
+        `The implementer says this test is wrong:\n\n- File: ${file}\n- Reason: ${reason || 'no reason given'}`,
+        `This is a refactor ticket. Change only ${file}, and only so it checks what the ticket's criteria say.`,
+        "The implementer's work is already in the worktree, so the test may pass now. That is fine here.",
+    ].join('\n\n')
+
+/**
+ * The follow-up a refactor ticket's implementer gets once the test-writer
+ * fixed the test it sent back.
+ *
+ * @example
+ * refactorTestFixedMessage({ file: 'src/rows.test.ts' })
+ */
+export const refactorTestFixedMessage = ({ file }: { file: string }): string =>
+    `The test-writer changed ${file} so it checks what the ticket's criteria say. Carry on with the refactor. You may follow renames into test files, but don't change what a test checks.`
+
+/**
+ * The section a refactor ticket's reviewer gets once a refactor test update
+ * fixed a test: which file, why, and that only that change to what a test
+ * checks is expected.
+ *
+ * @example
+ * refactorFixedReviewSection({ fixed: [{ file: 'src/rows.test.ts', reason: 'It pins the old order.' }] })
+ */
+export const refactorFixedReviewSection = ({
+    fixed,
+}: {
+    fixed: { file: string; reason: string }[]
+}): string =>
+    [
+        '## Tests a test-writer changed on purpose',
+        "The implementer sent these tests back as bad, and a test-writer changed them so they check what the ticket's criteria say. The engine checked it changed no other test file.",
+        fixed
+            .map(
+                ({ file, reason }) =>
+                    `- File: ${file}\n  Reason: ${reason || 'no reason given'}`
+            )
+            .join('\n'),
+        "This change to what these tests check is expected: judge it against the ticket's criteria, not as a behavior change. Any other change to what a test checks is still a blocker.",
+    ].join('\n\n')

package/engine/agents/role-turns.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure: how many model turns each role gets, whatever launcher runs it. A
+ * launch's own `max_turns` (#684) replaces its role's.
+ */
+import type { AgentRole } from './role-results'
+
+/**
+ * How many model turns one agent gets before its try ends. The integration
+ * lens reads how every ticket fits together on the whole branch, and the
+ * rules lens reads every rule file against it (#684), so they get more than
+ * the other lenses.
+ */
+export const MAX_TURNS: Record<AgentRole, number> = {
+    'test-writer': 80,
+    implementer: 150,
+    'ticket-reviewer': 60,
+    'architecture-lens': 60,
+    'simplification-lens': 60,
+    'security-lens': 60,
+    'integration-lens': 100,
+    'rules-lens': 100,
+    learner: 40,
+}

package/engine/agents/scripted-launcher.ts

@@ -78,6 +78,8 @@ export type ScriptedCall = {
      * `null` for a session the launcher doesn't know.
      */
     effort: EffortLevel | null
+    /** The turn limit a launch asked for (#684); left out when it asked for none. */
+    max_turns?: number
     /** What each of the turn's tool calls handed over, in order. */
     delivered: string[]
 }
@@ -204,6 +206,7 @@ export const createScriptedLauncher = ({
             messaging,
             model,
             effort,
+            max_turns,
         }) => {
             const session_id = `scripted-${role}-${ticket}-${calls.length + 1}`
             sessions.set(session_id, { messaging, model, effort })
@@ -216,6 +219,7 @@ export const createScriptedLauncher = ({
                 may_edit_tests,
                 model,
                 effort,
+                ...(max_turns === undefined ? {} : { max_turns }),
                 delivered: [],
             }
             calls.push(call)

package/engine/agents/session-pool.ts

@@ -93,6 +93,7 @@ export const createSessionPool = ({
                       ok: false,
                       failure: 'agent',
                       error: `No result within ${timeoutMs} ms; the agent was interrupted.`,
+                      session_closed: true,
                   }
                 : raced
         if (raced === 'timeout') {

package/engine/config/engine-config-schema.ts

@@ -51,46 +51,84 @@ const JunitPathSchema = z.string().min(1).refine(isFileInsideRepo, {
         'must be a file inside the repo, relative to its root: not an absolute path, not one that leaves the repo with "..", and not ending in "/"',
 })
 
+/** The text a slow command's `run_files` must hold, where the files go (#683). */
+export const RUN_FILES_PLACEHOLDER = '{files}'
+
 /**
- * One entry of a `checks.test` list: a command, or a command and its kind.
- * A `junit` command names the JUnit files it writes in `junit_path` (#668),
- * one path or a list; no other kind may have one.
+ * One entry of a `checks.test` or `checks.slow_test` list: a command, or a
+ * command and its kind. A `junit` command names the JUnit files it writes in
+ * `junit_path` (#668), one path or a list; no other kind may have one. A slow
+ * entry may also name the test files it owns (`file_patterns`) and how to run
+ * some of them (`run_files`, #683); they come together, and a `checks.test`
+ * entry may have neither.
  */
-const TestCommandEntrySchema = z.union([
-    z.string().min(1),
-    z
-        .object({
-            run: z.string().min(1),
-            results: TestResultsSchema.optional(),
-            junit_path: z
-                .union([JunitPathSchema, z.array(JunitPathSchema).min(1)])
-                .optional(),
-        })
-        .refine(
-            ({ results, junit_path }) =>
-                results !== 'junit' || junit_path !== undefined,
-            {
-                message:
-                    'a "junit" test command needs junit_path: the JUnit files it writes, relative to the repo root',
-                path: ['junit_path'],
-            }
-        )
-        .refine(
-            ({ results, junit_path }) =>
-                results === 'junit' || junit_path === undefined,
-            {
-                message:
-                    'junit_path is only for a test command with "results": "junit"',
-                path: ['junit_path'],
-            }
-        ),
-])
+const testCommandEntrySchema = ({ slow }: { slow: boolean }) =>
+    z.union([
+        z.string().min(1),
+        z
+            .object({
+                run: z.string().min(1),
+                results: TestResultsSchema.optional(),
+                junit_path: z
+                    .union([JunitPathSchema, z.array(JunitPathSchema).min(1)])
+                    .optional(),
+                file_patterns: z.array(z.string().min(1)).min(1).optional(),
+                run_files: z.string().min(1).optional(),
+            })
+            .refine(
+                ({ file_patterns, run_files }) =>
+                    slow ||
+                    (file_patterns === undefined && run_files === undefined),
+                {
+                    message:
+                        'checks.test: file_patterns and run_files belong only on checks.slow_test entries.',
+                }
+            )
+            .refine(
+                ({ file_patterns, run_files }) =>
+                    !slow ||
+                    (file_patterns === undefined) === (run_files === undefined),
+                {
+                    message:
+                        'checks.slow_test: file_patterns and run_files come together; this entry has only one of them.',
+                }
+            )
+            .refine(
+                ({ run_files }) =>
+                    !slow ||
+                    run_files === undefined ||
+                    run_files.includes(RUN_FILES_PLACEHOLDER),
+                {
+                    message: `checks.slow_test: run_files must contain ${RUN_FILES_PLACEHOLDER}.`,
+                    path: ['run_files'],
+                }
+            )
+            .refine(
+                ({ results, junit_path }) =>
+                    results !== 'junit' || junit_path !== undefined,
+                {
+                    message:
+                        'a "junit" test command needs junit_path: the JUnit files it writes, relative to the repo root',
+                    path: ['junit_path'],
+                }
+            )
+            .refine(
+                ({ results, junit_path }) =>
+                    results === 'junit' || junit_path === undefined,
+                {
+                    message:
+                        'junit_path is only for a test command with "results": "junit"',
+                    path: ['junit_path'],
+                }
+            ),
+    ])
 
-/** A test command setting: one command, or a list of them (see `testCommands`). */
-const TestCommandsSchema = z.union([
-    z.string().min(1),
-    z.array(TestCommandEntrySchema),
-])
+/**
+ * A test command setting: one command, or a list of them (see
+ * `testCommands`). Only a slow one's entries may own files (#683).
+ */
+const testCommandsSchema = ({ slow }: { slow: boolean }) =>
+    z.union([z.string().min(1), z.array(testCommandEntrySchema({ slow }))])
 
 /** The config's `muninn` block. */
 export const MuninnConfigSchema = z.object({
@@ -204,13 +242,15 @@ export type ModelsConfig = z.infer<typeof ModelsConfigSchema>
 export const EngineConfigSchema = z.object({
     checks: z
         .object({
-            test: TestCommandsSchema.optional(),
+            test: testCommandsSchema({ slow: false }).optional(),
             /**
              * The slow tests (#563): the tests `test` leaves out, run only at
-             * the final review. Same shape as `test`. Left out, nothing
+             * the final review. Same shape as `test`, and an entry may also
+             * own some test files and run them in a ticket's gates
+             * (`file_patterns`, `run_files`, #683). Left out, nothing
              * changes.
              */
-            slow_test: TestCommandsSchema.optional(),
+            slow_test: testCommandsSchema({ slow: true }).optional(),
             types: z.string().min(1).optional(),
             lint: z.string().min(1).optional(),
         })

package/engine/config/engine-config.ts

@@ -37,6 +37,7 @@ export {
     ModelsConfigSchema,
     MuninnConfigSchema,
     ROUTED_ROLES,
+    RUN_FILES_PLACEHOLDER,
     TestResultsSchema,
 } from './engine-config-schema'
 export type {
@@ -55,8 +56,10 @@ export {
     hasSlowTests,
     isBunTestCommand,
     junitCommands,
+    ownSlowCommands,
     slowTestCommands,
     testCommands,
+    type OwnSlowCommand,
     type TestCommand,
 } from './test-commands'
 

package/engine/config/test-commands.ts

@@ -77,6 +77,41 @@ export const slowTestCommands = ({
     config: EngineConfig
 }): TestCommand[] => commandsOf(config.checks.slow_test)
 
+/**
+ * A slow test command that runs some of its files (#683): the test files it
+ * owns, and the command with `{files}` where they go.
+ */
+export type OwnSlowCommand = { file_patterns: string[]; run_files: string }
+
+/**
+ * The slow test commands with `run_files` (#683), in config order: a
+ * ticket's gates run its own files that match `file_patterns` through them.
+ *
+ * @example
+ * ownSlowCommands({ config: { ...config, checks: { test: 'bun test src', slow_test: [{ run: 'bun run ui', file_patterns: ['ui/**'], run_files: 'bun run ui-files {files}' }] } } })
+ * // [{ file_patterns: ['ui/**'], run_files: 'bun run ui-files {files}' }]
+ */
+export const ownSlowCommands = ({
+    config,
+}: {
+    config: EngineConfig
+}): OwnSlowCommand[] => {
+    const value = config.checks.slow_test
+    if (value === undefined || typeof value === 'string') return []
+    return value.flatMap((entry) =>
+        typeof entry === 'string' ||
+        entry.file_patterns === undefined ||
+        entry.run_files === undefined
+            ? []
+            : [
+                  {
+                      file_patterns: entry.file_patterns,
+                      run_files: entry.run_files,
+                  },
+              ]
+    )
+}
+
 /** Whether the config has a slow test command (#563). */
 export const hasSlowTests = ({ config }: { config: EngineConfig }): boolean =>
     slowTestCommands({ config }).length > 0

package/engine/core/agent-turn.ts

@@ -66,7 +66,9 @@ const failTurn = ({
  * every launcher alike; what others changed in the shared `.git` meanwhile
  * is journaled as `shared_git_changed`. Then the result is judged by its
  * structured output. Each failed turn is journaled once as `agent_failed`
- * with how it failed; the decision step picks what happens next. A writer's
+ * with how it failed; the decision step picks what happens next. A turn the
+ * launcher interrupted for its time limit then journals its session closed
+ * (#685), since the launcher closed it. A writer's
  * result then gets its chores done (`doChores`, #618); one the engine could
  * not do fails the turn as a `chore` failure. A launcher stop journals
  * `run_stopped` and ends the run. A turn the plan cut off (a rejected limit,
@@ -177,6 +179,16 @@ export const runTurn = async ({
             session_gone,
             out_of_turns,
         })
+        // A timed-out turn's session was closed by the launcher (#685):
+        // journal the close, so the next try is a fresh agent.
+        if (!turn.ok && turn.session_closed === true && session_id !== null) {
+            context.journal.append({
+                kind: 'agent_session_closed',
+                ticket,
+                role,
+                content: { role, session_id },
+            })
+        }
         return null
     }
     if (violations.length > 0) {

package/engine/core/build-action.ts

@@ -137,6 +137,23 @@ export type BuildAction =
           from_sha: string
           base_sha: string
       }
+    /**
+     * A refactor ticket's first bad test (#686): keep the implementer's work,
+     * hash the worktree's test files, and journal it all as
+     * `refactor_test_update`, so a fresh test-writer fixes `file`.
+     */
+    | {
+          type: 'open_refactor_update'
+          ticket: number
+          file: string
+          reason: string
+      }
+    /**
+     * After the refactor test update's test-writer answered: find the test
+     * files it changed since the update, journaled as
+     * `refactor_test_update_checked`.
+     */
+    | { type: 'check_refactor_update'; ticket: number }
     /** Remove these git worktrees at the end of the run; branches stay. */
     | { type: 'remove_worktrees'; paths: string[] }
     /** No ticket can move, and not every ticket has joined. */

package/engine/core/build-launch.ts

@@ -16,6 +16,10 @@ import {
 import { handoffSection, reviewFixSection, reviewSections } from './review-text'
 import { retrySection } from './stuck-text'
 
+import {
+    refactorFixedReviewSection,
+    refactorUpdateSection,
+} from '../agents/refactor-update-prompts'
 import {
     CHANGESETS_LENS_SECTION,
     CHANGESETS_SECTION,
@@ -95,9 +99,14 @@ const promptSections = ({
     progress: TicketProgress
 }): string[] => {
     const sections = buildPromptSections({ role, progress })
-    const { retried, crashed_turn } = progress
+    const { retried, crashed_turn, refactor_update } = progress
     return [
         ...sections,
+        ...(role === 'test-writer' &&
+        refactor_update !== null &&
+        refactor_update.result === null
+            ? [refactorUpdateSection(refactor_update)]
+            : []),
         ...(retried === null ? [] : [retrySection({ retried })]),
         ...(crashed_turn === role ? [CRASH_SECTION] : []),
     ]
@@ -152,8 +161,9 @@ const testUpdateSections = ({
 
 /**
  * The sections a launch adds for the ticket review: the reviewer's diff and
- * gate results (a re-review's new changes and earlier findings), or a
- * review fixer's findings while a review fix round is open.
+ * gate results (a re-review's new changes and earlier findings), and the
+ * tests a refactor test update changed on purpose (#686); or a review
+ * fixer's findings while a review fix round is open.
  */
 const reviewPromptSections = ({
     role,
@@ -164,10 +174,16 @@ const reviewPromptSections = ({
 }): string[] => {
     const fix = progress.review_fix
     if (role === 'ticket-reviewer') {
-        return reviewSections({
-            progress,
-            base_sha: progress.worktree?.base_sha ?? 'HEAD',
-        })
+        const { refactor_fixed } = progress
+        return [
+            ...reviewSections({
+                progress,
+                base_sha: progress.worktree?.base_sha ?? 'HEAD',
+            }),
+            ...(refactor_fixed.length === 0
+                ? []
+                : [refactorFixedReviewSection({ fixed: refactor_fixed })]),
+        ]
     }
     if (fix === null || progress.commits.green === null) return []
     if (role === 'test-writer' && !fix.tests_answered) {
@@ -209,8 +225,12 @@ export const launch = ({
         spec: snapshot.spec,
         ticket,
         refactor: isRefactorTicket({ ticket }),
-        // A test update names the bad test in its own section.
-        bad_test: progress.test_update === null ? progress.bad_test : null,
+        // A test update, or a refactor one, names the bad test in its own
+        // section.
+        bad_test:
+            progress.test_update === null && progress.refactor_update === null
+                ? progress.bad_test
+                : null,
         bad_test_by: progress.bad_test_source ?? undefined,
         sections: [
             ...promptSections({ role, progress }),