@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/engine/agents/turn-progress.ts

@@ -0,0 +1,283 @@
+/**
+ * A turn's live progress (#628), for the engine's live file: what the
+ * agent and its helpers (#636) are doing now, read from the SDK messages (streamed chunks too,
+ * #631) and the guard hook. It
+ * holds only short words: a tool and a target (a path relative to the
+ * worktree, or the first words of a command), never a prompt, a file's
+ * contents or a command's output.
+ */
+import { basename, isAbsolute, join, relative } from 'node:path'
+
+import { z } from 'zod'
+
+import { RateLimitSchema, toolResultIds } from './claude-messages'
+
+import { HELPER_MODEL, HELPER_TOOL } from '../guards/helper-rules'
+
+/** The agent's latest action: a tool and a short target, with its time (ISO). */
+export type ProgressAction = { tool: string; target: string; at: string }
+
+/** A tool call the guard let through whose result hasn't come back yet. */
+export type ProgressOpenCall = {
+    tool: string
+    target: string
+    started_at: string
+}
+
+/**
+ * A helper the agent started this turn (#636): its model, its latest
+ * action, and whether its result has come back.
+ */
+export type ProgressHelper = {
+    model: string
+    action: ProgressAction | null
+    done: boolean
+}
+
+/** What one turn has done so far, as `on_progress` hears it. */
+export type TurnProgress = {
+    /** Every token the turn's messages read or wrote so far, cache reads included. */
+    tokens: number
+    action: ProgressAction | null
+    open_call: ProgressOpenCall | null
+    /** The turn's helpers, oldest first; none when left out. */
+    helpers?: ProgressHelper[]
+    /** The turn's `rate_limit_event` readings so far, each with `arrived_at`. */
+    rate_limit_events: Record<string, unknown>[]
+}
+
+/** Hears a turn's progress each time it changes. */
+export type ProgressListener = (progress: TurnProgress) => void
+
+/** How many words of a command a target keeps. */
+const COMMAND_WORDS = 3
+
+/** The longest target, in characters. */
+const MAX_TARGET = 60
+
+const UsageSchema = z.object({
+    input_tokens: z.number().default(0),
+    output_tokens: z.number().default(0),
+    cache_read_input_tokens: z.number().nullable().default(0),
+    cache_creation_input_tokens: z.number().nullable().default(0),
+})
+
+const AssistantSchema = z.object({
+    type: z.literal('assistant'),
+    uuid: z.string().optional(),
+    parent_tool_use_id: z.string().nullable().default(null),
+    message: z.object({
+        id: z.string().optional(),
+        content: z.array(z.unknown()).default([]),
+        usage: UsageSchema.optional(),
+    }),
+})
+
+const ToolUseSchema = z.object({
+    type: z.literal('tool_use'),
+    name: z.string(),
+    input: z.unknown(),
+})
+
+/** The parts of a tool call's input a target is made from. */
+const TargetInputSchema = z
+    .object({
+        file_path: z.unknown(),
+        notebook_path: z.unknown(),
+        command: z.unknown(),
+        pattern: z.unknown(),
+        subagent_type: z.unknown(),
+    })
+    .partial()
+
+/** A streamed chunk of the model's answer (#631), with partial messages on. */
+const StreamEventSchema = z.object({ type: z.literal('stream_event') })
+
+const textOf = (value: unknown): string | null =>
+    typeof value === 'string' && value.trim() !== '' ? value.trim() : null
+
+/** A path relative to the worktree; one outside it keeps its name only. */
+const shortPath = ({
+    path,
+    worktree,
+}: {
+    path: string
+    worktree: string
+}): string => {
+    const inside = relative(
+        worktree,
+        isAbsolute(path) ? path : join(worktree, path)
+    )
+    return inside.startsWith('..') || isAbsolute(inside)
+        ? basename(path)
+        : inside
+}
+
+/** The first words of a command's first line. */
+const firstWords = (command: string): string =>
+    (command.split('\n')[0] ?? '')
+        .trim()
+        .match(new RegExp(`^\\S+(?:\\s+\\S+){0,${COMMAND_WORDS - 1}}`))?.[0] ??
+    ''
+
+/**
+ * A tool call's short target: the path it works on, the first words of
+ * its command, its search pattern, or its helper's type.
+ *
+ * @example
+ * targetOf({ tool_name: 'Bash', tool_input: { command: 'bun test src --bail' }, worktree }) // 'bun test src'
+ */
+export const targetOf = ({
+    tool_name,
+    tool_input,
+    worktree,
+}: {
+    tool_name: string
+    tool_input: unknown
+    worktree: string
+}): string => {
+    const parsed = TargetInputSchema.safeParse(tool_input)
+    const input = parsed.success ? parsed.data : {}
+    const path = textOf(input.file_path) ?? textOf(input.notebook_path)
+    const target =
+        path !== null
+            ? shortPath({ path, worktree })
+            : tool_name === 'Bash'
+              ? firstWords(textOf(input.command) ?? '')
+              : (textOf(input.pattern) ?? textOf(input.subagent_type) ?? '')
+    return target.slice(0, MAX_TARGET)
+}
+
+/**
+ * Keeps one session's turn progress and tells `on_progress` each time it
+ * changes. `start` begins a turn afresh, with its own listener;
+ * `readings` gives the turn's plan-usage readings, as the session's
+ * summary has them.
+ *
+ * @example
+ * const progress = createTurnProgress({ worktree, readings: () => summary.rate_limit_events })
+ * progress.start(on_progress)
+ * progress.heard(message)
+ */
+export const createTurnProgress = ({
+    worktree,
+    readings,
+}: {
+    worktree: string
+    readings: () => Record<string, unknown>[]
+}) => {
+    let listener: ProgressListener | undefined
+    let tokens = new Map<string, number>()
+    let action: ProgressAction | null = null
+    let open = new Map<string, ProgressOpenCall>()
+    /** The turn's helpers, by the `Agent` call that started each. */
+    let helpers = new Map<string, ProgressHelper>()
+
+    const tell = (): void => {
+        listener?.({
+            tokens: [...tokens.values()].reduce((sum, each) => sum + each, 0),
+            action,
+            open_call: [...open.values()].at(-1) ?? null,
+            helpers: [...helpers.values()].map((helper) => ({ ...helper })),
+            rate_limit_events: [...readings()],
+        })
+    }
+
+    const start = (on_progress: ProgressListener | undefined): void => {
+        listener = on_progress
+        tokens = new Map()
+        action = null
+        open = new Map()
+        helpers = new Map()
+    }
+
+    /**
+     * Reads one SDK message: its tokens, its tool calls, the results back. A
+     * streamed chunk is told as it comes, so the heartbeat moves while the
+     * model thinks, but nothing of it is kept: the whole message that
+     * follows carries the tokens.
+     */
+    const heard = (raw: unknown): void => {
+        if (
+            RateLimitSchema.safeParse(raw).success ||
+            StreamEventSchema.safeParse(raw).success
+        ) {
+            tell()
+            return
+        }
+        const assistant = AssistantSchema.safeParse(raw)
+        if (assistant.success) {
+            const { message, uuid, parent_tool_use_id } = assistant.data
+            const usage = message.usage
+            if (usage !== undefined) {
+                tokens.set(
+                    message.id ?? uuid ?? String(tokens.size),
+                    usage.input_tokens +
+                        usage.output_tokens +
+                        (usage.cache_read_input_tokens ?? 0) +
+                        (usage.cache_creation_input_tokens ?? 0)
+                )
+            }
+            // A helper's own calls are its action, not its agent's.
+            const helper =
+                parent_tool_use_id === null
+                    ? undefined
+                    : helpers.get(parent_tool_use_id)
+            for (const block of message.content) {
+                const call = ToolUseSchema.safeParse(block)
+                if (!call.success) continue
+                const latest = {
+                    tool: call.data.name,
+                    target: targetOf({
+                        tool_name: call.data.name,
+                        tool_input: call.data.input,
+                        worktree,
+                    }),
+                    at: new Date().toISOString(),
+                }
+                if (parent_tool_use_id === null) action = latest
+                else if (helper !== undefined) helper.action = latest
+            }
+            tell()
+            return
+        }
+        const ids = toolResultIds(raw)
+        if (!ids.some((id) => open.has(id) || helpers.has(id))) return
+        for (const id of ids) {
+            open.delete(id)
+            const helper = helpers.get(id)
+            if (helper !== undefined) helper.done = true
+        }
+        tell()
+    }
+
+    /** A tool call the guard let through: open until its result comes back. */
+    const opened = ({
+        tool_name,
+        tool_input,
+        tool_use_id,
+    }: {
+        tool_name: string
+        tool_input: unknown
+        tool_use_id: string
+    }): void => {
+        open.set(tool_use_id, {
+            tool: tool_name,
+            target: targetOf({ tool_name, tool_input, worktree }),
+            started_at: new Date().toISOString(),
+        })
+        if (tool_name === HELPER_TOOL) {
+            helpers.set(tool_use_id, {
+                model: HELPER_MODEL,
+                action: null,
+                done: false,
+            })
+        }
+        tell()
+    }
+
+    return { start, heard, opened }
+}
+
+/** The progress `createTurnProgress` keeps for one session. */
+export type TurnProgressKeeper = ReturnType<typeof createTurnProgress>

package/engine/agents/writer-instructions.ts

@@ -0,0 +1,151 @@
+/**
+ * The task sections of the roles that write: the test-writer and the
+ * implementer.
+ */
+import { engineChores, REVIEW_FIXER, setupFiles } from './common-instructions'
+
+import {
+    caseLimitOf,
+    featureMapPath,
+    isFeatureMapFolder,
+    slowTestCommands,
+    testCommands,
+    type EngineConfig,
+} from '../config/engine-config'
+import { MAX_TESTS_PER_CRITERION } from '../core/loop-caps'
+
+const TEST_UPDATE = `## Updating tests after a rebase
+Sometimes other tickets joined the run branch after this ticket's tests were written, and the engine moved this ticket's change on top of it. If the implementer then says one of your tests is wrong, the tests come back to you. Your prompt says what joined, and the test and the implementer's reason. Then:
+- The ticket's code is already in the worktree. Never touch it; edit test files only.
+- Change a test only where the run branch's behavior changed what it should expect. Read what joined with \`git log\` and \`git show\`. Don't weaken a test just to make it pass.
+- Every criterion still needs a test. Your updated tests may pass now, since the code is there; that is fine. The engine runs every test in the gates after the implementer's turn.
+- Answer "tests_written" with the full criterion mapping again.`
+
+/**
+ * When a writer may answer `environment` (#613), and that the engine checks
+ * the claim by rerunning the failed check.
+ */
+const environmentLine = ({ check }: { check: string }): string =>
+    `- If ${check} failed for a reason that is not this ticket's fault (the machine or another ticket: a port already in use, EADDRINUSE; an old test that also fails at baseline), don't fake a fix: answer outcome "environment", with your evidence in "environment": { evidence } (the error lines, and what you checked). The engine checks the claim by rerunning the failed check once, with no fix round used. If the rerun fails the same way, the ticket is stuck for the owner, so answer it only when you are sure.`
+
+/**
+ * The test-writer's lines about the feature map (#583), or nothing without
+ * one. A folder map (#597) is read page by page, and a new test file goes on
+ * its area's page.
+ */
+const featureMapLines = ({ config }: { config: EngineConfig }): string => {
+    const path = featureMapPath({ config })
+    if (path === null) return ''
+    return isFeatureMapFolder({ path })
+        ? `- Read the feature map's pages (the *.md files under ${path}/) first: they list each feature and the test files that prove it.\n- Put new tests in a feature's existing test files when you can. A new test file must be listed under its feature on its area's page in ${path}/; you may edit or add those pages.\n`
+        : `- Read ${path} first: it lists each feature and the test files that prove it.\n- Put new tests in a feature's existing test files when you can. A new test file must be listed under its feature in ${path}; you may edit that file.\n`
+}
+
+/** What the test-writer's "ONLY test files" line adds for the feature map, or nothing. */
+const featureMapClause = ({ config }: { config: EngineConfig }): string => {
+    const path = featureMapPath({ config })
+    if (path === null) return ''
+    return isFeatureMapFolder({ path })
+        ? ` and the feature map's pages (*.md under ${path}/)`
+        : ` and the feature map ${path}`
+}
+
+/** What the test-writer's "ONLY test files" line adds for test helpers (#619), or nothing. */
+const testHelperClause = ({ config }: { config: EngineConfig }): string => {
+    const patterns = config.test_helper_patterns ?? []
+    return patterns.length === 0
+        ? ''
+        : `, test helpers only tests use, such as fakes and fixtures (${patterns.join(', ')})`
+}
+
+export const TEST_WRITER = ({
+    config,
+}: {
+    config: EngineConfig
+}) => `# Your role: test-writer
+
+You write the failing tests for ONE ticket, before any code exists.
+
+- Create or edit ONLY test files (${config.test_file_patterns.join(', ')})${testHelperClause({ config })}${featureMapClause({ config })}. No other file: no implementation, no package.json, no config, no notes, and not the test setup files.
+- Your new tests must FAIL right now, because the code does not exist yet. That is expected. Do not create or stub the module under test.
+- Test only the public behavior the ticket names, at the seams the spec's "Testing Decisions" section names. No mocks unless the spec asks. No tautological asserts.
+${featureMapLines({ config })}- Every acceptance criterion needs at least one test, and at most ${MAX_TESTS_PER_CRITERION}: write the fewest tests that prove it. Old tests must keep passing.
+- Map every test you add. The red check refuses a new test your criterion mapping doesn't name.
+- Give every test a plain string-literal name (no test.each, no template names), so the engine can find each one before the module exists.
+
+Your result (structured output):
+- outcome: "tests_written", or "nothing_new_to_test" if the ticket truly changes no behavior (a refactor), or "already_done" if the ticket's work is already on the base branch, or "needs_setup_change" if the tests can't work without a change to a test setup file${setupFiles({ config })} (you may never change one): say which file and why in "setup_change", and the user makes the change.
+- Answer "already_done" only when EVERY acceptance criterion is already met on the base branch and already has a test that checks it. Look with \`git log\` and \`git show\`, and read the code and tests. Then write no tests, and give your evidence: in "done_by", the commits that did the work, as { sha, title }; in "criteria", the existing tests that cover each criterion. The engine checks this evidence: each commit must be on the base branch, and each test must exist and pass there. If even one criterion is not met, or not tested, write the tests instead.
+- criteria: for EACH criterion id (AC1, AC2, ...), the tests that check it, as { file, name }. "name" is the full name bun prints: describe names and the test name joined by " > ".
+${environmentLine({ check: 'the red check' })}
+- done_by: empty, unless the outcome is "already_done".
+- finding_responses: empty, unless your prompt gives you ticket review findings (see below).
+- file_modes, run_generators: empty, unless you need a chore below.
+- summary, assumptions, run_notes.
+
+${engineChores({ config })}
+
+${TEST_UPDATE}
+
+${REVIEW_FIXER}`
+
+const testFileRule = ({
+    config,
+    may_edit_tests,
+}: {
+    config: EngineConfig
+    may_edit_tests: boolean
+}): string =>
+    may_edit_tests
+        ? `- You may follow renames and moves into test files (${config.test_file_patterns.join(', ')}), but never change what a test checks. Never touch a test setup file${setupFiles({ config })}.`
+        : `- Never create, edit, or delete a test file (${config.test_file_patterns.join(', ')}) or a test setup file${setupFiles({ config })}.`
+
+/** The implementer's line about the slow tests (#563), or nothing without them. */
+const slowLine = ({ config }: { config: EngineConfig }): string => {
+    const slow = slowTestCommands({ config }).map(({ run }) => `\`${run}\``)
+    return slow.length === 0
+        ? ''
+        : ` The slow tests (${slow.join(', ')}) run at the final review, and the ticket's gates also run the slow test files it added or changed; you may run them yourself.`
+}
+
+/**
+ * The implementer's line about the fast test limit (#580), or nothing without
+ * one.
+ */
+const limitLine = ({ config }: { config: EngineConfig }): string => {
+    const limit = caseLimitOf({ config })
+    return limit === null
+        ? ''
+        : `- Each fast test must finish within ${limit} ms. If one of the ticket's tests can't, answer "bad_test".\n`
+}
+
+export const IMPLEMENTER = ({
+    config,
+    may_edit_tests,
+}: {
+    config: EngineConfig
+    may_edit_tests: boolean
+}) => `# Your role: implementer
+
+You write the code that makes ONE ticket's failing tests pass. Another agent wrote the tests; the engine already committed them.
+
+- Make every gate pass: ${[
+    ...testCommands({ config }).map(({ run }) => run),
+    config.checks.types,
+    config.checks.lint,
+]
+    .filter((command) => command !== undefined)
+    .map((command) => `\`${command}\``)
+    .join(', ')}.${slowLine({ config })}
+${limitLine({ config })}${testFileRule({ config, may_edit_tests })}
+- If a test is wrong (it contradicts the ticket or spec, or no correct code can pass it), don't work around it: answer outcome "bad_test" with the test and your reason.
+- If the gates can't pass without a change to a test setup file${setupFiles({ config })}, don't work around it: answer outcome "needs_setup_change", with the file and why in "setup_change". The user makes the change.
+${environmentLine({ check: 'a gate' })}
+- Follow the spec's Implementation Decisions. Keep the change small: no extra features, and no new dependencies unless the spec says so.
+- Leave nothing behind: no scratch files, logs, notes, or unused scripts. The engine scans for leftovers before it commits.
+
+Your result (structured output): outcome ("done", "bad_test", "needs_setup_change", or "environment"), bad_test (null unless outcome is "bad_test"), setup_change (null unless outcome is "needs_setup_change"), environment (null unless outcome is "environment"), finding_responses (empty unless you were sent ticket review findings), file_modes and run_generators (empty unless you need a chore below), summary, assumptions, run_notes.
+
+${engineChores({ config })}
+
+${REVIEW_FIXER}`

package/engine/cli/computer-adapters-real.ts

@@ -372,12 +372,24 @@ export const boardDir = async (): Promise<string> => {
 }
 
 /**
- * The installed Luca: its version (see `lucaVersion`), its board folder,
- * the real path of its `luca-run`, and Bun's own path.
+ * The skills folder in Luca's install folder: `skills/` next to `engine/`
+ * in the published package, or `packages/engine/skills` in a working copy
+ * (both two folders up from this file). Its real path when it exists;
+ * `luca doctor` reports it when it doesn't.
+ */
+export const skillsDir = async (): Promise<string> => {
+    const dir = join(import.meta.dir, '..', '..', 'skills')
+    return realpath(dir).catch(() => dir)
+}
+
+/**
+ * The installed Luca: its version (see `lucaVersion`), its board and skills
+ * folders, the real path of its `luca-run`, and Bun's own path.
  */
 export const lucaInstall = async (): Promise<LucaInstall> => ({
     luca_version: lucaVersion(),
     board_dir: await boardDir(),
+    skills_dir: await skillsDir(),
     engine_path: await realpath(join(import.meta.dir, 'luca-run.ts')),
     bun_path: await realpath(process.execPath),
 })
@@ -388,7 +400,7 @@ const PackageJsonSchema = z.looseObject({
 })
 
 /** The package a file belongs to: the nearest package.json with a name. */
-const packageOf = async (
+export const packageOf = async (
     file: string
 ): Promise<{ name: string; version: string | null } | null> => {
     for (let dir = dirname(file); ; dir = dirname(dir)) {

package/engine/cli/computer-adapters.ts

@@ -115,6 +115,8 @@ export type LucaInstall = {
     luca_version: string
     /** The board folder inside Luca's install folder. */
     board_dir: string
+    /** The skills folder inside Luca's install folder (Luca's own skills). */
+    skills_dir: string
     /** The real path of the installed `luca-run`. */
     engine_path: string
     /** Bun's own path. */

package/engine/cli/computer-checks.ts

@@ -22,17 +22,24 @@ import {
     type DoctorCheck,
     type Found,
 } from './doctor-checks'
+import { claudeSkillsDir, skillDrift } from './luca-skills'
 import { isRight, rightEntry, userMuninnEntry } from './muninn-entry'
 
 import { LUCA_PACKAGE } from '../config/luca-version'
+import {
+    loadDecisionModelCredentials,
+    missingKeyLines,
+    type Env,
+} from '../jev/decision-model-credentials'
+import { DEFAULT_DECISION_MODEL } from '../jev/jev-schemas'
 import { READY_LABEL } from '../tracker/tracker'
 
 /**
  * `luca doctor`'s checks of this computer, read-only: Bun, the `luca`
  * copies on the PATH, Claude Code, the `gh` login, Paseo and its plugins,
- * the board, MuninnDB and Claude Code's `muninn` entry, and the planning
- * skills. `luca init` and `luca upgrade` end with them too. The token is
- * never shown.
+ * the board, MuninnDB and Claude Code's `muninn` entry, the planning
+ * skills, Luca's own skills, and the decision model's credentials. `luca
+ * init` and `luca upgrade` end with them too. No token is ever shown.
  */
 
 /** The oldest tool versions Luca works with. */
@@ -327,17 +334,77 @@ const checkPlanningSkills = async ({ home }: { home: string }) => {
     return ok('The planning skills write what intake needs')
 }
 
+/**
+ * Luca's own skills (#504): each one in the installed Luca's skills folder
+ * (#529) is in `~/.claude/skills`, and its files are the ones it ships.
+ */
+const checkLucaSkills = async ({
+    home,
+    skills_dir,
+    luca_version,
+}: {
+    home: string
+    skills_dir: string
+    luca_version: string
+}) => {
+    const drift = await skillDrift({ home, skills_dir })
+    if (drift.length === 0) {
+        return problem({
+            detail: `Luca's folder ${skills_dir} has no skills.`,
+            fix: `Reinstall Luca: bun add -g ${LUCA_PACKAGE}@alpha`,
+        })
+    }
+    const off = drift.filter(
+        ({ missing, changed }) => missing.length + changed.length > 0
+    )
+    if (off.length > 0) {
+        const described = off.map(({ skill, missing }) =>
+            missing.includes('SKILL.md')
+                ? `/${skill} isn't installed`
+                : `/${skill} isn't the one Luca ${luca_version} ships`
+        )
+        return problem({
+            detail: `In ${claudeSkillsDir({ home })}, ${described.join('; ')}.`,
+            fix: 'Run luca doctor --fix (or luca init) to install it.',
+        })
+    }
+    return ok(
+        `Luca's skills (${drift.map(({ skill }) => `/${skill}`).join(', ')}) match Luca ${luca_version}`
+    )
+}
+
+/**
+ * The decision model's Cloudflare credentials (#534), from Luca's own env
+ * file and the process env. With none it is off: a warning, not a problem,
+ * since runs go on without it. Never shows the token.
+ */
+const checkDecisionModel = async ({
+    env,
+    home,
+}: {
+    env: Env
+    home: string
+}) => {
+    const credentials = await loadDecisionModelCredentials({ env, home })
+    if (credentials.ok) return ok(`Clef set up (${DEFAULT_DECISION_MODEL})`)
+    return warning({
+        detail: `Decision model off: no credentials (${credentials.missing.join(' and ')} not set in ${credentials.file}).`,
+        fix: `Add these lines to ${credentials.file}: ${missingKeyLines(credentials).join(', ')} (a Workers AI token from the Cloudflare dashboard), or leave the decision model off.`,
+    })
+}
+
 /**
  * Runs the computer checks, in order, read-only. Never throws: a check that
  * fails becomes a problem.
  *
  * @example
- * const checks = await computerChecks({ home, luca_version, board_dir, engine_path, bun_path, computer, muninn, muninn_health, claude, paseo })
+ * const checks = await computerChecks({ home, luca_version, board_dir, skills_dir, engine_path, bun_path, computer, muninn, muninn_health, claude, paseo, env: process.env })
  */
 export const computerChecks = async ({
     home,
     luca_version,
     board_dir,
+    skills_dir,
     engine_path,
     bun_path,
     computer,
@@ -345,11 +412,14 @@ export const computerChecks = async ({
     muninn_health,
     claude,
     paseo,
+    env,
 }: {
     home: string
     /** The installed Luca's version. */
     luca_version: string
     board_dir: string
+    /** The skills folder inside Luca's install folder. */
+    skills_dir: string
     engine_path: string
     bun_path: string
     computer: Computer
@@ -357,6 +427,11 @@ export const computerChecks = async ({
     muninn_health: MuninnHealth
     claude: ClaudeMcp
     paseo: Paseo
+    /**
+     * The process env, for the decision model's keys and `XDG_CONFIG_HOME`.
+     * Left out, none: only Luca's env file in `home` counts.
+     */
+    env?: Env
 }): Promise<DoctorCheck[]> => {
     // With Paseo down, its plugins and the board aren't asked about.
     let paseo_up = true
@@ -399,6 +474,14 @@ export const computerChecks = async ({
             ['muninndb', () => checkMuninnDb({ muninn, muninn_health })],
             ['muninn_entry', () => checkMuninnEntry({ muninn, claude })],
             ['planning_skills', () => checkPlanningSkills({ home })],
+            [
+                'luca_skills',
+                () => checkLucaSkills({ home, skills_dir, luca_version }),
+            ],
+            [
+                'decision_model',
+                () => checkDecisionModel({ env: env ?? {}, home }),
+            ],
         ],
     })
 }

package/engine/cli/config-reload-text.ts

@@ -0,0 +1,39 @@
+/**
+ * The log line for a resume's config reload (#516): what a `config_reloaded`
+ * changed, or why a `config_reload_refused` kept the run's own config.
+ */
+import type { JournalRecord } from '../journal/journal-record'
+
+/** A value of a reloaded config field in a log line; `null` is "none". */
+const fieldValue = (value: string | number | string[] | null): string => {
+    if (value === null) return 'none'
+    if (Array.isArray(value)) return `[${value.join(', ')}]`
+    return 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
+    }
+}