@alecsibilia/luca 14.0.0-alpha.1 → 14.0.0-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.3
+
+No changes in this release.
+
+## 14.0.0-alpha.2
+
+No changes in this release.
+
 ## 14.0.0-alpha.1
 
 ### Patch Changes

package/README.md

@@ -45,7 +45,7 @@ This is Luca v14, in alpha. Old Luca (v13) is still on npm; see [Coming from v13
 | `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, and the planning skills (`to-spec`, `to-tickets`, `setup-matt-pocock-skills`, `grilling`, `domain-modeling`). It asks before turning on Paseo's plugins, and leaves skills you already have alone. `--skip-skills` skips the 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. Then it reloads the board and says when to run `/reload-skills`. |
+| `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 it reloads the board and says when to run `/reload-skills`. |
 | `luca upgrade --to <version>` | Installs that exact version, an older one too, to go back when a version breaks. |
 
 `init`, `setup`, and `upgrade` end with their part of `luca doctor`'s checks.

package/board/index.client.tsx

@@ -31,7 +31,7 @@ export default function contribute(client: PluginClientContext) {
     client.addSlashCommand({
         name: 'luca-run',
         description:
-            'Start a Luca run for a spec: live rows here, and the Luca board panel',
+            'Start a Luca run for a spec, or resume one: live rows here, and the Luca board panel',
         argumentHint: RUN_USAGE.replace('/luca-run ', ''),
         context: 'agent',
         onSubmit: async ({ args, agent, workspace, rpc, openPanel }) => {

package/board/package.json

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

package/board/server/board-server.ts

@@ -15,9 +15,11 @@ import {
     liveRunIds,
     MAX_AUTO_RESTARTS,
     parseUnfinished,
+    RESUMED_TEXT,
     restartRow,
     restartText,
     resumeArgs,
+    resumeRow,
     UNFINISHED_TIMEOUT_MS,
     type StopWhy,
     type UnfinishedRun,
@@ -450,7 +452,7 @@ export const createBoardServer = ({
         change,
     }: {
         memory: RunMemory
-        change: Partial<Pick<RunEntry, 'ended' | 'restarts'>>
+        change: Partial<Pick<RunEntry, 'ended' | 'restarts' | 'token'>>
     }) => {
         memory.entry = registry.update({
             run_id: memory.entry.run_id,
@@ -503,15 +505,221 @@ export const createBoardServer = ({
         })
     }
 
+    /** Waits for rows being added, but at most `HEADER_WAIT_MS`. */
+    const waitForRows = async (adding: Promise<unknown>) => {
+        let timer: ReturnType<typeof setTimeout> | undefined
+        await Promise.race([
+            adding,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, HEADER_WAIT_MS)
+            }),
+        ])
+        clearTimeout(timer)
+    }
+
+    /**
+     * Engine checks and resumes run one at a time, so a resume and a check
+     * never both start an engine for the same run.
+     */
+    let engine_work: Promise<unknown> = Promise.resolve()
+    const exclusive = <Result>(work: () => Promise<Result>) => {
+        const result = engine_work.then(work)
+        engine_work = result.catch(() => undefined)
+        return result
+    }
+
+    /** Spawns a run's engine with `--resume` and its token; returns its pid. */
+    const spawnResume = ({
+        memory,
+        engine,
+        on_failed,
+    }: {
+        memory: RunMemory
+        engine: { command: string; lead_args: string[] }
+        /** What the log says when the process fails after the spawn. */
+        on_failed: string
+    }): number | null => {
+        const { run_id, repo, token, log_path } = memory.entry
+        return spawn_engine({
+            command: engine.command,
+            args: [...engine.lead_args, ...resumeArgs({ run_id, repo })],
+            env: childEnv({ token }),
+            cwd: repo,
+            log_path,
+            on_error: (error) => {
+                log(`[${run_id}] ${on_failed}: ${errorText({ error })}`)
+                void enqueue({
+                    run_id,
+                    work: () =>
+                        endRun({
+                            memory,
+                            ended: {
+                                ok: false,
+                                message: engineStoppedText({
+                                    why: {
+                                        kind: 'spawn_failed',
+                                        error: errorText({ error }),
+                                    },
+                                    run_id,
+                                    log_path,
+                                }),
+                            },
+                        }),
+                })
+            },
+        }).pid
+    }
+
+    /**
+     * `/luca-run resume <run id>` (#493): goes on with a run this plugin
+     * started, from its journal, with the board attached again. Refused for
+     * an unknown run, a demo, a run that is over, a run whose engine is
+     * still running, or when `ps` fails. Otherwise the run gets a new token,
+     * loses its `ended`, and starts its restart count again at 0; it keeps
+     * its chat, workspace, repo, and log. The engine is spawned with
+     * `--resume`, and the run's chat gets a row saying so.
+     */
+    const resumeRun = async ({
+        run_id,
+        input,
+    }: {
+        run_id: string
+        input: RunStartInput
+    }): Promise<RunStartOutput> => {
+        const refuse = (message: string): RunStartOutput => ({
+            ok: false,
+            message,
+            run_id: null,
+        })
+        const memory = runs.get(run_id)
+        if (!memory) {
+            return refuse(
+                `The board doesn't know run ${run_id}, so it can't resume it. Check the id: the run's header row and the board panel show it. A run the board didn't start goes on from a terminal with luca-run --resume ${run_id}, without the board.`
+            )
+        }
+        if (memory.entry.demo) {
+            return refuse(
+                `Run ${run_id} is a demo, and a demo can't be picked up again. Start a new one with /luca-run demo.`
+            )
+        }
+        if (OVER_PHASES.has(memory.state.run.phase)) {
+            return refuse(
+                `Run ${run_id} is over, so there is nothing to resume.`
+            )
+        }
+        const engine = await findEngine()
+        if (!engine.ok) return refuse(engine.message)
+
+        return exclusive(async () => {
+            let command_lines: string[]
+            try {
+                command_lines = await list_processes()
+            } catch (error) {
+                return refuse(
+                    `Couldn't check whether run ${run_id}'s engine is still running (${errorText({ error })}), so it wasn't resumed: two engines on one run would be far worse. Try again.`
+                )
+            }
+            if (liveRunIds({ command_lines }).has(run_id)) {
+                return refuse(
+                    `Run ${run_id} is still running (its engine is live), so there is nothing to resume.`
+                )
+            }
+            return enqueue({
+                run_id,
+                work: async (): Promise<RunStartOutput> => {
+                    const before = memory.entry
+                    // The new token is kept first: the engine may send
+                    // before the spawn returns.
+                    updateEntry({
+                        memory,
+                        change: {
+                            token: randomBytes(24).toString('hex'),
+                            ended: null,
+                            restarts: 0,
+                        },
+                    })
+                    let pid: number | null = null
+                    try {
+                        pid = spawnResume({
+                            memory,
+                            engine,
+                            on_failed: 'the resumed engine failed',
+                        })
+                    } catch (error) {
+                        updateEntry({
+                            memory,
+                            change: {
+                                token: before.token,
+                                ended: before.ended,
+                                restarts: before.restarts,
+                            },
+                        })
+                        return refuse(
+                            `Couldn't start the engine: ${errorText({ error })}`
+                        )
+                    }
+                    const { log_path, spec, agent_id } = memory.entry
+                    log(
+                        `[${run_id}] resumed with /luca-run resume: ${engine.command} with --resume (pid ${pid ?? '?'}), log ${log_path}`
+                    )
+                    memory.rows_stopped = false
+                    memory.append_failures = 0
+                    memory.state = {
+                        ...memory.state,
+                        run: { ...memory.state.run, engine_ended: null },
+                        latest: RESUMED_TEXT,
+                    }
+                    void enqueue({
+                        run_id,
+                        work: () =>
+                            appendRows({
+                                memory,
+                                rows: [
+                                    resumeRow({
+                                        run_id,
+                                        time: now().toISOString(),
+                                    }),
+                                    header({ memory }),
+                                ],
+                            }),
+                    })
+                    const what =
+                        spec === null
+                            ? `run ${run_id}`
+                            : `spec #${spec} (run ${run_id})`
+                    const where =
+                        agent_id === input.agent_id
+                            ? ''
+                            : ' Its rows go on in the chat it started in.'
+                    return {
+                        ok: true,
+                        run_id,
+                        message: `Resumed ${what} from its journal.${where} Its log is ${log_path}.`,
+                    }
+                },
+            })
+        })
+    }
+
     /**
      * `run.start`: parses the args, finds the engine, records the run, spawns
      * the engine detached, and adds the chat's header row. Returns at once.
+     * `resume <run id>` goes on with a run instead (see `resumeRun`).
      */
     const startRun = async (input: RunStartInput): Promise<RunStartOutput> => {
         await ready
         const parsed = parseRunArgs({ args: input.args })
         if (!parsed.ok)
             return { ok: false, message: parsed.message, run_id: null }
+        if (parsed.target.kind === 'resume') {
+            const output = await resumeRun({
+                run_id: parsed.target.run_id,
+                input,
+            })
+            const rows = queues.get(parsed.target.run_id)
+            if (output.ok && rows) await waitForRows(rows)
+            return output
+        }
 
         const engine = await findEngine()
         if (!engine.ok)
@@ -523,7 +731,7 @@ export const createBoardServer = ({
         }
         const token = randomBytes(24).toString('hex')
         const log_path = join(log_dir, `${run_id}.log`)
-        const { target } = parsed
+        const target = parsed.target
         const entry: RunEntry = {
             run_id,
             token,
@@ -583,18 +791,12 @@ export const createBoardServer = ({
             `[${run_id}] started ${engine.command} (pid ${pid ?? '?'}), log ${log_path}`
         )
 
-        const headerAdded = enqueue({
-            run_id,
-            work: () => appendRows({ memory, rows: [header({ memory })] }),
-        })
-        let timer: ReturnType<typeof setTimeout> | undefined
-        await Promise.race([
-            headerAdded,
-            new Promise((resolve) => {
-                timer = setTimeout(resolve, HEADER_WAIT_MS)
-            }),
-        ])
-        clearTimeout(timer)
+        await waitForRows(
+            enqueue({
+                run_id,
+                work: () => appendRows({ memory, rows: [header({ memory })] }),
+            })
+        )
 
         const what =
             target.kind === 'demo' ? 'a demo run' : `spec #${target.spec}`
@@ -805,39 +1007,14 @@ export const createBoardServer = ({
         memory: RunMemory
         engine: { command: string; lead_args: string[] }
     }): Promise<{ ok: true } | { ok: false; error: string }> => {
-        const { run_id, repo, token, log_path } = memory.entry
+        const { run_id, log_path } = memory.entry
         let pid: number | null = null
         try {
-            pid = spawn_engine({
-                command: engine.command,
-                args: [...engine.lead_args, ...resumeArgs({ run_id, repo })],
-                env: childEnv({ token }),
-                cwd: repo,
-                log_path,
-                on_error: (error) => {
-                    log(
-                        `[${run_id}] the restarted engine failed: ${errorText({ error })}`
-                    )
-                    void enqueue({
-                        run_id,
-                        work: () =>
-                            endRun({
-                                memory,
-                                ended: {
-                                    ok: false,
-                                    message: engineStoppedText({
-                                        why: {
-                                            kind: 'spawn_failed',
-                                            error: errorText({ error }),
-                                        },
-                                        run_id,
-                                        log_path,
-                                    }),
-                                },
-                            }),
-                    })
-                },
-            }).pid
+            pid = spawnResume({
+                memory,
+                engine,
+                on_failed: 'the restarted engine failed',
+            })
         } catch (error) {
             return { ok: false, error: errorText({ error }) }
         }
@@ -957,7 +1134,7 @@ export const createBoardServer = ({
      * const { restarted, stopped } = await board.checkEngines()
      */
     const checkEngines = (): Promise<EngineCheck> => {
-        checking ??= runCheck()
+        checking ??= exclusive(runCheck)
             .catch((error: unknown) => {
                 log(`The engine check failed: ${errorText({ error })}`)
                 return { restarted: [], stopped: [] }
@@ -972,6 +1149,7 @@ export const createBoardServer = ({
     const idle = async () => {
         await ready
         await checking
+        await engine_work
         await Promise.all([...queues.values()])
     }
 

package/board/server/board-vocabulary.ts

@@ -128,7 +128,10 @@ export const BOARD_VOCABULARY = {
             })
         ),
     }),
-    nothing_to_do: z.looseObject({}),
+    /** The run ends with nothing to do; `already_done` is empty at intake (#484). */
+    nothing_to_do: z.looseObject({
+        already_done: z.array(z.number().int()).catch([]).default([]),
+    }),
     spec_snapshot: z.looseObject({
         spec: z.looseObject({ number: z.number(), title: z.string() }),
         ticket_order: z.array(z.number()).catch([]),
@@ -221,6 +224,20 @@ export const BOARD_VOCABULARY = {
         tests: z.array(z.string()).catch([]),
         code: z.array(z.string()).catch([]),
     }),
+    /**
+     * After a rebase, a test the joined tickets made wrong went back to the
+     * ticket's test-writer (#489). `round` counts these per ticket.
+     */
+    tests_sent_back: z.looseObject({
+        round: z.number().int().min(1).catch(1),
+        bad_test: z
+            .looseObject({
+                file: z.string().catch(''),
+                name: z.string().catch(''),
+            })
+            .catch({ file: '', name: '' }),
+        joined: z.array(z.looseObject({ ticket: z.number().int() })).catch([]),
+    }),
     run_branch_pushed: z.looseObject({ branch: z.string() }),
     ticket_stuck: z.looseObject({
         reason: z.string(),
@@ -313,6 +330,12 @@ export const BOARD_VOCABULARY = {
     ticket_skipped: z.looseObject({
         because: z.number().int().nullable().catch(null),
     }),
+    /** A ticket whose work was already on the base branch (#484), done by `shas`. */
+    ticket_already_done: z.looseObject({
+        shas: z.array(z.string()).catch([]),
+    }),
+    /** The engine closed an already-done ticket, as the run opens no PR. */
+    ticket_closed: z.looseObject({}),
 
     // The final review (#367). Its agent, gate, scan, commit, and push
     // records are the usual kinds with `ticket: null`.
@@ -408,6 +431,7 @@ const BoardEntrySchema = z.discriminatedUnion('kind', [
     entry({ kind: 'gates_run' }),
     entry({ kind: 'ticket_joined' }),
     entry({ kind: 'ticket_rebased' }),
+    entry({ kind: 'tests_sent_back' }),
     entry({ kind: 'run_branch_pushed' }),
     entry({ kind: 'ticket_stuck' }),
     entry({ kind: 'run_stuck' }),
@@ -428,6 +452,8 @@ const BoardEntrySchema = z.discriminatedUnion('kind', [
     entry({ kind: 'reply_ignored' }),
     entry({ kind: 'ticket_retried' }),
     entry({ kind: 'ticket_skipped' }),
+    entry({ kind: 'ticket_already_done' }),
+    entry({ kind: 'ticket_closed' }),
     entry({ kind: 'final_review_started' }),
     entry({ kind: 'lens_started' }),
     entry({ kind: 'lens_finished' }),

package/board/server/engine-launch.ts

@@ -10,25 +10,42 @@ import type { EngineSettings } from '../shared/engine-settings'
  * `import.meta.url` is undefined and the cwd is `/`.
  */
 
-/** What a run builds: one spec, or the engine's safe practice run. */
+/** What a new run builds: one spec, or the engine's safe practice run. */
 export type RunTarget = { kind: 'spec'; spec: number } | { kind: 'demo' }
 
+/** What `/luca-run` asks for: a new run, or to resume a run the board started. */
+export type RunRequest = RunTarget | { kind: 'resume'; run_id: string }
+
 /**
- * Reads what followed `/luca-run`: `123`, `#123`, or `demo`.
+ * Reads what followed `/luca-run`: `123`, `#123`, `demo`, or
+ * `resume <run id>`.
  *
  * @example
  * parseRunArgs({ args: '#12' }) // { ok: true, target: { kind: 'spec', spec: 12 } }
+ * parseRunArgs({ args: 'resume luca-20260928-124805-69hp' }) // { ok: true, target: { kind: 'resume', run_id: 'luca-20260928-124805-69hp' } }
  * parseRunArgs({ args: 'soon' }).ok // false
  */
 export const parseRunArgs = ({
     args,
 }: {
     args: string
-}): { ok: true; target: RunTarget } | { ok: false; message: string } => {
+}): { ok: true; target: RunRequest } | { ok: false; message: string } => {
     const text = args.trim()
     if (text.toLowerCase() === 'demo') {
         return { ok: true, target: { kind: 'demo' } }
     }
+    const words = text.split(/\s+/)
+    if (words[0]?.toLowerCase() === 'resume') {
+        const run_id = words[1]
+        return run_id !== undefined &&
+            words.length === 2 &&
+            !run_id.startsWith('-')
+            ? { ok: true, target: { kind: 'resume', run_id } }
+            : {
+                  ok: false,
+                  message: `Which run? Give its id, as the board shows it. Usage: ${RUN_USAGE}`,
+              }
+    }
     const match = /^#?(\d+)$/.exec(text)
     const spec = match?.[1] ? Number(match[1]) : 0
     if (spec > 0 && Number.isSafeInteger(spec)) {

package/board/server/engine-watch.ts

@@ -131,6 +131,18 @@ export type StopWhy =
     | { kind: 'check_failed'; error: string }
     | { kind: 'spawn_failed'; error: string }
 
+/**
+ * How the owner resumes run `run_id` with the board attached: the
+ * `/luca-run resume` slash command (see `resumeRow`). A bare
+ * `luca-run --resume` would run without the board's token, so the board
+ * would show it read-only.
+ *
+ * @example
+ * resumeHint({ run_id: 'r1' }) // 'type /luca-run resume r1 in a Paseo chat'
+ */
+export const resumeHint = ({ run_id }: { run_id: string }): string =>
+    `type /luca-run resume ${run_id} in a Paseo chat`
+
 /**
  * What the board says when a run's engine is gone and the plugin won't
  * restart it. The panel and header show it as "The engine stopped: <text>".
@@ -147,22 +159,22 @@ export const engineStoppedText = ({
     run_id: string
     log_path: string
 }): string => {
-    const resume = `luca-run --resume ${run_id}`
+    const resume = resumeHint({ run_id })
     switch (why.kind) {
         case 'demo':
             return `its process is gone, and a demo can't be picked up again. Start a new one with /luca-run demo. Its log is ${log_path}.`
         case 'not_listed':
             return `its process is gone, and its journal has nothing to pick up again (it never wrote one, or the run already ended). Read its log: ${log_path}.`
         case 'launcher_stopped':
-            return `The run stopped: ${why.reason}. It isn't restarted automatically, because it would stop the same way. Fix that, then run ${resume}. Its log is ${log_path}.`
+            return `The run stopped: ${why.reason}. It isn't restarted automatically, because it would stop the same way. Fix that, then ${resume}. Its log is ${log_path}.`
         case 'billing_stopped':
             return `The run stopped for billing: ${why.reason}. It will not go on; start a new run once per-token billing is off.`
         case 'restarts_used_up':
-            return `it stopped again after ${MAX_AUTO_RESTARTS} automatic restarts, so Paseo stopped restarting it. Read its log: ${log_path}. To try once more, run ${resume}.`
+            return `it stopped again after ${MAX_AUTO_RESTARTS} automatic restarts, so Paseo stopped restarting it. Read its log: ${log_path}. To try once more, ${resume}.`
         case 'check_failed':
-            return `its process is gone, and Paseo couldn't check whether the run can go on (${why.error}). To go on from its journal, run ${resume}. Its log is ${log_path}.`
+            return `its process is gone, and Paseo couldn't check whether the run can go on (${why.error}). To go on from its journal, ${resume}. Its log is ${log_path}.`
         case 'spawn_failed':
-            return `its process is gone, and Paseo couldn't restart the engine: ${why.error}. To go on from its journal, run ${resume}. Its log is ${log_path}.`
+            return `its process is gone, and Paseo couldn't restart the engine: ${why.error}. To go on from its journal, ${resume}. Its log is ${log_path}.`
     }
 }
 
@@ -195,3 +207,31 @@ export const restartRow = ({
         tone: 'warning',
     },
 })
+
+/** The words of the chat row for a run resumed with `/luca-run resume`. */
+export const RESUMED_TEXT =
+    'The run was resumed from its journal with /luca-run resume.'
+
+/**
+ * The chat row for a run resumed with `/luca-run resume`; its id is unique
+ * per run and time, so each resume gets its own row.
+ *
+ * @example
+ * resumeRow({ run_id, time: new Date().toISOString() })
+ */
+export const resumeRow = ({
+    run_id,
+    time,
+}: {
+    run_id: string
+    time: string
+}): BoardRow => ({
+    id: `${run_id}-resumed-${time}`,
+    kind: ROW_KIND.event,
+    data: {
+        time,
+        ticket: null,
+        text: RESUMED_TEXT,
+        tone: 'info',
+    },
+})

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.1"
+export const LUCA_VERSION: string = "14.0.0-alpha.3"

package/board/server/make-rows.ts

@@ -11,7 +11,9 @@ import {
     runReasonText,
     reviewCountsText,
     roleWords,
+    shortSha,
     startKind,
+    testsSentBackText,
 } from './reduce-board'
 
 import {
@@ -216,11 +218,16 @@ export const describeRecord = ({
                 text: `Intake refused the run. ${after.run.refusal.join('; ')}`,
                 tone: 'danger',
             })
-        case 'nothing_to_do':
+        case 'nothing_to_do': {
+            const done = record.content.already_done
             return event({
-                text: 'Nothing to do: the spec has no open tickets.',
+                text:
+                    done.length === 0
+                        ? 'Nothing to do: the spec has no open tickets.'
+                        : `Nothing to do: the work of ${done.map((number) => `#${number}`).join(', ')} was already on the base branch.`,
                 tone: 'info',
             })
+        }
         case 'spec_snapshot':
             return event({
                 text: `Intake passed: spec #${record.content.spec.number}, ${record.content.ticket_order.length} tickets.`,
@@ -367,6 +374,11 @@ export const describeRecord = ({
                 text: `${at}${lowerFirst({ text: rebasedText({ content: record.content }) })}.`,
                 tone: 'warning',
             })
+        case 'tests_sent_back':
+            return event({
+                text: `${at}${lowerFirst({ text: testsSentBackText({ content: record.content }) })}.`,
+                tone: 'warning',
+            })
         case 'ticket_stuck':
             return event({
                 text: `${at}stuck. ${reasonText({ reason: record.content.reason })}`,
@@ -389,6 +401,16 @@ export const describeRecord = ({
                 tone: 'info',
             })
         }
+        case 'ticket_already_done':
+            return event({
+                text: `${at}already done on the base branch, by ${record.content.shas.map((sha) => shortSha({ sha })).join(', ')}. Nothing to build.`,
+                tone: 'success',
+            })
+        case 'ticket_closed':
+            return event({
+                text: `${at}closed, since its work was already done.`,
+                tone: 'info',
+            })
         case 'ticket_skipped': {
             const { because } = record.content
             return event({
@@ -689,6 +711,12 @@ const finishedText = ({
         })
     }
     if (role === 'test-writer') {
+        if (result.outcome === 'already_done') {
+            return event({
+                text: `${at}the test-writer found the work already done.`,
+                tone: 'info',
+            })
+        }
         return result.outcome === 'nothing_new_to_test'
             ? event({ text: `${at}nothing new to test.`, tone: 'info' })
             : event({ text: `${at}tests written.`, tone: 'info' })