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

package/engine/cli/decision-model-setup.ts

@@ -0,0 +1,70 @@
+/**
+ * The decision model a real run asks (#534): what its setup holds
+ * (`DecisionModelSetup`), and opening it for a run (`openDecisionModel`), off
+ * with a journaled reason when there are no credentials.
+ */
+import { decisionModelOf } from '../config/engine-config'
+import { createClefClient, type DecisionModelFetch } from '../jev/clef-client'
+import {
+    noCredentialsText,
+    type DecisionModelCredentials,
+} from '../jev/decision-model-credentials'
+import { DEFAULT_DECISION_MODEL } from '../jev/jev-schemas'
+import type { JevShadow } from '../jev/jev-shadow'
+import type { Journal } from '../journal/journal'
+import { replayRun } from '../journal/replay'
+
+/**
+ * What a real run needs to ask the decision model (#534): its Cloudflare
+ * credentials (`loadDecisionModelCredentials`), and for tests a fake
+ * `fetch` and a shorter timeout. The model comes from the run's config.
+ */
+export type DecisionModelSetup = {
+    credentials: DecisionModelCredentials
+    /** Defaults to the global `fetch`. */
+    fetch?: DecisionModelFetch
+    /** Defaults to `DEFAULT_JEV_TIMEOUT_MS`. */
+    timeout_ms?: number
+}
+
+/**
+ * The decision model for this run, from `setup` and the model in the run's
+ * own config (its `run_started`, so a resume keeps it). With no credentials
+ * it is off for the run: one `decision_model_off { reason: 'no_credentials' }`
+ * record and one line naming Luca's env file and the keys to add, and no
+ * shadow, so nothing is ever asked. Never logs the token.
+ */
+export const openDecisionModel = ({
+    setup,
+    journal,
+    log,
+}: {
+    setup: DecisionModelSetup | undefined
+    journal: Journal
+    log: (line: string) => void
+}): JevShadow | undefined => {
+    if (setup === undefined) return undefined
+    const { config } = replayRun({ records: journal.read() })
+    const model =
+        config === null ? DEFAULT_DECISION_MODEL : decisionModelOf({ config })
+    const { credentials } = setup
+    if (!credentials.ok) {
+        const detail = noCredentialsText(credentials)
+        journal.append({
+            kind: 'decision_model_off',
+            ticket: null,
+            role: null,
+            content: { model, reason: 'no_credentials', detail },
+        })
+        log(`[luca-run] decision model off: ${detail}`)
+        return undefined
+    }
+    log(`[luca-run] decision model: Clef (${model}), in shadow mode`)
+    return {
+        client: createClefClient({ credentials, model, fetch: setup.fetch }),
+        timeout_ms: setup.timeout_ms,
+        log: (line) => {
+            log(`[luca-run] ${line}`)
+        },
+    }
+}

package/engine/cli/doctor-command.ts

@@ -65,6 +65,7 @@ export const doctorCommand = async ({
                           memory,
                       },
             tmp_dir: '/tmp',
+            env: process.env,
             log: (line) => {
                 console.log(line)
             },

package/engine/cli/doctor.ts

@@ -14,6 +14,7 @@ import {
     reason,
     type DoctorCheck,
 } from './doctor-checks'
+import { installLucaSkills } from './luca-skills'
 import { ensureMuninnEntry, hideToken } from './muninn-entry'
 import { repoChecks, runSetup, type SetupGitHub } from './setup'
 import {
@@ -24,6 +25,7 @@ import {
 } from './v13-leftovers'
 
 import type { V13Manifest } from '../doctor/v13-manifest'
+import type { Env } from '../jev/decision-model-credentials'
 import type { MemoryClient } from '../memory/memory-client'
 import { runCommand } from '../shell/run-command'
 
@@ -31,13 +33,14 @@ import { runCommand } from '../shell/run-command'
  * `luca doctor [--fix]`: checks this computer, the repo when run inside
  * one, and what old Luca v13 left behind, and prints each check as OK, or
  * the problem and its exact fix. It exits 1 when any check is a problem;
- * warnings (memory off, planning-skill drift) don't fail it. When it finds
+ * warnings (memory off, the decision model off, planning-skill drift)
+ * don't fail it. When it finds
  * v13 leftovers, it links the migration guide.
  *
  * `--fix` fixes what's safe, without asking: it cleans up v13's leftovers
  * first (see `fixV13`), starts MuninnDB and repairs Claude Code's `muninn`
  * entry (as `luca init` does), reloads the board and rewrites its paths,
- * and runs `luca setup` in a repo. It never deletes and never commits: it
+ * installs Luca's own skills again, and runs `luca setup` in a repo. It never deletes and never commits: it
  * lists the repo files to commit. Installs, sign-ins, Paseo's plugin
  * consent, and other `luca` copies are only reported.
  */
@@ -126,8 +129,10 @@ const tryFix = async ({
 
 /** Fixes what's safe on this computer, guided by the checks. */
 const fixComputer = async ({
+    home,
     checks,
     board_dir,
+    skills_dir,
     engine_path,
     bun_path,
     muninn,
@@ -136,8 +141,10 @@ const fixComputer = async ({
     paseo,
     log,
 }: {
+    home: string
     checks: DoctorCheck[]
     board_dir: string
+    skills_dir: string
     engine_path: string
     bun_path: string
     muninn: MuninnCli
@@ -190,6 +197,9 @@ const fixComputer = async ({
             log,
         })
     }
+    if (statusOf({ checks, name: 'luca_skills' }) === 'problem') {
+        await installLucaSkills({ home, skills_dir, prefix: PREFIX, log })
+    }
 }
 
 /** Runs `luca setup` in the repo. */
@@ -243,7 +253,7 @@ const listToCommit = async ({
  * then checks again. Never throws, and never shows the token.
  *
  * @example
- * const end = await runDoctor({ home: homedir(), fix: false, luca_version, board_dir, engine_path, bun_path, computer, muninn, muninn_health, claude, paseo, repo: null, tmp_dir: '/tmp', log: console.log })
+ * const end = await runDoctor({ home: homedir(), fix: false, luca_version, board_dir, skills_dir, engine_path, bun_path, computer, muninn, muninn_health, claude, paseo, repo: null, tmp_dir: '/tmp', log: console.log })
  * process.exit(end.exit_code)
  */
 export const runDoctor = async ({
@@ -251,6 +261,7 @@ export const runDoctor = async ({
     fix,
     luca_version,
     board_dir,
+    skills_dir,
     engine_path,
     bun_path,
     computer,
@@ -261,6 +272,7 @@ export const runDoctor = async ({
     repo,
     tmp_dir,
     v13_manifest,
+    env,
     log,
 }: LucaInstall & {
     home: string
@@ -276,6 +288,8 @@ export const runDoctor = async ({
     tmp_dir: string
     /** The v13 fingerprint list; defaults to the committed one. */
     v13_manifest?: V13Manifest
+    /** The process env, for the decision model's check. Left out, none. */
+    env?: Env
     log: (line: string) => void
 }): Promise<DoctorEnd> => {
     const check = async (): Promise<DoctorCheck[]> => [
@@ -283,6 +297,7 @@ export const runDoctor = async ({
             home,
             luca_version,
             board_dir,
+            skills_dir,
             engine_path,
             bun_path,
             computer,
@@ -290,6 +305,7 @@ export const runDoctor = async ({
             muninn_health,
             claude,
             paseo,
+            env,
         })),
         ...(repo === null
             ? []
@@ -331,8 +347,10 @@ export const runDoctor = async ({
             })
         }
         await fixComputer({
+            home,
             checks,
             board_dir,
+            skills_dir,
             engine_path,
             bun_path,
             muninn,

package/engine/cli/going-runs.ts

@@ -3,7 +3,12 @@ import { join } from 'node:path'
 
 import { z } from 'zod'
 
-import { readRunStart, unfinishedRuns } from './run-modes'
+import {
+    BOARD_MAX_AUTO_RESTARTS,
+    liveRunIds,
+    type ListProcesses,
+} from './live-runs'
+import { readRunStart, restartableRuns, type RestartableRun } from './run-modes'
 
 import { boardStateDir } from '../board/board-state-dir'
 import { decide } from '../core/decide'
@@ -12,7 +17,9 @@ import { createJournal, runJournalPath } from '../journal/journal'
 
 /**
  * The runs that are going, for the commands that must not change Luca under
- * them (`luca upgrade`).
+ * them (`luca upgrade`) and for a new run's repo wait (#615), and the
+ * unfinished runs whose engine is gone, which can go on later on any
+ * version.
  */
 
 /**
@@ -27,13 +34,37 @@ export const defaultRegistryPath = ({
     home_dir: string
 }): string => join(boardStateDir({ env, home_dir }), 'runs.json')
 
-/** A run that is not over, by spec and repo. */
+/**
+ * Why a run counts as going, or `engine_gone` for an unfinished run nothing
+ * runs now:
+ *
+ * - `engine_running`: `ps` shows its engine.
+ * - `board_will_restart`: its engine is gone, but the board plugin will
+ *   restart it (its registry entry hasn't ended and has restarts left).
+ * - `not_checked`: `ps` failed, so it counts as going to be safe.
+ * - `engine_gone`: not running, and the board won't restart it.
+ */
+export type RunState =
+    | 'engine_running'
+    | 'board_will_restart'
+    | 'not_checked'
+    | 'engine_gone'
+
+/** An unfinished run, by spec and repo. */
 export type GoingRun = {
     run_id: string
     /** `null` for a demo run. */
     spec: number | null
     /** `null` in journals from before the repo was kept. */
     repo: string | null
+    /** Whether the board plugin started it (it is in the board's registry). */
+    board: boolean
+    state: RunState
+    /**
+     * When its `run_started` was journaled; `null` for a registry entry
+     * with no journal yet.
+     */
+    started_at: string | null
 }
 
 const RegistrySchema = z.object({
@@ -42,11 +73,15 @@ const RegistrySchema = z.object({
             run_id: z.string(),
             repo: z.string(),
             spec: z.number().nullable(),
+            demo: z.boolean().default(false),
             ended: z.unknown().nullable().default(null),
+            restarts: z.number().default(0),
         })
     ),
 })
 
+type RegistryEntry = z.infer<typeof RegistrySchema>['runs'][number]
+
 /** Whether run `run_id` has a journal in `runs_dir` whose run is over. */
 const journalIsOver = ({
     runs_dir,
@@ -65,35 +100,16 @@ const journalIsOver = ({
     }
 }
 
-/**
- * The runs that are going: every journal in `runs_dir` whose run is not
- * over (limit waits and stuck runs waiting for a reply included), and every
- * run in the board registry at `registry_path` that has not ended and whose
- * journal, if any, is not over. An error when the registry can't be read.
- *
- * @example
- * const going = await goingRuns({ runs_dir: defaultRunsDir(), registry_path })
- * if (going.ok) console.log(going.runs.map(({ spec }) => spec))
- */
-export const goingRuns = async ({
-    runs_dir,
+/** The board registry's runs; none when it has no file yet. */
+const readRegistry = async ({
     registry_path,
 }: {
-    runs_dir: string
     registry_path: string
-}): Promise<{ ok: true; runs: GoingRun[] } | { ok: false; error: string }> => {
-    const runs: GoingRun[] = unfinishedRuns({ runs_dir }).map((run_id) => {
-        const start = readRunStart({ runs_dir, run_id })
-        return start.ok
-            ? {
-                  run_id,
-                  spec: start.start.spec_number,
-                  repo: start.start.repo,
-              }
-            : { run_id, spec: null, repo: null }
-    })
+}): Promise<
+    { ok: true; entries: RegistryEntry[] } | { ok: false; error: string }
+> => {
     const file = Bun.file(registry_path)
-    if (!(await file.exists())) return { ok: true, runs }
+    if (!(await file.exists())) return { ok: true, entries: [] }
     let parsed
     try {
         parsed = RegistrySchema.safeParse(JSON.parse(await file.text()))
@@ -109,22 +125,162 @@ export const goingRuns = async ({
             error: `The board's run registry ${registry_path} is not valid: ${z.prettifyError(parsed.error)}`,
         }
     }
-    const known = new Set(runs.map(({ run_id }) => run_id))
-    for (const entry of parsed.data.runs) {
+    return { ok: true, entries: parsed.data.runs }
+}
+
+/** An unfinished run before its engine is checked. */
+type Candidate = {
+    run_id: string
+    spec: number | null
+    repo: string | null
+    started_at: string | null
+    /** What its journal says (`null` with no journal to go on from). */
+    reason: RestartableRun['reason'] | null
+    entry: RegistryEntry | null
+}
+
+/**
+ * Whether the board plugin will restart a run whose engine is gone: the
+ * plugin started it, its entry hasn't ended, it isn't a demo, it has
+ * restarts left, and its journal can go on. Pure.
+ */
+const boardWillRestart = ({ candidate }: { candidate: Candidate }) =>
+    candidate.entry !== null &&
+    candidate.entry.ended === null &&
+    !candidate.entry.demo &&
+    candidate.entry.restarts < BOARD_MAX_AUTO_RESTARTS &&
+    candidate.reason === 'resumable'
+
+/**
+ * The unfinished runs: every journal in `runs_dir` whose run is not over
+ * (limit waits and stuck runs waiting for a reply included), and every run
+ * in the board registry at `registry_path` that has not ended and whose
+ * journal, if any, is not over. Each is then checked with `ps` (see
+ * `liveRunIds`):
+ *
+ * - `runs`: the going ones. A run is going when its engine is running, or
+ *   when its engine is gone but the board will restart it. When `ps` fails,
+ *   every unfinished run is going, and `ps_error` says why.
+ * - `stopped`: the rest that can go on from their journal (a crash or a
+ *   launcher stop). Nothing runs them now, so they can wait for a resume on
+ *   any version. A billing stop never goes on, so it is in neither list.
+ *
+ * An error when the registry can't be read.
+ *
+ * @example
+ * const going = await goingRuns({ runs_dir: defaultRunsDir(), registry_path, list_processes: listProcesses })
+ * if (going.ok) console.log(going.runs.map(({ spec }) => spec))
+ */
+export const goingRuns = async ({
+    runs_dir,
+    registry_path,
+    list_processes,
+}: {
+    runs_dir: string
+    registry_path: string
+    list_processes: ListProcesses
+}): Promise<
+    | {
+          ok: true
+          runs: GoingRun[]
+          stopped: GoingRun[]
+          /** Why `ps` failed, or `null` when it worked. */
+          ps_error: string | null
+      }
+    | { ok: false; error: string }
+> => {
+    const registry = await readRegistry({ registry_path })
+    if (!registry.ok) return registry
+    const entries = new Map(
+        registry.entries.map((entry) => [entry.run_id, entry])
+    )
+
+    const candidates: Candidate[] = restartableRuns({ runs_dir }).map(
+        ({ run_id, reason }) => {
+            const start = readRunStart({ runs_dir, run_id })
+            const entry = entries.get(run_id) ?? null
+            return {
+                run_id,
+                spec: start.ok
+                    ? start.start.spec_number
+                    : (entry?.spec ?? null),
+                repo: start.ok ? start.start.repo : (entry?.repo ?? null),
+                started_at: start.ok ? start.start.started_at : null,
+                reason,
+                entry,
+            }
+        }
+    )
+    const known = new Set(candidates.map(({ run_id }) => run_id))
+    for (const entry of registry.entries) {
         if (entry.ended !== null || known.has(entry.run_id)) continue
         if (journalIsOver({ runs_dir, run_id: entry.run_id })) continue
         known.add(entry.run_id)
-        runs.push({ run_id: entry.run_id, spec: entry.spec, repo: entry.repo })
+        candidates.push({
+            run_id: entry.run_id,
+            spec: entry.spec,
+            repo: entry.repo,
+            started_at: null,
+            reason: null,
+            entry,
+        })
+    }
+
+    const runOf = ({
+        candidate,
+        state,
+    }: {
+        candidate: Candidate
+        state: RunState
+    }): GoingRun => ({
+        run_id: candidate.run_id,
+        spec: candidate.spec,
+        repo: candidate.repo,
+        board: candidate.entry !== null,
+        state,
+        started_at: candidate.started_at,
+    })
+
+    let live: Set<string>
+    try {
+        live = liveRunIds({ command_lines: await list_processes() })
+    } catch (error) {
+        // Never guess: an upgrade under a live engine is far worse than a
+        // refused one.
+        return {
+            ok: true,
+            runs: candidates.map((candidate) =>
+                runOf({ candidate, state: 'not_checked' })
+            ),
+            stopped: [],
+            ps_error: error instanceof Error ? error.message : String(error),
+        }
+    }
+
+    const runs: GoingRun[] = []
+    const stopped: GoingRun[] = []
+    for (const candidate of candidates) {
+        if (live.has(candidate.run_id)) {
+            runs.push(runOf({ candidate, state: 'engine_running' }))
+        } else if (boardWillRestart({ candidate })) {
+            runs.push(runOf({ candidate, state: 'board_will_restart' }))
+        } else if (
+            candidate.reason === 'resumable' ||
+            candidate.reason === 'launcher_stopped'
+        ) {
+            stopped.push(runOf({ candidate, state: 'engine_gone' }))
+        }
     }
-    return { ok: true, runs }
+    return { ok: true, runs, stopped, ps_error: null }
 }
 
 /**
- * One going run as a list line. Pure.
+ * One unfinished run as a list line, with why it is going when its engine
+ * isn't running. Pure.
  *
  * @example
- * describeRun({ run_id: 'r1', spec: 5, repo: '/code/app' })
+ * describeRun({ run_id: 'r1', spec: 5, repo: '/code/app', board: false, state: 'engine_running', started_at: null })
  * // '- spec #5 in /code/app (run r1)'
  */
-export const describeRun = ({ run_id, spec, repo }: GoingRun): string =>
-    `- ${spec === null ? 'a demo' : `spec #${spec}`} in ${repo ?? 'an unknown repo'} (run ${run_id})`
+export const describeRun = ({ run_id, spec, repo, state }: GoingRun): string =>
+    `- ${spec === null ? 'a demo' : `spec #${spec}`} in ${repo ?? 'an unknown repo'} (run ${run_id})${state === 'board_will_restart' ? ': its engine is gone, and the board will restart it' : ''}`

package/engine/cli/init-command.ts

@@ -160,6 +160,7 @@ export const initCommand = async ({
             ask: askInTerminal,
             computer: computerOf({ home }),
             ...(await lucaInstall()),
+            env: process.env,
             log: (line) => {
                 console.log(line)
             },

package/engine/cli/init.ts

@@ -19,9 +19,12 @@ import {
     reason,
     type DoctorCheck,
 } from './doctor-checks'
+import { installLucaSkills } from './luca-skills'
 import { ensureMuninnEntry, hideToken } from './muninn-entry'
 import { runSetup } from './setup'
 
+import type { Env } from '../jev/decision-model-credentials'
+
 /**
  * `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
@@ -50,6 +53,11 @@ import { runSetup } from './setup'
  * `mattpocock/skills` with the `skills` tool, skipping any already there.
  * `skip_skills` skips this part.
  *
+ * Luca's own skills: copies them (`/luca-unstick`, `/luca-retro`) from Luca's
+ * install folder into `~/.claude/skills`, over Luca's earlier copy (see
+ * `installLucaSkills`). They are part of Luca, so `skip_skills` doesn't
+ * skip them.
+ *
  * 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.
@@ -264,7 +272,8 @@ const setUpMemory = async ({
 
 /**
  * Runs `luca init` against `home` with these adapters: memory, then the
- * board, then the planning skills, then doctor's computer checks, then
+ * board, then the planning skills, then Luca's own 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.
@@ -287,8 +296,10 @@ export const runInit = async ({
     computer,
     luca_version,
     board_dir,
+    skills_dir,
     engine_path,
     bun_path,
+    env,
     log,
 }: LucaInstall & {
     home: string
@@ -304,6 +315,8 @@ export const runInit = async ({
     skills: SkillsTool
     ask: Ask
     computer: Computer
+    /** The process env, for the decision model's check. Left out, none. */
+    env?: Env
     log: (line: string) => void
 }): Promise<InitEnd> => {
     const memory = await setUpMemory({
@@ -330,10 +343,17 @@ export const runInit = async ({
     } else {
         planning = await setUpSkills({ skills, log })
     }
+    const own_skills = await installLucaSkills({
+        home,
+        skills_dir,
+        prefix: '[luca init]',
+        log,
+    })
     const doctor = await computerChecks({
         home,
         luca_version,
         board_dir,
+        skills_dir,
         engine_path,
         bun_path,
         computer,
@@ -341,6 +361,7 @@ export const runInit = async ({
         muninn_health,
         claude,
         paseo,
+        env,
     })
     for (const line of formatChecks({ checks: doctor })) log(line)
     const setup =
@@ -358,6 +379,7 @@ export const runInit = async ({
             memory.ok &&
             board.ok &&
             planning.ok &&
+            own_skills.ok &&
             !hasProblem({ checks: doctor }) &&
             (setup?.ok ?? true),
         memory: memory.memory,

package/engine/cli/live-runs.ts

@@ -0,0 +1,73 @@
+/**
+ * Which runs have a live engine process, from `ps`. The board plugin checks
+ * the same way (`liveRunIds` and `listProcesses` in
+ * `packages/board/server/`). The plugin never imports the engine and the
+ * engine never imports the plugin, so this is a copy: change both together.
+ */
+
+/** Every running process's full command line. Rejects when it can't list them. */
+export type ListProcesses = () => Promise<string[]>
+
+/**
+ * How many times the board plugin restarts one run by itself before it gives
+ * up. A copy of the board's `MAX_AUTO_RESTARTS`: change both together.
+ */
+export const BOARD_MAX_AUTO_RESTARTS = 3
+
+/**
+ * The run ids that have a live engine, from every process's command line: a
+ * run is live when a command line has `--run-id <id>` or `--resume <id>` (or
+ * `--run-id=<id>`), as whole words, so one id never matches inside another.
+ * Pure.
+ *
+ * @example
+ * liveRunIds({ command_lines: ['bun luca-run.ts --resume r1 --repo /x'] }) // Set { 'r1' }
+ */
+export const liveRunIds = ({
+    command_lines,
+}: {
+    command_lines: string[]
+}): Set<string> => {
+    const live = new Set<string>()
+    for (const line of command_lines) {
+        const tokens = line.split(/\s+/)
+        tokens.forEach((token, index) => {
+            const next = tokens[index + 1]
+            if ((token === '--run-id' || token === '--resume') && next) {
+                live.add(next)
+            }
+            const joined = /^--(?:run-id|resume)=(.+)$/.exec(token)
+            if (joined?.[1]) live.add(joined[1])
+        })
+    }
+    return live
+}
+
+/**
+ * Every running process's full command line, from `ps -axww -o command=`
+ * (`-ww` never cuts a line). Rejects when `ps` fails, so a caller can take
+ * the safe side rather than guess.
+ *
+ * @example
+ * const live = liveRunIds({ command_lines: await listProcesses() })
+ */
+export const listProcesses: ListProcesses = async () => {
+    const child = Bun.spawn(['ps', '-axww', '-o', 'command='], {
+        stdout: 'pipe',
+        stderr: 'pipe',
+    })
+    const [stdout, stderr, exit_code] = await Promise.all([
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+        child.exited,
+    ])
+    if (exit_code !== 0) {
+        throw new Error(
+            `ps exited with ${exit_code}: ${stderr.trim().slice(0, 300)}`
+        )
+    }
+    return stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '')
+}