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

package/CHANGELOG.md

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

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.5",
+    "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(
@@ -279,7 +288,10 @@ export const BOARD_VOCABULARY = {
         reason: z.string(),
         detail: z.string().catch(''),
     }),
-    /** The whole run is stuck (#435): `run_budget`, it used up its budget. */
+    /**
+     * The whole run is stuck (#435): `run_budget`, it used up its budget,
+     * or `pull_request_failed`, its PR didn't open (#508).
+     */
     run_stuck: z.looseObject({
         reason: z.string(),
         detail: z.string().catch(''),
@@ -445,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.5"
+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

@@ -408,6 +408,8 @@ const resolveNeedsYou = ({
 const RUN_STUCK_REASONS: Record<string, string> = {
     run_budget:
         'The run used up its run budget of tokens. `retry` adds one more full budget.',
+    pull_request_failed:
+        "The run's pull request didn't open. `retry` tries again, reusing a PR already open from the run branch.",
 }
 
 /** A run stuck reason code in words. */
@@ -861,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/agents/role-prompts.ts

@@ -190,6 +190,28 @@ export const prepareSection = ({ command }: { command: string }): string =>
             "If the engine's prepare command fails after your turn, its output comes back to you like a failed check.",
     ].join('\n\n')
 
+/**
+ * The section a test-writer or implementer (a ticket's or the final
+ * review's fixers) gets in a repo with changesets: the engine writes the
+ * run's one changeset, so an agent's own is extra.
+ */
+export const CHANGESETS_SECTION = [
+    '## The engine writes the changeset',
+    "Don't write changesets, even if the repo's rules ask for one: the engine writes the run's one changeset when it opens the PR. " +
+        'A new file you add in `.changeset/` is removed before the commit. ' +
+        'A finding that only asks for a changeset is answered by this: answer it "wont_fix" and say the engine adds it.',
+].join('\n\n')
+
+/**
+ * The section the rules lens gets in a repo with changesets, so a rule like
+ * "every PR needs a changeset" raises no finding.
+ */
+export const CHANGESETS_LENS_SECTION = [
+    '## The engine writes the changeset',
+    "The engine adds the run's one changeset when it opens the PR, so a rule that asks for a changeset is met. " +
+        'Raise no finding that only asks for a changeset.',
+].join('\n\n')
+
 /** What each lens judges the whole run branch on, in one paragraph. */
 const LENS_TASK_TEXT =
     'You are one lens of the final review: a fresh, read-only reviewer of the WHOLE run branch, every ticket of the spec together. Write nothing.'

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

@@ -47,6 +47,8 @@ import {
 import { badTestDetail, retrySection, setupChangeDetail } from './stuck-text'
 
 import {
+    CHANGESETS_LENS_SECTION,
+    CHANGESETS_SECTION,
     prepareSection,
     rejoinSection,
     rolePrompt,
@@ -1303,34 +1305,47 @@ export const decideBuild = ({
 }): BuildAction[] => {
     const steps = buildSteps({ state, spec_number })
     const command = state.config?.prepare
-    return command === undefined
-        ? steps
-        : steps.map((step) => withPrepareSection({ step, command }))
+    const prepared =
+        command === undefined
+            ? steps
+            : steps.map((step) =>
+                  withWriterSection({
+                      step,
+                      section: prepareSection({ command }),
+                  })
+              )
+    return state.changesets ? prepared.map(withChangesetsSections) : prepared
 }
 
 /**
  * A fresh test-writer's or implementer's launch (a ticket's or the final
- * review's fixers), with the repo's prepare command named in its prompt.
- * Any other step as it is.
+ * review's fixers), with `section` added to its prompt, such as the repo's
+ * prepare command. Any other step as it is.
  */
-const withPrepareSection = ({
+const withWriterSection = ({
     step,
-    command,
+    section,
 }: {
     step: BuildAction
-    command: string
+    section: string
 }): BuildAction => {
     const writesCode =
         (step.type === 'launch_agent' || step.type === 'launch_final_fixer') &&
         (step.role === 'test-writer' || step.role === 'implementer')
     return writesCode
-        ? {
-              ...step,
-              prompt: `${step.prompt}\n\n${prepareSection({ command })}`,
-          }
+        ? { ...step, prompt: `${step.prompt}\n\n${section}` }
         : step
 }
 
+/**
+ * In a repo with changesets, the writers are told not to write one and the
+ * rules lens that the engine adds the run's one at PR time (#507).
+ */
+const withChangesetsSections = (step: BuildAction): BuildAction =>
+    step.type === 'launch_lens' && step.lens === 'rules'
+        ? { ...step, prompt: `${step.prompt}\n\n${CHANGESETS_LENS_SECTION}` }
+        : withWriterSection({ step, section: CHANGESETS_SECTION })
+
 /** `decideBuild`'s steps, before the prepare command joins any prompt. */
 const buildSteps = ({
     state,

package/engine/core/decide-run-budget.ts

@@ -1,5 +1,9 @@
 import { pendingReplies, waitForReply, type StuckAction } from './decide-stuck'
-import { runBudgetDetail, runStuckComment } from './stuck-text'
+import {
+    pullRequestStuckComment,
+    runBudgetDetail,
+    runStuckComment,
+} from './stuck-text'
 
 import type { JournalRecord, RunStuckReason } from '../journal/journal-record'
 import type { RunState } from '../journal/replay'
@@ -19,7 +23,9 @@ export type RunBudgetAction =
  * reason "run budget": that is its only step, and nothing new starts. The
  * spec issue is told, then the run waits for the owner: a bare `retry`
  * adds one more full budget (replay does that), and `stop` ends the run.
- * The owner's other replies wait until the run carries on. `null` when
+ * The owner's other replies wait until the run carries on. A run whose PR
+ * didn't open (#508) is stuck the same way, told why, and a `retry` tries
+ * the PR again, adding no budget. `null` when
  * the budget has nothing to say: the run is under it, stopping, or its PR
  * is open.
  *
@@ -56,7 +62,10 @@ export const decideRunBudget = ({
             {
                 type: 'report_run_stuck',
                 spec_number,
-                body: runStuckComment({ detail: stuck.detail, budget }),
+                body:
+                    stuck.reason === 'pull_request_failed'
+                        ? pullRequestStuckComment({ detail: stuck.detail })
+                        : runStuckComment({ detail: stuck.detail, budget }),
             },
         ]
     }