@alecsibilia/luca 14.0.0-alpha.6 → 14.0.0-alpha.8

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.8
+
+No changes in this release.
+
+## 14.0.0-alpha.7
+
+No changes in this release.
+
 ## 14.0.0-alpha.6
 
 No changes in this release.

package/board/package.json

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

package/board/server/board-vocabulary.ts

@@ -149,6 +149,15 @@ export const BOARD_VOCABULARY = {
     }),
     /** The engine started again on the run's journal, on Luca's `luca_version`. */
     engine_resumed: z.looseObject({ luca_version: z.string() }),
+    /**
+     * A resume took the repo's new build fields (#516); the board reads
+     * only which fields changed.
+     */
+    config_reloaded: z.looseObject({
+        changes: z.array(z.looseObject({ field: z.string() })),
+    }),
+    /** A resume kept the run's config, as the repo's couldn't be used. */
+    config_reload_refused: z.looseObject({ reason: z.string() }),
     intake_read: z.looseObject({ spec: SpecIssueSchema }),
     intake_refused: z.looseObject({
         problems: z.array(
@@ -448,6 +457,8 @@ const entry = <Kind extends BoardKind>({ kind }: { kind: Kind }) =>
 const BoardEntrySchema = z.discriminatedUnion('kind', [
     entry({ kind: 'run_started' }),
     entry({ kind: 'engine_resumed' }),
+    entry({ kind: 'config_reloaded' }),
+    entry({ kind: 'config_reload_refused' }),
     entry({ kind: 'intake_read' }),
     entry({ kind: 'intake_refused' }),
     entry({ kind: 'nothing_to_do' }),

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

package/board/server/make-rows.ts

@@ -252,6 +252,16 @@ export const describeRecord = ({
                 after.run.version_note !== before.run.version_note
                 ? event({ text: after.run.version_note, tone: 'warning' })
                 : null
+        case 'config_reloaded':
+            return event({
+                text: `Config reloaded: ${record.content.changes.map(({ field }) => field).join(', ')} changed.`,
+                tone: 'info',
+            })
+        case 'config_reload_refused':
+            return event({
+                text: `Config not reloaded, so the run keeps its own: ${record.content.reason.split('\n')[0] ?? ''}`,
+                tone: 'warning',
+            })
         case 'intake_refused':
             return event({
                 text: `Intake refused the run. ${after.run.refusal.join('; ')}`,

package/board/server/reduce-board.ts

@@ -61,6 +61,8 @@ const STUCK_REASONS: Record<string, string> = {
     setup_change_needed:
         'An agent needs a test setup file changed; only you may change one.',
     crashed: 'The engine crashed in the same step again and again.',
+    undo_refused:
+        'Undoing its join would have rewound the run branch over other work.',
 }
 
 /**
@@ -863,6 +865,10 @@ const applyKind = ({
                     }),
                 },
             }
+        // A resume's config reload (#516) is only a chat row.
+        case 'config_reloaded':
+        case 'config_reload_refused':
+            return state
         case 'intake_read':
             return {
                 ...state,

package/engine/cli/run-modes.ts

@@ -13,6 +13,7 @@ import { loadEngineConfig } from '../config/engine-config'
 import { lucaVersion } from '../config/luca-version'
 import { decide, type EngineAction } from '../core/decide'
 import {
+    recordConfigReload,
     recordResume,
     runEngine,
     startRun,
@@ -210,13 +211,46 @@ const driveRun = async ({
     return end
 }
 
+/** 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)
+
+/**
+ * The log line for a resume's `config_reloaded` or `config_reload_refused`
+ * (#516).
+ *
+ * @example
+ * configReloadText({ reload }) // 'config reloaded: prepare changed (make rom -> make rom-cached)'
+ */
+export const configReloadText = ({
+    reload,
+}: {
+    reload: JournalRecord
+}): string => {
+    switch (reload.kind) {
+        case 'config_reloaded':
+            return `config reloaded: ${reload.content.changes
+                .map(
+                    ({ field, from, to }) =>
+                        `${field} changed (${fieldValue(from)} -> ${fieldValue(to)})`
+                )
+                .join(', ')}`
+        case 'config_reload_refused':
+            return `kept the run's config, as the repo's can't be used: ${reload.content.reason}`
+        default:
+            return reload.kind
+    }
+}
+
 /**
  * A real run of `spec_number` on `repo`: loads the repo's engine config,
  * opens (or resumes) the run's journal at `<runs_dir>/<run_id>`, and runs the
  * engine with the board kept in step, the agents from `launcher`, and Jev
  * in shadow mode if given. With `memory`, a new run turns memory on (#370),
  * with the engine config's `muninn.vault` as the project vault (none:
- * `default` only); a resumed run keeps what its journal says. Never throws;
+ * `default` only); a resumed run keeps what its journal says. A new run
+ * stops on a bad config; a resume takes the config's build fields again
+ * and keeps its own on a bad one (`recordConfigReload`, #516). Never throws;
  * the launcher's sessions and the memory client are closed and the board
  * always gets the run's end.
  *
@@ -268,7 +302,9 @@ export const runSpec = async ({
     log(`[luca-run] spec #${spec_number} in ${repo}, run ${run_id}`)
     log(`[luca-run] journal: ${journal.file}`)
     const loaded = await loadEngineConfig({ repo_root: repo })
-    if (!loaded.ok) {
+    const fresh = isEmpty(journal.read())
+    // A new run needs a good config; a resume keeps its own (#516).
+    if (fresh && !loaded.ok) {
         log(`[luca-run] stopped: ${loaded.error}`)
         await launcher.closeAll?.()
         await memory?.client.close().catch(() => undefined)
@@ -276,7 +312,7 @@ export const runSpec = async ({
         await board?.end({ records: journal.read(), ...end })
         return end
     }
-    if (isEmpty(journal.read())) {
+    if (fresh && loaded.ok) {
         startRun({
             journal,
             spec_number,
@@ -292,6 +328,8 @@ export const runSpec = async ({
     } else {
         log('[luca-run] resuming the run from its journal')
         recordResume({ journal, luca_version })
+        const reload = recordConfigReload({ journal, loaded })
+        if (reload !== null) log(`[luca-run] ${configReloadText({ reload })}`)
     }
     return driveRun({
         journal,

package/engine/config/config-reload.ts

@@ -0,0 +1,160 @@
+import omit from 'lodash/omit'
+import reduce from 'lodash/reduce'
+import { z } from 'zod'
+
+import type { EngineConfig } from './engine-config'
+
+/**
+ * The config fields a resumed run takes from the repo's
+ * `.luca/config.json` again (#516). They say how the engine builds a
+ * checkout before its tests, not what the tests are, so a run can change
+ * them halfway without making its earlier results wrong: a repo that swaps
+ * a slow `prepare` for a fast cached one gets it on the next resume.
+ *
+ * - `prepare`: the command run before each test run in a checkout.
+ * - `prepare_timeout_ms`: how long that command may run.
+ * - `prepare_concurrency`: how many prepare runs may go at once. The
+ *   prepare slots take the limit on each call (`prepareCheck`), so a new
+ *   one counts from the next prepare run.
+ */
+export const RELOADED_FIELDS = [
+    'prepare',
+    'prepare_timeout_ms',
+    'prepare_concurrency',
+] as const
+
+/**
+ * The config fields a run keeps from its `run_started`, whatever the file
+ * says on a resume:
+ *
+ * - `checks`: the baseline, the red check, and the gates compare test
+ *   results across the run. A ticket takes another's baseline by commit
+ *   alone (`sharedBaselineStep` in `core/decide-build.ts`), and the red
+ *   check holds every old passing test of the baseline to the new run by
+ *   file and name (`checkRed` in `gates/red-check.ts`). A baseline taken
+ *   with old commands is not comparable with a run of new ones. Intake also
+ *   judged the run's tickets against these commands (a `bun` test command
+ *   for the red check).
+ * - `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.
+ * - `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`).
+ * - `run_budget_tokens`: the budget the run's tokens are counted against,
+ *   and the board's, from `run_started`; a raise is a `retry` reply.
+ */
+export const FROZEN_FIELDS = [
+    'checks',
+    'test_file_patterns',
+    'test_setup_files',
+    'rule_files',
+    'muninn',
+    'run_budget_tokens',
+] as const
+
+const positiveInt = z.number().int().positive().nullable()
+
+/**
+ * One reloaded field that changed: its value in the run before (`from`)
+ * and in the file now (`to`). `null` is a field left out, so a field added
+ * or removed is a change too.
+ */
+export const ConfigChangeSchema = z.discriminatedUnion('field', [
+    z.object({
+        field: z.literal('prepare'),
+        from: z.string().min(1).nullable(),
+        to: z.string().min(1).nullable(),
+    }),
+    z.object({
+        field: z.literal('prepare_timeout_ms'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+    z.object({
+        field: z.literal('prepare_concurrency'),
+        from: positiveInt,
+        to: positiveInt,
+    }),
+])
+
+export type ConfigChange = z.infer<typeof ConfigChangeSchema>
+
+/**
+ * The reloaded fields whose value differs between the run's config
+ * (`current`) and the one just read (`next`), old to new, in
+ * `RELOADED_FIELDS` order. Frozen fields are never changes. Pure.
+ *
+ * @example
+ * configChanges({ current: { ...config, prepare: 'make' }, next: { ...config, prepare: 'make fast' } })
+ * // [{ field: 'prepare', from: 'make', to: 'make fast' }]
+ */
+export const configChanges = ({
+    current,
+    next,
+}: {
+    current: EngineConfig
+    next: EngineConfig
+}): ConfigChange[] => {
+    const all: ConfigChange[] = [
+        {
+            field: 'prepare',
+            from: current.prepare ?? null,
+            to: next.prepare ?? null,
+        },
+        {
+            field: 'prepare_timeout_ms',
+            from: current.prepare_timeout_ms ?? null,
+            to: next.prepare_timeout_ms ?? null,
+        },
+        {
+            field: 'prepare_concurrency',
+            from: current.prepare_concurrency ?? null,
+            to: next.prepare_concurrency ?? null,
+        },
+    ]
+    return all.filter(({ from, to }) => from !== to)
+}
+
+const applyChange = ({
+    config,
+    change,
+}: {
+    config: EngineConfig
+    change: ConfigChange
+}): EngineConfig => {
+    switch (change.field) {
+        case 'prepare':
+            return change.to === null
+                ? omit(config, 'prepare')
+                : { ...config, prepare: change.to }
+        case 'prepare_timeout_ms':
+            return change.to === null
+                ? omit(config, 'prepare_timeout_ms')
+                : { ...config, prepare_timeout_ms: change.to }
+        case 'prepare_concurrency':
+            return change.to === null
+                ? omit(config, 'prepare_concurrency')
+                : { ...config, prepare_concurrency: change.to }
+    }
+}
+
+/**
+ * `config` with each change's new value: set, or left out for `null`. Pure.
+ *
+ * @example
+ * withConfigChanges({ config, changes: [{ field: 'prepare', from: 'make', to: null }] })
+ * // config without prepare
+ */
+export const withConfigChanges = ({
+    config,
+    changes,
+}: {
+    config: EngineConfig
+    changes: ConfigChange[]
+}): EngineConfig =>
+    reduce(
+        changes,
+        (next, change) => applyChange({ config: next, change }),
+        config
+    )

package/engine/core/decide-build.ts

@@ -1254,13 +1254,16 @@ const notRemoved = ({
  * the run branch's tip, then its install) once every ticket it waits on has
  * pushed, and while no ticket waits to join, so it never builds on joined
  * commits whose gates have not passed yet. Approved tickets join one at a
- * time, in the order their reviews finally approved them. A clash or failed
+ * time, in the order their reviews finally approved them, except that one
+ * already joining finishes first. A clash or failed
  * gates after joining puts the ticket's change back on top of the run
- * branch to be fixed there (up to `MAX_REJOINS` times), then re-reviewed. A
- * stuck ticket ends the run: no ticket starts or moves on, and the worktrees
- * of pushed tickets are removed. Once every ticket pushed, the final review
- * looks at the whole run branch (`decideFinalReview`) before the PR opens; a
- * stuck final review ends the run with the run branch's worktree kept. In a
+ * branch to be fixed there (up to `MAX_REJOINS` times), then re-reviewed.
+ * While a stuck ticket's join is still on the run branch, no ticket starts
+ * or joins until it is undone (#519), so no join lands on top of a join
+ * that is going away. A stuck ticket ends the run: no ticket starts or
+ * moves on, and the worktrees of pushed tickets are removed. Once every
+ * ticket pushed, the final review looks at the whole run branch
+ * (`decideFinalReview`) before the PR opens; a stuck final review ends the run with the run branch's worktree kept. In a
  * repo with changesets, the run's changeset is written just before the PR
  * (`write_changeset`), once. Once
  * the PR is open, every worktree is removed. Branches and the journal stay.
@@ -1450,6 +1453,8 @@ const buildSteps = ({
         }
     }
 
+    // A ticket already on the run branch finishes its join first (#519): a
+    // retried ticket approved earlier never joins on top of it.
     const queue = sortBy(
         numbers.filter(
             (number) =>
@@ -1457,16 +1462,20 @@ const buildSteps = ({
                 !isStuck(number) &&
                 !skipped(number)
         ),
-        (number) => progress(number).approved_seq
+        [
+            (number) => progress(number).joined === null,
+            (number) => progress(number).approved_seq,
+        ]
     )
-    const joiner = queue[0] ?? null
-    // A stuck ticket's join is undone before any new ticket starts on it.
+    // A stuck ticket's join is undone before any new ticket starts on it
+    // or joins on top of it (#519): a join on top would be undone with it.
     const stuckJoinOnRunBranch = numbers.some(
         (number) =>
             isStuck(number) &&
             progress(number).joined?.ok === true &&
             progress(number).pushed === null
     )
+    const joiner = stuckJoinOnRunBranch ? null : (queue[0] ?? null)
 
     const steps = numbers.flatMap((number): BuildAction[] => {
         const ticket = snapshot.tickets[number]

package/engine/core/decide-stuck.ts

@@ -137,7 +137,9 @@ const awaitingReply = (progress: TicketProgress): boolean =>
 /**
  * The next steps of one stuck ticket: undo a join its stuck left on the run
  * branch (so no other ticket builds on it), tell the spec issue, then act
- * on the owner's reply. Nothing while it waits for one.
+ * on the owner's reply. Nothing while it waits for one. A ticket stuck
+ * because its undo was refused (`undo_refused`, #519) is never undone again
+ * before a reply: it is told at once, with its join left where it is.
  */
 export const stuckTicketSteps = ({
     spec_number,
@@ -151,7 +153,11 @@ export const stuckTicketSteps = ({
     const { stuck, joined } = progress
     if (stuck === null) return []
     const number = ticket.number
-    if (joined?.ok === true && progress.pushed === null) {
+    if (
+        joined?.ok === true &&
+        progress.pushed === null &&
+        stuck.reason !== 'undo_refused'
+    ) {
         const first_sha = joined.shas[0]
         if (first_sha !== undefined) {
             return [{ type: 'undo_join', ticket: number, first_sha }]

package/engine/core/execute-build.ts

@@ -949,11 +949,37 @@ const undoCutOffJoin = async ({
     await context.git.resetWorktree({ cwd: runBranch.path, to: sha })
 }
 
+/**
+ * The run branch commits an undo of `ticket`'s join may take (#519): its
+ * own joined commits, and those of any other ticket that joined and has not
+ * pushed (a later join on top goes with it, and replay clears that join
+ * too). A pushed ticket's commits never.
+ */
+const undoableCommits = ({
+    state,
+    ticket,
+}: {
+    state: RunState
+    ticket: number
+}): string[] =>
+    uniq(
+        Object.entries(state.tickets).flatMap(([number, progress]) => {
+            const { joined } = progress
+            if (!joined?.ok) return []
+            const own = Number(number) === ticket
+            return own || progress.pushed === null ? joined.shas : []
+        })
+    )
+
 /**
  * Undoes a ticket's join on the run branch, back to before `first_sha`, and
- * returns the commits undone. The undone join's install is still in the run
- * branch's `node_modules`, so when its commits changed dependency files the
- * lockfile's install runs there again.
+ * returns the commits undone. It never rewinds over other work (#519): it
+ * may only undo the ticket's own join and later joins not pushed yet
+ * (`undoableCommits`). When git refuses, the run branch is left alone, the
+ * ticket is stuck (`undo_refused`) with why, and it returns `null`, so the
+ * caller does nothing more. The undone joins' install is still in the run
+ * branch's `node_modules`, so when their commits changed dependency files
+ * the lockfile's install runs there again.
  */
 const undoJoin = async ({
     context,
@@ -963,20 +989,45 @@ const undoJoin = async ({
     context: BuildContext
     ticket: number
     first_sha: string
-}): Promise<string[]> => {
-    const { git, state, journal } = context
+}): Promise<string[] | null> => {
+    const { git, state, journal, launcher } = context
     const runBranch = need({ value: state.run_branch, what: 'run branch' })
     const joined = state.tickets[ticket]?.joined
-    const last = joined?.ok ? joined.shas.at(-1) : undefined
+    const tip = await git.head({ cwd: runBranch.path })
+    const undo = await git.undoReplay({
+        cwd: runBranch.path,
+        first_sha,
+        only: undoableCommits({ state, ticket }),
+    })
+    if (!undo.ok) {
+        // A stuck ticket's agents take no more follow-ups.
+        await closeSessions({
+            journal,
+            launcher,
+            sessions: openSessionsIn({ records: journal.read() }).filter(
+                (session) => session.ticket === ticket
+            ),
+        })
+        journal.append({
+            kind: 'ticket_stuck',
+            ticket,
+            role: null,
+            content: {
+                reason: 'undo_refused',
+                detail: `The engine went to undo this ticket's join on the run branch (from ${first_sha.slice(0, 7)}), but that would have rewound the run branch over other work, so the run branch was left alone:\n${undo.error}`,
+            },
+        })
+        return null
+    }
+    const { undone } = undo
     const undoneFiles =
-        last === undefined
+        undone.length === 0
             ? []
             : await git.filesBetween({
                   cwd: runBranch.path,
                   from: `${first_sha}^`,
-                  to: last,
+                  to: tip,
               })
-    const { undone } = await git.undoReplay({ cwd: runBranch.path, first_sha })
     // A redo whose first try undid the join before a crash finds nothing
     // left to undo: the commits it undid are the journaled join's.
     const named =
@@ -999,7 +1050,8 @@ const undoJoin = async ({
  * join first if asked (its gates failed), then resets the ticket's worktree
  * to the run branch's tip and applies the ticket's whole diff there,
  * uncommitted, with conflict markers in the files that clash. Journals the
- * clashed files split into tests and code.
+ * clashed files split into tests and code. A refused undo (#519) leaves the
+ * ticket stuck, and nothing is rebased.
  */
 const rebaseTicket = async ({
     context,
@@ -1025,6 +1077,8 @@ const rebaseTicket = async ({
                   ticket: action.ticket,
                   first_sha: action.undo_first_sha,
               })
+    // A refused undo left the run branch alone and the ticket stuck.
+    if (undone === null) return
     const onto = await git.head({ cwd: runBranch.path })
     const moved_files = await git.filesBetween({
         cwd: worktree.path,
@@ -1458,20 +1512,22 @@ export const executeBuildAction = async ({
             })
             return
         }
-        case 'undo_join':
+        case 'undo_join': {
+            const shas = await undoJoin({
+                context,
+                ticket: action.ticket,
+                first_sha: action.first_sha,
+            })
+            // A refused undo left the run branch alone and the ticket stuck.
+            if (shas === null) return
             journal.append({
                 kind: 'join_undone',
                 ticket: action.ticket,
                 role: null,
-                content: {
-                    shas: await undoJoin({
-                        context,
-                        ticket: action.ticket,
-                        first_sha: action.first_sha,
-                    }),
-                },
+                content: { shas },
             })
             return
+        }
         case 'retry_ticket':
             return retryTicket({ context, action })
         case 'report_stuck':

package/engine/core/execute.ts

@@ -2,6 +2,7 @@ import { basename, dirname } from 'node:path'
 
 import has from 'lodash/has'
 import partition from 'lodash/partition'
+import values from 'lodash/values'
 
 import { decideSteps, type EngineAction } from './decide'
 import { isFinalReviewAction } from './decide-final-review'
@@ -29,9 +30,13 @@ import {
 } from './session-close'
 
 import type { BoardSync } from '../board/board-sync'
-import type { EngineConfig } from '../config/engine-config'
+import { configChanges } from '../config/config-reload'
+import type {
+    EngineConfig,
+    LoadEngineConfigResult,
+} from '../config/engine-config'
 import { lucaVersion } from '../config/luca-version'
-import { outsideBlockerNumbers } from '../intake/intake-checks'
+import { configProblems, outsideBlockerNumbers } from '../intake/intake-checks'
 import type { IntakeProblem } from '../intake/intake-schemas'
 import { jevAsksAfter, jevAsksBefore } from '../jev/jev-jobs'
 import { askJevInShadow, type JevShadow } from '../jev/jev-shadow'
@@ -140,6 +145,62 @@ export const recordResume = ({
         content: { luca_version },
     })
 
+/**
+ * On a resume, takes the repo's config again (#516), just read as
+ * `loaded`, and journals what came of it, right after `recordResume`:
+ *
+ * - a `config_reloaded` with the build fields (`RELOADED_FIELDS`) that
+ *   changed, old to new, which replay puts on the run's config;
+ * - nothing, when none changed (frozen fields never count, see
+ *   `FROZEN_FIELDS`);
+ * - a `config_reload_refused` with the reason, when the file is missing,
+ *   not JSON, not a valid config, or one intake would refuse
+ *   (`configProblems`, on the run's tickets). The run keeps its config.
+ *
+ * Never throws for a bad file: the run always goes on. Returns the record
+ * it appended, or `null`. A journal with no config yet (not a run) gets
+ * nothing; the decision step says what is wrong with it.
+ *
+ * @example
+ * recordResume({ journal })
+ * const reload = recordConfigReload({ journal, loaded: await loadEngineConfig({ repo_root }) })
+ */
+export const recordConfigReload = ({
+    journal,
+    loaded,
+}: {
+    journal: Journal
+    loaded: LoadEngineConfigResult
+}): JournalRecord | null => {
+    const state = replayRun({ records: journal.read() })
+    if (state.config === null) return null
+    const refuse = (reason: string): JournalRecord =>
+        journal.append({
+            kind: 'config_reload_refused',
+            ticket: null,
+            role: null,
+            content: { reason },
+        })
+    if (!loaded.ok) return refuse(loaded.error)
+    const problems = configProblems({
+        config: loaded.config,
+        tickets: values(state.snapshot?.tickets ?? {}),
+    })
+    if (problems.length > 0) return refuse(problems.join('\n'))
+    const changes = configChanges({
+        current: state.config,
+        next: loaded.config,
+    })
+    return changes.length === 0
+        ? null
+        : journal.append({
+              kind: 'config_reloaded',
+              ticket: null,
+              role: null,
+              content: { changes },
+          })
+}
+
 /** The comment a bad spec or ticket gets when intake refuses the run. */
 export const refusalComment = ({
     spec_number,

package/engine/core/stuck-text.ts

@@ -37,6 +37,8 @@ const REASON_LINES: Record<StuckReason, string> = {
     setup_change_needed:
         'An agent needs a test setup file changed, and only you may change one.',
     crashed: 'The engine crashed in the same step, again and again.',
+    undo_refused:
+        'Undoing its join would have rewound the run branch over other work, so the run branch was left alone.',
 }
 
 /** What the user could do, per reason; `n` is the ticket. */
@@ -75,6 +77,8 @@ const suggestion = ({
             return `Make that change yourself in the worktree, then reply ${retry}.`
         case 'crashed':
             return `Read the engine's log for why it crashed, fix what trips it, then reply ${retry} to take the step again with a fresh agent.`
+        case 'undo_refused':
+            return `Put the run branch back so this ticket's join is on top (or take its join off by hand), then reply ${retry}; or reply \`skip #${n}\`.`
     }
 }
 

package/engine/git/git-adapter.ts

@@ -134,14 +134,21 @@ export type GitAdapter = {
     }) => Promise<{ ok: true; shas: string[] } | { ok: false; error: string }>
     /**
      * Undoes a replay on the branch checked out at `cwd`: resets it hard to
-     * the commit before `first_sha`. Safe to run twice.
+     * the commit before `first_sha`. It never rewinds over other work
+     * (#519), so it refuses, with the branch left as it is, when
+     * `first_sha` is no commit (or has no parent), is not on the branch, or
+     * when any commit from `first_sha` up to the branch's tip is not in
+     * `only`. Safe to run twice: with the branch already at the commit
+     * before `first_sha`, it undoes nothing.
      *
-     * @returns The commits it undid, oldest first.
+     * @returns The commits it undid, oldest first, or why it refused.
      */
     undoReplay: (args: {
         cwd: string
         first_sha: string
-    }) => Promise<{ undone: string[] }>
+        /** The commits it may undo: any other on top of `first_sha` refuses. */
+        only: string[]
+    }) => Promise<{ ok: true; undone: string[] } | { ok: false; error: string }>
     /**
      * Moves a worktree's change onto another commit: resets the worktree at
      * `cwd` hard to `onto`, then applies the whole diff from `from` to `to`
@@ -535,16 +542,52 @@ export const createGitAdapter = ({
                 ),
             }
         },
-        undoReplay: async ({ cwd, first_sha }) => {
-            const before = `${first_sha}^`
+        undoReplay: async ({ cwd, first_sha, only }) => {
+            const short = first_sha.slice(0, 7)
+            const parent = await gitRun({
+                cwd,
+                args: [
+                    'rev-parse',
+                    '--verify',
+                    '--quiet',
+                    `${first_sha}^{commit}^`,
+                ],
+            })
+            if (parent.exit_code !== 0) {
+                return {
+                    ok: false,
+                    error: `Commit ${short} is not in the repo (or has no parent), so there is no join to undo.`,
+                }
+            }
+            const before = parent.stdout.trim()
+            const tip = await head({ cwd })
+            const ancestor = await gitRun({
+                cwd,
+                args: ['merge-base', '--is-ancestor', first_sha, 'HEAD'],
+            })
+            if (ancestor.exit_code !== 0) {
+                // Already undone, such as a redo after a crash.
+                if (tip === before) return { ok: true, undone: [] }
+                return {
+                    ok: false,
+                    error: `Commit ${short} is not on the branch, so undoing it (a reset to its parent) would rewind the branch over other work.`,
+                }
+            }
             const undone = lines(
                 await gitOk({
                     cwd,
                     args: ['rev-list', '--reverse', `${before}..HEAD`],
                 })
             )
+            const others = undone.filter((sha) => !only.includes(sha))
+            if (others.length > 0) {
+                return {
+                    ok: false,
+                    error: `Undoing ${short} would also undo other work on top of it: ${others.map((sha) => sha.slice(0, 7)).join(', ')}.`,
+                }
+            }
             await gitOk({ cwd, args: ['reset', '--quiet', '--hard', before] })
-            return { undone }
+            return { ok: true, undone }
         },
         rebaseWorktree: async ({ cwd, from, to, onto }) => {
             const folder = await mkdtemp(join(tmpdir(), 'luca-rebase-'))

package/engine/intake/intake-checks.ts

@@ -226,6 +226,43 @@ const groupFindings = ({
     }))
 }
 
+/**
+ * Intake's checks on the engine config, as messages for a person: a test
+ * command, and one with bun's per-test results unless every ticket in
+ * `tickets` is a refactor ticket (the red check reads per-test results,
+ * which only bun's give today). Pure. Empty when the config is fine.
+ *
+ * Intake runs it on the open tickets agents build; a resume runs it on the
+ * repo's config file before taking its new build fields (#516).
+ *
+ * @example
+ * configProblems({ config: { ...config, checks: {} }, tickets: [] })
+ * // ['The engine config (.luca/config.json) has no test command at checks.test.']
+ */
+export const configProblems = ({
+    config,
+    tickets,
+}: {
+    config: EngineConfig
+    tickets: { labels: string[] }[]
+}): string[] => {
+    const tests = testCommands({ config })
+    if (tests.length === 0) {
+        return [
+            `The engine config (${ENGINE_CONFIG_FILE}) has no test command at checks.test.`,
+        ]
+    }
+    if (
+        !tests.some(({ results }) => results === 'bun') &&
+        tickets.some((ticket) => !ticket.labels.includes(REFACTOR_LABEL))
+    ) {
+        return [
+            `The engine config (${ENGINE_CONFIG_FILE}) has no test command with bun results at checks.test, so the red check can't prove new tests fail first. Add a \`bun test\` command, or label every open ticket \`${REFACTOR_LABEL}\`.`,
+        ]
+    }
+    return []
+}
+
 /**
  * Intake's checks: is the spec, and every open ticket in it, ready to build?
  *
@@ -261,21 +298,8 @@ export const checkIntake = ({
     const onSpec = (message: string) =>
         findings.push({ ticket: spec.number, message })
 
-    const tests = testCommands({ config })
-    if (tests.length === 0) {
-        findings.push({
-            ticket: null,
-            message: `The engine config (${ENGINE_CONFIG_FILE}) has no test command at checks.test.`,
-        })
-    } else if (
-        !tests.some(({ results }) => results === 'bun') &&
-        forAgents.some((ticket) => !ticket.labels.includes(REFACTOR_LABEL))
-    ) {
-        // The red check reads per-test results, which only bun's give today.
-        findings.push({
-            ticket: null,
-            message: `The engine config (${ENGINE_CONFIG_FILE}) has no test command with bun results at checks.test, so the red check can't prove new tests fail first. Add a \`bun test\` command, or label every open ticket \`${REFACTOR_LABEL}\`.`,
-        })
+    for (const message of configProblems({ config, tickets: forAgents })) {
+        findings.push({ ticket: null, message })
     }
     if (spec.state !== 'open') onSpec('The spec is closed.')
     if (section({ body: spec.body, heading: 'Testing Decisions' }) === '') {

package/engine/journal/journal-record.ts

@@ -7,6 +7,7 @@ import {
     LensNameSchema,
     RoleResultSchema,
 } from '../agents/role-results'
+import { ConfigChangeSchema } from '../config/config-reload'
 import { EngineConfigSchema } from '../config/engine-config'
 import {
     GateCheckSchema,
@@ -92,6 +93,29 @@ const EngineResumedEntrySchema = z.object({
     content: z.object({ luca_version: z.string().min(1) }),
 })
 
+/**
+ * A resume read the repo's `.luca/config.json` again (#516), and the
+ * build fields it reloads (`RELOADED_FIELDS`) changed: each one, old to
+ * new. Journaled right after the resume's `engine_resumed`, only when
+ * something changed. Replay puts the new values on the run's config.
+ */
+const ConfigReloadedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('config_reloaded'),
+    content: z.object({ changes: z.array(ConfigChangeSchema).min(1) }),
+})
+
+/**
+ * A resume could not take the repo's config (#516): it is missing, not
+ * JSON, not a valid config, or one intake would refuse. The run keeps the
+ * config it had and goes on. `reason` says what is wrong.
+ */
+const ConfigReloadRefusedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('config_reload_refused'),
+    content: z.object({ reason: z.string().min(1) }),
+})
+
 const IntakeReadEntrySchema = z.object({
     ...ENTRY_FIELDS,
     kind: z.literal('intake_read'),
@@ -660,7 +684,9 @@ export type RejoinCause = z.infer<typeof RejoinCauseSchema>
  * and `code` are the files that clashed (conflict markers left in them),
  * split by the config's test file patterns. `undone` are the run branch
  * commits the engine undid first (a join whose gates failed), and
- * `reinstall` says whether the worktree needs its install again.
+ * `reinstall` says whether the worktree needs its install again. As with
+ * `join_undone`, replay clears the join of any other ticket whose joined
+ * commits are among `undone` (#519).
  */
 const TicketRebasedEntrySchema = z.object({
     ...ENTRY_FIELDS,
@@ -727,6 +753,8 @@ const RunBranchPushedEntrySchema = z.object({
 /**
  * Why a ticket (or the final review) is stuck. A failed red check or gate is only stuck once its
  * fix loop reaches its cap, and a bad test only on its second bounce.
+ * `undo_refused`: undoing its join would have rewound the run branch over
+ * other work, so the engine left the run branch alone (#519).
  */
 export const StuckReasonSchema = z.enum([
     'agent_failed',
@@ -742,6 +770,7 @@ export const StuckReasonSchema = z.enum([
     'prepare_failed',
     'setup_change_needed',
     'crashed',
+    'undo_refused',
 ])
 
 export type StuckReason = z.infer<typeof StuckReasonSchema>
@@ -932,7 +961,11 @@ const FinalReviewRetriedEntrySchema = z.object({
 
 /**
  * A stuck ticket's join was undone on the run branch (its commits were
- * never pushed), so no other ticket builds on them.
+ * never pushed), so no other ticket builds on them. `shas` are every commit
+ * the undo took off the run branch, oldest first: the ticket's own join and
+ * any later, unpushed joins on top of it (#519). Replay clears the join of
+ * every ticket whose joined commits are among them, not only this one's, so
+ * those tickets join again on the run branch as it is now.
  */
 const JoinUndoneEntrySchema = z.object({
     ...ENTRY_FIELDS,
@@ -1364,6 +1397,8 @@ export const JournalEntrySchema = z.discriminatedUnion('kind', [
     RunResumedEntrySchema,
     JoinStartedEntrySchema,
     EngineResumedEntrySchema,
+    ConfigReloadedEntrySchema,
+    ConfigReloadRefusedEntrySchema,
 ])
 
 /** A journal entry as callers write it; schema defaults fill the rest. */
@@ -1445,6 +1480,8 @@ export const JournalRecordSchema = z.discriminatedUnion('kind', [
     RunResumedEntrySchema.extend(STAMP_FIELDS),
     JoinStartedEntrySchema.extend(STAMP_FIELDS),
     EngineResumedEntrySchema.extend(STAMP_FIELDS),
+    ConfigReloadedEntrySchema.extend(STAMP_FIELDS),
+    ConfigReloadRefusedEntrySchema.extend(STAMP_FIELDS),
 ])
 
 export type JournalRecord = z.infer<typeof JournalRecordSchema>
@@ -1525,6 +1562,8 @@ export const JournalKindSchema = z.enum([
     'run_resumed',
     'join_started',
     'engine_resumed',
+    'config_reloaded',
+    'config_reload_refused',
 ])
 
 export type JournalKind = z.infer<typeof JournalKindSchema>

package/engine/journal/replay.ts

@@ -29,6 +29,7 @@ import {
     type TestWriterResult,
     type TicketReviewResult,
 } from '../agents/role-results'
+import { withConfigChanges } from '../config/config-reload'
 import type { EngineConfig } from '../config/engine-config'
 import type {
     GateCheck,
@@ -1014,6 +1015,21 @@ const applyRecord = ({
         // Luca's version on a resume changes no step: only the board reads it.
         case 'engine_resumed':
             return next
+        // A resume's new build fields (#516): every later step uses them.
+        case 'config_reloaded':
+            return {
+                ...next,
+                config:
+                    state.config === null
+                        ? null
+                        : withConfigChanges({
+                              config: state.config,
+                              changes: record.content.changes,
+                          }),
+            }
+        // The run kept its config; only the board and the log read why.
+        case 'config_reload_refused':
+            return next
         case 'comment_read':
             return { ...next, comments: [...state.comments, record.content] }
         case 'run_stuck':
@@ -1192,6 +1208,18 @@ const applyRecord = ({
                 state: { ...next, run_notes: notesAfter({ state, record }) },
                 record,
             })
+        case 'join_undone':
+            return undoneJoinsAfter({
+                state: applyTicketRecord({ state: next, record }),
+                ticket: record.ticket,
+                shas: record.content.shas,
+            })
+        case 'ticket_rebased':
+            return undoneJoinsAfter({
+                state: applyTicketRecord({ state: next, record }),
+                ticket: record.ticket,
+                shas: record.content.undone,
+            })
         // Always the final review's (see finalRecordOf above).
         case 'final_review_started':
         case 'lens_started':
@@ -1687,6 +1715,8 @@ type TicketRecord = Exclude<
             | 'step_ended'
             | 'run_resumed'
             | 'engine_resumed'
+            | 'config_reloaded'
+            | 'config_reload_refused'
             | 'join_started'
             | 'memory_write_started'
             | 'memory_write_done'
@@ -2260,8 +2290,8 @@ const retriedChange = ({
  * - in a review fix round, the round starts over as round 1 with fresh
  *   fixers, so the user's changes are gated, committed, and re-reviewed;
  * - a leftover scan, a failed install, a failed prepare command at the
- *   baseline, a reviewer's failed tries, a failed join, or a step crashes
- *   cut off just run again.
+ *   baseline, a reviewer's failed tries, a failed join, a refused undo of
+ *   its join (#519), or a step crashes cut off just run again.
  */
 const resumedProgress = ({
     progress,
@@ -2302,6 +2332,7 @@ const resumedProgress = ({
         reason === 'prepare_failed' ||
         reason === 'join_failed' ||
         reason === 'join_gates_failed' ||
+        reason === 'undo_refused' ||
         reason === 'crashed' ||
         reviewerFailed
     ) {
@@ -2546,6 +2577,41 @@ const closedSessionAfter = ({
     }
 }
 
+/**
+ * The other tickets whose joins an undo took off the run branch (#519): an
+ * undo resets the run branch to before the undone ticket's join, so any
+ * join on top of it goes too. Each such ticket's join and join gates are
+ * cleared, as its own undo would, so it joins again on the run branch as it
+ * is now, and a stuck one is never undone a second time. Its push, stuck,
+ * and reply are kept.
+ */
+const undoneJoinsAfter = ({
+    state,
+    ticket,
+    shas,
+}: {
+    state: RunState
+    /** The ticket whose join was undone. */
+    ticket: number | null
+    /** Every commit the undo took off the run branch. */
+    shas: string[]
+}): RunState => {
+    if (shas.length === 0) return state
+    return {
+        ...state,
+        tickets: mapValues(state.tickets, (progress, number) => {
+            const { joined } = progress
+            const taken =
+                Number(number) !== ticket &&
+                joined?.ok === true &&
+                joined.shas.some((sha) => shas.includes(sha))
+            return taken
+                ? { ...progress, joined: null, join_gates: null }
+                : progress
+        }),
+    }
+}
+
 const applyTicketRecord = ({
     state,
     record,

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@alecsibilia/luca",
     "description": "Luca: turns a spec on GitHub Issues into a reviewed pull request, run from Paseo with Claude Code",
-    "version": "14.0.0-alpha.6",
+    "version": "14.0.0-alpha.8",
     "license": "Apache-2.0",
     "author": "Alec Sibilia <sibilia.alec@gmail.com>",
     "homepage": "https://github.com/asibilia/luca-framework#readme",

package/skills/luca-unstick/SKILL.md

@@ -72,6 +72,7 @@ Find the stuck reason: `ticket_stuck` (a ticket), `final_review_stuck` (the fina
 | `leftovers_found` | The leftover scan found files that must not be committed (a report file, a nested git repo). | Delete or move those files out of the worktree (they're not the ticket's work), then `retry #n`. |
 | `setup_change_needed` | An agent needs a test setup file changed, and only a person may do that. | Read what it asks for. If it's right, make that change yourself in the worktree (ask the owner first: this one isn't a test file), then `retry #n`. |
 | `crashed` | The engine crashed in the same step, again and again. | That's an engine bug, not the ticket (see below). |
+| `undo_refused` | The ticket's join is still on the run branch, but undoing it would have rewound the run branch over other work (its join isn't on the branch, or other commits sit on top of it), so Luca left the run branch alone. Nothing new starts or joins until it's sorted (#519). | Look at the run branch's log next to the joins in the journal. Put the run branch back so the ticket's join is on top, or take its join off by hand (ask the owner first), then `retry #n`. Or `skip #n`. |
 | `run_budget` | The whole run used up its budget of tokens. | Look at what used them (a ticket stuck in fix loops?). A bare `retry` gives one more full budget; `stop` ends the run. |
 | `pull_request_failed` | Every ticket is done, but `gh pr create` failed, so the run's PR didn't open. The run branch is pushed, and the PR's full text is in the run folder's `pull-request.md`. | Read `gh`'s error. A GitHub or sign-in hiccup: a bare `retry` opens the PR. If you open it by hand from the run branch first, `retry` reuses it and never opens a second one. |