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

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.2
+
+No changes in this release.
+
+## 14.0.0-alpha.1
+
+### Patch Changes
+
+- 8a58510: Spec: Luca v14 fixes: no empty changesets, board version, init sets up the repo ([#480](https://github.com/asibilia/luca-framework/issues/480))
+
 ## 14.0.0-alpha.0
 
 ### Major Changes

package/README.md

@@ -24,17 +24,15 @@ This is Luca v14, in alpha. Old Luca (v13) is still on npm; see [Coming from v13
 
    While v14 is in alpha, npm's `latest` is still v13, so install `@alecsibilia/luca@alpha` for now.
 
-2. Set up this computer, once:
+2. Set up this computer and your repo, once, from inside your repo:
 
    ```bash
    luca init
    ```
 
-3. Set up your repo, once, from inside it:
+   Run inside a git repo, `luca init` sets up this computer, then runs `luca setup` to set up that repo too. Run outside a repo, it sets up only this computer. For another repo later, run `luca setup` from inside it.
 
-   ```bash
-   luca setup
-   ```
+3. Check what `luca setup` wrote to `.luca/config.json`. It names your repo's GitHub name (like `tmnb`) as its memory vault in `muninn.vault`; change it if you want another.
 
 4. In Claude Code, in your repo, run `/setup-matt-pocock-skills` so the planning skills know your repo.
 5. Write a spec with `/to-spec`, then split it into tickets with `/to-tickets`.
@@ -44,8 +42,8 @@ This is Luca v14, in alpha. Old Luca (v13) is still on npm; see [Coming from v13
 
 | Command | What it does |
 | ------- | ------------ |
-| `luca init` | Sets up this computer, once (safe to run again): MuninnDB and its Claude Code entry, the board in Paseo with its engine and Bun paths, and the planning skills (`to-spec`, `to-tickets`, `setup-matt-pocock-skills`, `grilling`, `domain-modeling`). It asks before turning on Paseo's plugins, and leaves skills you already have alone. `--skip-skills` skips the skills. |
-| `luca setup` | Gets the repo in this folder ready: the labels a run needs (and the `release:*` labels when the repo uses changesets), `.luca/config.json`, and a check of GitHub sub-issues and dependencies. `--base <branch>` names the base branch. |
+| `luca init` | Sets up this computer, once (safe to run again): MuninnDB and its Claude Code entry, the board in Paseo with its engine and Bun paths, and the planning skills (`to-spec`, `to-tickets`, `setup-matt-pocock-skills`, `grilling`, `domain-modeling`). It asks before turning on Paseo's plugins, and leaves skills you already have alone. `--skip-skills` skips the skills. Inside a git repo, it then runs `luca setup` for that repo. |
+| `luca setup` | Gets the repo in this folder ready: the labels a run needs (and the `release:*` labels when the repo uses changesets), `.luca/config.json` (a new one gets the repo's GitHub name as its vault; an existing vault is kept), and a check of GitHub sub-issues and dependencies. `--base <branch>` names the base branch. |
 | `luca doctor` | Checks this computer, this repo when you're in one, and what v13 left behind. Each problem comes with its exact fix. `luca doctor --fix` fixes what's safe without asking: it never deletes (v13 files go to a dated backup folder) and never commits, and it lists the repo files to commit. |
 | `luca upgrade` | Moves to the newest Luca on your channel: `alpha` stays on `alpha`, and it never goes back to v13. It refuses while any run is going (stuck runs and limit waits count) and lists them. Then it reloads the board and says when to run `/reload-skills`. |
 | `luca upgrade --to <version>` | Installs that exact version, an older one too, to go back when a version breaks. |

package/board/index.server.ts

@@ -1,7 +1,5 @@
-import { existsSync, readFileSync, realpathSync } from 'node:fs'
+import { existsSync, realpathSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 
 import type {
     PluginHandlerContext,
@@ -11,6 +9,7 @@ import type {
 import { createBoardServer } from './server/board-server'
 import { ENGINE_CHECK_MS } from './server/engine-watch'
 import { listProcesses } from './server/list-processes'
+import { LUCA_VERSION } from './server/luca-version'
 import { runCommand } from './server/run-command'
 import { defaultRunsDir } from './server/run-journals'
 import { defaultRegistryPath } from './server/run-registry'
@@ -37,29 +36,6 @@ type Paseo = PluginHandlerContext['paseo']
 
 const log = (message: string) => console.error(`[${PLUGIN_ID}] ${message}`)
 
-/**
- * The Luca version in the board folder's package.json, which the published
- * package stamps with its own version; `null` when it can't be read.
- */
-const loadedVersion = (): string | null => {
-    try {
-        const manifest: unknown = JSON.parse(
-            readFileSync(
-                join(dirname(fileURLToPath(import.meta.url)), 'package.json'),
-                'utf8'
-            )
-        )
-        return typeof manifest === 'object' &&
-            manifest !== null &&
-            'version' in manifest &&
-            typeof manifest.version === 'string'
-            ? manifest.version
-            : null
-    } catch {
-        return null
-    }
-}
-
 /**
  * The board plugin's daemon side: the engine settings (their usage lines
  * kept in a file for the engine), `run.start` (launch a
@@ -154,9 +130,8 @@ export default function contribute(server: PluginServerContext) {
         connect({ context })
         return board.readBoard(input)
     })
-    // Read once, as loaded: after an upgrade it differs until a reload.
-    const version = loadedVersion()
-    server.handle(boardVersionRpc, () => ({ version }))
+    // Fixed as loaded: after an upgrade it differs until a reload.
+    server.handle(boardVersionRpc, () => ({ version: LUCA_VERSION }))
 
     // Lifecycle hooks time out at 30 s, so the first check is not awaited.
     void board.checkEngines()

package/board/package.json

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

package/board/server/board-vocabulary.ts

@@ -128,7 +128,10 @@ export const BOARD_VOCABULARY = {
             })
         ),
     }),
-    nothing_to_do: z.looseObject({}),
+    /** The run ends with nothing to do; `already_done` is empty at intake (#484). */
+    nothing_to_do: z.looseObject({
+        already_done: z.array(z.number().int()).catch([]).default([]),
+    }),
     spec_snapshot: z.looseObject({
         spec: z.looseObject({ number: z.number(), title: z.string() }),
         ticket_order: z.array(z.number()).catch([]),
@@ -313,6 +316,12 @@ export const BOARD_VOCABULARY = {
     ticket_skipped: z.looseObject({
         because: z.number().int().nullable().catch(null),
     }),
+    /** A ticket whose work was already on the base branch (#484), done by `shas`. */
+    ticket_already_done: z.looseObject({
+        shas: z.array(z.string()).catch([]),
+    }),
+    /** The engine closed an already-done ticket, as the run opens no PR. */
+    ticket_closed: z.looseObject({}),
 
     // The final review (#367). Its agent, gate, scan, commit, and push
     // records are the usual kinds with `ticket: null`.
@@ -428,6 +437,8 @@ const BoardEntrySchema = z.discriminatedUnion('kind', [
     entry({ kind: 'reply_ignored' }),
     entry({ kind: 'ticket_retried' }),
     entry({ kind: 'ticket_skipped' }),
+    entry({ kind: 'ticket_already_done' }),
+    entry({ kind: 'ticket_closed' }),
     entry({ kind: 'final_review_started' }),
     entry({ kind: 'lens_started' }),
     entry({ kind: 'lens_finished' }),

package/board/server/luca-version.ts

@@ -0,0 +1,2 @@
+/** The Luca version of this board, stamped when the package was packed. */
+export const LUCA_VERSION: string = "14.0.0-alpha.2"

package/board/server/make-rows.ts

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

package/board/server/reduce-board.ts

@@ -40,7 +40,7 @@ const STUCK_REASONS: Record<string, string> = {
     agent_failed: 'An agent failed on its last try.',
     red_check_failed: 'The red check failed.',
     nothing_new_to_test:
-        'The test-writer found nothing new to test. If the ticket changes no behavior, label it refactor and start the run again.',
+        'The test-writer says the ticket changes no behavior, so there is nothing new to test. Label it refactor and retry it.',
     leftovers_found:
         'The leftover scan found files that must not be committed.',
     gates_failed: 'The checks failed.',
@@ -49,11 +49,30 @@ const STUCK_REASONS: Record<string, string> = {
     join_failed: "The ticket couldn't join the run branch.",
     join_gates_failed: 'The checks failed after the ticket joined.',
     install_failed: 'Installing the dependencies failed.',
+    prepare_failed: "The repo's prepare command failed.",
     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.',
 }
 
+/**
+ * A commit's short sha, as git and GitHub show it.
+ *
+ * @example
+ * shortSha({ sha: '3559c25f5a1b' }) // '3559c25'
+ */
+export const shortSha = ({ sha }: { sha: string }): string => sha.slice(0, 7)
+
+/**
+ * An already-done ticket's activity (#484): calm, with the commits that
+ * did its work.
+ *
+ * @example
+ * alreadyDoneText({ shas: ['3559c25f5a1b'] }) // 'already done · 3559c25'
+ */
+export const alreadyDoneText = ({ shas }: { shas: string[] }): string =>
+    ['already done', ...shas.map((sha) => shortSha({ sha }))].join(' · ')
+
 /** Why a retry of an edited ticket was refused, in words. */
 export const RETRY_REFUSED_TEXT =
     "Its new text or labels aren't ready to build."
@@ -375,6 +394,8 @@ const STEP_WORDS: Record<string, string> = {
     push_final_fixes: 'pushing the run branch',
     write_changeset: 'writing the changeset',
     open_pull_request: 'opening the pull request',
+    mark_already_done: 'noting the work is already done',
+    close_ticket: 'closing the ticket',
 }
 
 /**
@@ -1274,6 +1295,23 @@ const applyKind = ({
                 ticket,
                 because: record.content.because,
             })
+        // Done, not stuck (#484): its work was already on the base branch.
+        case 'ticket_already_done':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    stage: 'done',
+                    step: ALL_STEPS_DONE,
+                    role: null,
+                    open_check: null,
+                    activity: alreadyDoneText({ shas: record.content.shas }),
+                }),
+            })
+        // Its closing changes nothing the board shows.
+        case 'ticket_closed':
+            return state
         case 'ticket_retried':
             return ticketRetried({ state, record })
         // An ignored reply is only a chat row; the engine answered it.
@@ -1576,6 +1614,9 @@ const agentFinished = ({
                 if (card.open_check === 'review') {
                     return { ...done, activity: 'test findings answered' }
                 }
+                if (result.outcome === 'already_done') {
+                    return { ...done, activity: 'already done' }
+                }
                 return result.outcome === 'nothing_new_to_test'
                     ? { ...done, step: 2, activity: 'nothing new to test' }
                     : { ...done, step: 1, activity: 'red check' }

package/board/shared/board-rpc.ts

@@ -117,8 +117,8 @@ export type BoardReadInput = z.input<typeof BoardReadInputSchema>
 export type BoardReadOutput = z.infer<typeof BoardReadOutputSchema>
 
 /**
- * API Response: the Luca version of the loaded board, read from its folder's
- * package.json when it was loaded; `null` when it has none.
+ * API Response: the Luca version of the loaded board, from its version
+ * module (the dev value from the repo's source); `null` from older boards.
  */
 export const BoardVersionOutputSchema = z.object({
     version: z.string().nullable(),

package/engine/agents/role-instructions.ts

@@ -82,8 +82,10 @@ You write the failing tests for ONE ticket, before any code exists.
 - 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 "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.
+- 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. 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 " > ".
+- done_by: empty, unless the outcome is "already_done".
 - finding_responses: empty, unless your prompt gives you ticket review findings (see below).
 - summary, assumptions, run_notes.
 

package/engine/agents/role-prompts.ts

@@ -109,6 +109,23 @@ export const runNotesSection = ({
                   .join('\n'),
           ]
 
+/**
+ * The section a test-writer or implementer gets when the repo has a prepare
+ * command: the engine runs it before its test runs, so tests that need its
+ * outputs may fail when the agent runs them itself.
+ *
+ * @example
+ * prepareSection({ command: 'bun run build:rom' })
+ * // '## This repo has a prepare command\n\n...'
+ */
+export const prepareSection = ({ command }: { command: string }): string =>
+    [
+        '## This repo has a prepare command',
+        `The engine runs \`${command}\` in the worktree before each of its test runs (the red check and the gates), so tests that need its outputs find them up to date. ` +
+            "Never run it yourself. Tests that need its outputs may fail when you run them, and still pass at the engine's checks. " +
+            "If the engine's prepare command fails after your turn, its output comes back to you like a failed check.",
+    ].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/agents/role-results.ts

@@ -126,21 +126,39 @@ const SHARED_FIELDS = {
     run_notes: z.array(z.string()).default([]),
 }
 
+/** A commit on the base branch that did a ticket's work (#484). */
+export const DoneCommitSchema = z.object({
+    sha: z.string().min(1),
+    /** Its subject line, if the agent read it. */
+    title: z.string().default(''),
+})
+
+export type DoneCommit = z.infer<typeof DoneCommitSchema>
+
 /**
  * The test-writer's result. `nothing_new_to_test` is an honest answer for a
  * ticket that changes no behavior; the engine then makes the ticket stuck,
- * with a hint to label it `refactor`. `needs_setup_change` says the tests
- * can't be written without a change to a test setup file (`setup_change`),
- * which only the user may make.
+ * with a hint to label it `refactor`. `already_done` says the ticket's work
+ * is already on the base branch (#484): `done_by` names the commits that did
+ * it and `criteria` the existing tests that cover each criterion; the engine
+ * counts the ticket as done. `needs_setup_change` says the tests can't be
+ * written without a change to a test setup file (`setup_change`), which
+ * only the user may make.
  */
 export const TestWriterResultSchema = z.object({
     outcome: z.enum([
         'tests_written',
         'nothing_new_to_test',
+        'already_done',
         'needs_setup_change',
     ]),
-    /** For each criterion id (AC1, AC2, ...), the tests that check it. */
+    /**
+     * For each criterion id (AC1, AC2, ...), the tests that check it: new
+     * ones, or with `already_done`, the ones already on the base branch.
+     */
     criteria: z.array(CriterionTestsSchema).default([]),
+    /** With `already_done`: the base branch's commits that did the work. */
+    done_by: z.array(DoneCommitSchema).default([]),
     ...SETUP_FIELDS,
     ...SHARED_FIELDS,
     ...FIXER_FIELDS,
@@ -317,8 +335,24 @@ export const parseRoleResult = ({
             error: `The ${role}'s result does not fit its schema:\n${z.prettifyError(parsed.error)}`,
         }
     }
-    // Every reviewer (the ticket reviewer and each lens) gives a verdict.
     const { result } = parsed.data
+    // "Already done" is only an answer with its evidence (#484).
+    if (parsed.data.role === 'test-writer') {
+        const { outcome, done_by, criteria } = parsed.data.result
+        if (outcome === 'already_done' && done_by.length === 0) {
+            return {
+                ok: false,
+                error: 'The test-writer\'s "already_done" names no commit: list in "done_by" the base branch\'s commits that did the work.',
+            }
+        }
+        if (outcome === 'already_done' && criteria.length === 0) {
+            return {
+                ok: false,
+                error: 'The test-writer\'s "already_done" names no tests: list in "criteria" the existing tests that cover each criterion.',
+            }
+        }
+    }
+    // Every reviewer (the ticket reviewer and each lens) gives a verdict.
     if ('verdict' in result) {
         const { verdict, findings } = result
         const expected = findings.some(isBlocking)

package/engine/cli/doctor-command.ts

@@ -24,25 +24,13 @@ import {
     paseoOf,
 } from './computer-adapters-real'
 import { runDoctor } from './doctor'
-import { githubOf, memoryOf } from './repo-adapters-real'
+import { githubOf, memoryOf, repoTop } from './repo-adapters-real'
 
 import type { MemoryClient } from '../memory/memory-client'
-import { runCommand } from '../shell/run-command'
 
 /** `luca doctor`'s usage line. */
 export const DOCTOR_USAGE = 'Usage: luca doctor [--fix]'
 
-/** The top of the git repo `cwd` is in, or `null` outside one. */
-const repoTop = async ({ cwd }: { cwd: string }): Promise<string | null> => {
-    const top = await runCommand({
-        cmd: ['git', 'rev-parse', '--show-toplevel'],
-        cwd,
-    })
-    return top.exit_code === 0 && top.stdout.trim() !== ''
-        ? top.stdout.trim()
-        : null
-}
-
 /** Runs `luca doctor` with the flags after `doctor`; returns the exit code. */
 export const doctorCommand = async ({
     argv,

package/engine/cli/init-command.ts

@@ -9,7 +9,8 @@
  * all of that: runs then have memory off. It puts the board into Paseo from
  * Luca's own install folder and writes its engine and Bun paths, asking
  * before it turns Paseo's plugins on. It installs the planning skills that
- * aren't there yet; `--skip-skills` skips them. See `runInit`.
+ * aren't there yet; `--skip-skills` skips them. Inside a git repo, it then
+ * runs `luca setup` for that repo. See `runInit`.
  *
  * Exits 0 when done, 1 when a step failed, 2 on bad flags.
  */
@@ -29,7 +30,9 @@ import {
 } from './computer-adapters-real'
 import { reason } from './doctor-checks'
 import { runInit, type Launchctl, type SkillsTool } from './init'
+import { githubOf, memoryOf, repoTop } from './repo-adapters-real'
 
+import type { MemoryClient } from '../memory/memory-client'
 import { runCommand } from '../shell/run-command'
 
 /** `luca init`'s flags. */
@@ -103,6 +106,24 @@ const skillsOf = ({ home }: { home: string }): SkillsTool => ({
     },
 })
 
+/**
+ * MuninnDB over MCP, found on first use: init writes Claude Code's `muninn`
+ * entry before its repo part reads it.
+ */
+const lazyMemory = (): MemoryClient => {
+    let client: Promise<MemoryClient> | null = null
+    const found = () => (client ??= memoryOf())
+    return {
+        recall: async (args) => (await found()).recall(args),
+        remember: async (args) => (await found()).remember(args),
+        evolve: async (args) => (await found()).evolve(args),
+        feedback: async (args) => (await found()).feedback(args),
+        close: async () => {
+            if (client !== null) await (await client).close()
+        },
+    }
+}
+
 /** Runs `luca init` with the flags after `init`; returns the exit code. */
 export const initCommand = async ({
     argv,
@@ -115,11 +136,21 @@ export const initCommand = async ({
     }
     const home = homedir()
     const paseo = paseoOf({ client_id: 'luca-init' })
+    const memory = lazyMemory()
     try {
+        const top = await repoTop({ cwd: process.cwd() })
         const end = await runInit({
             home,
             skip_muninndb: argv.includes('--skip-muninndb'),
             skip_skills: argv.includes('--skip-skills'),
+            repo:
+                top === null
+                    ? null
+                    : {
+                          path: top,
+                          github: await githubOf({ cwd: top }),
+                          memory,
+                      },
             muninn: muninnOf({ home }),
             muninn_health: muninnHealth,
             claude: claudeOf({ home }),
@@ -139,5 +170,6 @@ export const initCommand = async ({
         return 1
     } finally {
         await paseo.close()
+        await memory.close().catch(() => undefined)
     }
 }

package/engine/cli/init.ts

@@ -12,6 +12,7 @@ import type {
     Paseo,
 } from './computer-adapters'
 import { computerChecks } from './computer-checks'
+import type { DoctorRepo } from './doctor'
 import {
     formatChecks,
     hasProblem,
@@ -19,11 +20,12 @@ import {
     type DoctorCheck,
 } from './doctor-checks'
 import { ensureMuninnEntry, hideToken } from './muninn-entry'
+import { runSetup } from './setup'
 
 /**
  * `luca init`: sets up this computer for Luca, once, and is safe to run
  * again. It has three parts, each run even when an earlier one failed, and
- * ends with doctor's computer checks.
+ * ends with doctor's computer checks, then sets up the repo it runs in.
  *
  * Memory:
  *
@@ -48,6 +50,10 @@ import { ensureMuninnEntry, hideToken } from './muninn-entry'
  * `mattpocock/skills` with the `skills` tool, skipping any already there.
  * `skip_skills` skips this part.
  *
+ * The repo: inside a git repo, after the computer's checks, it runs `luca
+ * setup` for that repo (see `runSetup`), with the output setup gives on its
+ * own. Outside one, it stops after the computer part.
+ *
  * MuninnDB's CLI, `claude mcp`, `launchctl`, Paseo, the question to the
  * user, the `skills` tool, and the computer's tools are adapters, so tests
  * use fakes. The token is never printed, returned, or thrown.
@@ -258,17 +264,19 @@ const setUpMemory = async ({
 
 /**
  * Runs `luca init` against `home` with these adapters: memory, then the
- * board, then the planning skills, then doctor's computer checks, printed
- * last. Never throws: a failure is logged (token hidden) and ends with
- * `ok: false`, as does a check that is a problem.
+ * board, then the planning skills, then doctor's computer checks, then
+ * `luca setup` in `repo` when there is one. Never throws: a failure is
+ * logged (token hidden) and ends with `ok: false`, as does a check that is
+ * a problem or a setup to-do.
  *
  * @example
- * const end = await runInit({ home: homedir(), skip_muninndb: false, skip_skills: false, muninn, muninn_health, claude, launchctl, paseo, skills, ask, computer, ...(await lucaInstall()), log: console.log })
+ * const end = await runInit({ home: homedir(), skip_muninndb: false, skip_skills: false, repo: null, muninn, muninn_health, claude, launchctl, paseo, skills, ask, computer, ...(await lucaInstall()), log: console.log })
  */
 export const runInit = async ({
     home,
     skip_muninndb,
     skip_skills,
+    repo = null,
     muninn,
     muninn_health,
     claude,
@@ -286,6 +294,8 @@ export const runInit = async ({
     home: string
     skip_muninndb: boolean
     skip_skills: boolean
+    /** The git repo init runs in, set up after the computer; `null` outside one. */
+    repo?: DoctorRepo | null
     muninn: MuninnCli
     muninn_health: MuninnHealth
     claude: ClaudeMcp
@@ -333,12 +343,23 @@ export const runInit = async ({
         paseo,
     })
     for (const line of formatChecks({ checks: doctor })) log(line)
+    const setup =
+        repo === null
+            ? null
+            : await runSetup({
+                  repo: repo.path,
+                  github: repo.github,
+                  memory: repo.memory,
+                  base_branch: repo.base_branch,
+                  log,
+              })
     return {
         ok:
             memory.ok &&
             board.ok &&
             planning.ok &&
-            !hasProblem({ checks: doctor }),
+            !hasProblem({ checks: doctor }) &&
+            (setup?.ok ?? true),
         memory: memory.memory,
         message: planning.message,
         doctor,

package/engine/cli/luca.ts

@@ -3,7 +3,8 @@
  * `luca`: the command people run, with subcommands:
  *
  *   luca init [--skip-muninndb] [--skip-skills]
- *                                  sets up this computer, once
+ *                                  sets up this computer, once, then
+ *                                  the repo in this folder
  *   luca setup [--base <branch>]   gets the repo in this folder ready
  *   luca upgrade [--to <version>]  moves to another version of Luca
  *   luca doctor [--fix]            checks this computer and repo; --fix
@@ -22,7 +23,7 @@ const USAGE = `Usage: luca <command>
 
 Commands:
   init [--skip-muninndb] [--skip-skills]
-                            Set up this computer for Luca (once)
+                            Set up this computer for Luca (once), then the repo you're in
   setup [--base <branch>]   Get the repo in this folder ready for Luca
   upgrade [--to <version>]  Move to the newest Luca on your channel, or to <version>
   doctor [--fix]            Check this computer and repo; --fix fixes what's safe`