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

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @alecsibilia/luca
 
+## 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.7",
     "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.7"

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

@@ -863,6 +863,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/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/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'),
@@ -1364,6 +1388,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 +1471,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 +1553,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':
@@ -1687,6 +1703,8 @@ type TicketRecord = Exclude<
             | 'step_ended'
             | 'run_resumed'
             | 'engine_resumed'
+            | 'config_reloaded'
+            | 'config_reload_refused'
             | 'join_started'
             | 'memory_write_started'
             | 'memory_write_done'

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.7",
     "license": "Apache-2.0",
     "author": "Alec Sibilia <sibilia.alec@gmail.com>",
     "homepage": "https://github.com/asibilia/luca-framework#readme",