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

package/board/server/reduce-board-agents.ts

@@ -0,0 +1,160 @@
+/**
+ * An agent's turn on a ticket or the final review: its start, how it
+ * finished, and how it failed.
+ */
+import type { BoardRecord } from './board-vocabulary'
+import { agentStarted } from './reduce-board-agent-start'
+import { countFindings, failureText, roleWords } from './reduce-board-text'
+import {
+    LEARNER,
+    finalTried,
+    updateTicket,
+    withLearner,
+    withTried,
+} from './reduce-board-update'
+
+import { ALL_STEPS_DONE, type BoardState } from '../shared/board-state'
+
+const agentFinished = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'agent_finished' }>
+}): BoardState => {
+    const { role, result } = record.content
+    return updateTicket({
+        state,
+        number: record.ticket,
+        update: (card) => {
+            const wontFix = result.finding_responses.filter(
+                ({ response }) => response === 'wont_fix'
+            )
+            const done = {
+                ...card,
+                role: null,
+                failed_turn: null,
+                tried: wontFix.reduce(
+                    (tried, { finding_id, reason }) =>
+                        withTried({
+                            tried,
+                            line: `Won't fix ${finding_id}: ${reason}`,
+                        }),
+                    card.tried
+                ),
+            }
+            if (role === 'test-writer') {
+                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' }
+            }
+            if (role === 'implementer') {
+                return result.outcome === 'bad_test'
+                    ? { ...done, activity: 'bad test' }
+                    : { ...done, step: 3, activity: 'checks' }
+            }
+            if (role === 'ticket-reviewer') {
+                const findings = result.findings
+                    ? countFindings({ findings: result.findings })
+                    : card.findings
+                const ruled = result.rulings.reduce(
+                    (tried, { finding_id, ruling, reason }) =>
+                        withTried({
+                            tried,
+                            line:
+                                ruling === 'accepted'
+                                    ? `Declined ${finding_id} accepted: ${reason}`
+                                    : `${finding_id} still stands: ${reason}`,
+                        }),
+                    done.tried
+                )
+                // Approved, it joins the run branch next; else a review fix
+                // round follows.
+                return result.verdict === 'approve'
+                    ? {
+                          ...done,
+                          stage: 'joining',
+                          step: ALL_STEPS_DONE,
+                          findings,
+                          open_check: null,
+                          tried: ruled,
+                          activity: 'approved',
+                      }
+                    : {
+                          ...done,
+                          stage: 'fixing',
+                          findings,
+                          open_check: 'review',
+                          tried: ruled,
+                          activity: 'changes requested',
+                      }
+            }
+            return done
+        },
+    })
+}
+
+/** The record kinds of an agent's turn. */
+export const AGENT_KINDS = [
+    'agent_started',
+    'agent_finished',
+    'agent_failed',
+] as const
+
+type AgentRecord = Extract<BoardRecord, { kind: (typeof AGENT_KINDS)[number] }>
+
+/** Applies one record of AGENT_KINDS to the board. */
+export const applyAgentKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: AgentRecord
+}): BoardState => {
+    const { ticket } = record
+    switch (record.kind) {
+        case 'agent_started':
+            // The learner (#370) has no ticket and is no final review agent.
+            if (record.content.role === LEARNER) {
+                return withLearner({ state, learner: 'learning' })
+            }
+            return agentStarted({ state, record })
+        case 'agent_finished':
+            if (record.content.role === LEARNER) {
+                return withLearner({ state, learner: 'learned' })
+            }
+            return agentFinished({ state, record })
+        case 'agent_failed': {
+            const { role, error, failure } = record.content
+            // A failed learner gets a fresh one; its row says so.
+            if (role === LEARNER) return state
+            // A final review agent (a lens or a fixer) has no ticket.
+            if (ticket === null) {
+                return finalTried({
+                    state,
+                    line: `The ${roleWords({ role })} ${failureText({ failure })}: ${error}`,
+                })
+            }
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    role: null,
+                    failed_turn: role,
+                    activity: `${role} ${failure === 'engine' ? 'could not run' : 'failed'}`,
+                    tried: withTried({
+                        tried: card.tried,
+                        line: `The ${role} ${failureText({ failure })}: ${error}`,
+                    }),
+                }),
+            })
+        }
+    }
+}

package/board/server/reduce-board-counters.ts

@@ -0,0 +1,138 @@
+/**
+ * The run-wide counters: Jev's questions, agent messages, changes to the
+ * shared git folder, and what the memory searched, saved and learned.
+ */
+import type { BoardRecord } from './board-vocabulary'
+import { updateTicket, withLearner } from './reduce-board-update'
+
+import type { BoardState } from '../shared/board-state'
+
+/** The record kinds of the run-wide counters. */
+export const COUNTER_KINDS = [
+    'jev_asked',
+    'jev_answered',
+    'jev_failed',
+    'decision_model_off',
+    'agent_message',
+    'agent_message_delivered',
+    'shared_git_changed',
+    'memory_recalled',
+    'memories_saved',
+    'learning_skipped',
+    'memories_reported',
+] as const
+
+type CounterRecord = Extract<
+    BoardRecord,
+    { kind: (typeof COUNTER_KINDS)[number] }
+>
+
+/** Applies one record of COUNTER_KINDS to the board. */
+export const applyCounterKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: CounterRecord
+}): BoardState => {
+    switch (record.kind) {
+        case 'jev_asked':
+            return {
+                ...state,
+                jev: { ...state.jev, asked: state.jev.asked + 1 },
+            }
+        case 'jev_answered': {
+            const counted = {
+                ...state,
+                jev: { ...state.jev, answered: state.jev.answered + 1 },
+            }
+            const { job, answers } = record.content
+            const { role } = record
+            // An agent's model pick waits on its card for its `agent_started`.
+            if (job !== 'agent_model' || role === null) return counted
+            const pick = answers.model?.value ?? null
+            return updateTicket({
+                state: counted,
+                number: record.ticket,
+                update: (card) => ({
+                    ...card,
+                    model_answer: {
+                        role,
+                        pick: pick === null ? null : String(pick),
+                        confidence: answers.model?.confidence ?? null,
+                    },
+                }),
+            })
+        }
+        case 'jev_failed':
+            return {
+                ...state,
+                jev: { ...state.jev, failed: state.jev.failed + 1 },
+            }
+        // The decision model turning off is only a chat line (#534).
+        case 'decision_model_off':
+            return state
+        case 'agent_message': {
+            const refused = record.content.status === 'refused'
+            return {
+                ...state,
+                messages: {
+                    ...state.messages,
+                    sent: state.messages.sent + (refused ? 0 : 1),
+                    refused: state.messages.refused + (refused ? 1 : 0),
+                },
+            }
+        }
+        case 'agent_message_delivered':
+            return {
+                ...state,
+                messages: {
+                    ...state.messages,
+                    delivered:
+                        state.messages.delivered + record.content.ids.length,
+                },
+            }
+        // Another process's change to the shared `.git`: only counted.
+        case 'shared_git_changed':
+            return {
+                ...state,
+                shared_git_changed: state.shared_git_changed + 1,
+            }
+        case 'memory_recalled': {
+            const { vaults, memories } = record.content
+            const { memory } = state
+            return {
+                ...state,
+                memory: {
+                    ...memory,
+                    searches: memory.searches + 1,
+                    search_errors:
+                        memory.search_errors +
+                        vaults.filter(({ ok }) => !ok).length,
+                    shown: memory.shown + memories.length,
+                },
+            }
+        }
+        case 'memories_saved': {
+            const count = (outcome: string) =>
+                record.content.saves.filter((save) => save.outcome === outcome)
+                    .length
+            const { memory } = state
+            return {
+                ...state,
+                memory: {
+                    ...memory,
+                    added: memory.added + count('added'),
+                    updated: memory.updated + count('updated'),
+                    refused: memory.refused + count('refused'),
+                    failed: memory.failed + count('failed'),
+                },
+            }
+        }
+        case 'learning_skipped':
+            return withLearner({ state, learner: 'skipped' })
+        // The listing on the spec issue is only a chat row.
+        case 'memories_reported':
+            return state
+    }
+}

package/board/server/reduce-board-create.ts

@@ -0,0 +1,148 @@
+/**
+ * A new board's starting shapes: the board before any record, and a ticket's
+ * card when its snapshot first arrives.
+ */
+import {
+    DEFAULT_CONFIDENCE_BAR,
+    DEFAULT_RUN_BUDGET_TOKENS,
+    LENS_NAMES,
+    NO_MEMORY,
+    USAGE_LABEL,
+    type BoardState,
+    type FindingCounts,
+    type LensCard,
+    type TicketCard,
+} from '../shared/board-state'
+
+const noFindings = (): FindingCounts => ({ blocker: 0, should_fix: 0, nit: 0 })
+
+const freshLenses = (): LensCard[] =>
+    LENS_NAMES.map((name) => ({
+        name,
+        state: 'waiting',
+        findings: noFindings(),
+    }))
+
+/**
+ * A new run's board, before any record.
+ *
+ * @example
+ * const state = createBoardState({
+ *     run_id: 'luca-20260923-123042-ab12',
+ *     spec_number: 10,
+ *     demo: false,
+ *     started_at: '2026-09-23T12:30:42.000Z',
+ *     log_path: '/tmp/luca-20260923-123042-ab12.log',
+ * })
+ */
+export const createBoardState = ({
+    run_id,
+    spec_number,
+    demo,
+    started_at,
+    log_path,
+}: {
+    run_id: string
+    spec_number: number | null
+    demo: boolean
+    started_at: string
+    log_path: string | null
+}): BoardState => ({
+    run: {
+        run_id,
+        spec_number,
+        spec_title: null,
+        demo,
+        branch: null,
+        phase: 'starting',
+        status: 'starting',
+        pr_url: null,
+        pr_number: null,
+        refusal: [],
+        started_at,
+        last_time: null,
+        engine_ended: null,
+        stopped: null,
+        log_path,
+        started_on: null,
+        version_note: null,
+        spec_author: null,
+        spec_repo: null,
+    },
+    for_a_person: [],
+    usage: null,
+    usage_label: USAGE_LABEL,
+    run_tokens: 0,
+    run_budget_tokens: DEFAULT_RUN_BUDGET_TOKENS,
+    run_budget_each: DEFAULT_RUN_BUDGET_TOKENS,
+    run_stuck_reason: null,
+    confidence_bar: DEFAULT_CONFIDENCE_BAR,
+    limit_wait: null,
+    usage_line_wait: null,
+    repo_wait: null,
+    run_plan_used: [],
+    needs_you: [],
+    tickets: [],
+    final_review: {
+        state: 'waiting',
+        active: false,
+        round: 0,
+        fix_round: 0,
+        lenses: freshLenses(),
+        tried: [],
+    },
+    jev: { asked: 0, answered: 0, failed: 0 },
+    messages: { sent: 0, refused: 0, delivered: 0 },
+    memory: NO_MEMORY,
+    shared_git_changed: 0,
+    run_steps: [],
+    live_agents: [],
+    current_step: null,
+    feed: [],
+    live_written_at: null,
+    engine_gone: false,
+    event_count: 0,
+    latest: null,
+    latest_at: null,
+})
+
+export const newTicket = ({
+    number,
+    title,
+    refactor,
+    blockers,
+}: {
+    number: number
+    title: string
+    refactor: boolean
+    blockers: number[]
+}): TicketCard => ({
+    number,
+    title,
+    refactor,
+    blockers,
+    started: false,
+    stage: 'building',
+    step: -1,
+    activity: 'queued',
+    role: null,
+    model: null,
+    model_answer: null,
+    model_answers: {},
+    current_step: null,
+    wait: null,
+    fix_round: 0,
+    review_round: 0,
+    review_fix_round: 0,
+    open_check: null,
+    failed_turn: null,
+    tests: null,
+    baseline_tests: null,
+    findings: null,
+    tokens: 0,
+    agent_tokens: {},
+    tried: [],
+    plan_used: [],
+    live: null,
+    slot_wait: null,
+})

package/board/server/reduce-board-final-review.ts

@@ -0,0 +1,174 @@
+/**
+ * The final review: its rounds, its lenses, the fix rounds, and how it ends
+ * (passed, shipped by a person, or stuck).
+ */
+import type { BoardRecord } from './board-vocabulary'
+import { finalReasonText } from './reduce-board-reasons'
+import { clip } from './reduce-board-text'
+import {
+    DETAIL_MAX,
+    addNeedsYou,
+    resolveNeedsYou,
+    updateFinal,
+    withTried,
+} from './reduce-board-update'
+
+import { LOOP_CAP, type BoardState, type LensCard } from '../shared/board-state'
+import { FINAL_KEY, allowedReplies } from '../shared/reply-actions'
+
+const updateLens = ({
+    state,
+    lens,
+    update,
+}: {
+    state: BoardState
+    lens: string
+    update: (card: LensCard) => LensCard
+}): BoardState =>
+    updateFinal({
+        state,
+        update: (review) => ({
+            ...review,
+            lenses: review.lenses.map((card) =>
+                card.name === lens ? update(card) : card
+            ),
+        }),
+    })
+
+/** The record kinds of the final review. */
+export const FINAL_REVIEW_KINDS = [
+    'final_review_started',
+    'lens_started',
+    'lens_finished',
+    'final_review_fixing',
+    'final_review_stuck',
+    'final_review_shipped',
+    'final_review_passed',
+] as const
+
+type FinalReviewRecord = Extract<
+    BoardRecord,
+    { kind: (typeof FINAL_REVIEW_KINDS)[number] }
+>
+
+/** Applies one record of FINAL_REVIEW_KINDS to the board. */
+export const applyFinalReviewKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: FinalReviewRecord
+}): BoardState => {
+    switch (record.kind) {
+        case 'final_review_started':
+            return {
+                ...updateFinal({
+                    state,
+                    update: (review) => ({
+                        ...review,
+                        state: 'reviewing',
+                        round: review.round + 1,
+                        lenses: review.lenses.map((lens) =>
+                            lens.state === 'clean'
+                                ? lens
+                                : { ...lens, state: 'waiting' }
+                        ),
+                    }),
+                }),
+                run: { ...state.run, phase: 'final_review' },
+            }
+        case 'lens_started':
+            return updateLens({
+                state,
+                lens: record.content.lens,
+                update: (lens) => ({ ...lens, state: 'reviewing' }),
+            })
+        case 'lens_finished': {
+            const { findings } = record.content
+            const counts = {
+                blocker: findings.blocker,
+                should_fix: findings.should_fix,
+                nit: findings.nit,
+            }
+            return updateLens({
+                state,
+                lens: record.content.lens,
+                update: (lens) => ({
+                    ...lens,
+                    findings: counts,
+                    state:
+                        counts.blocker + counts.should_fix > 0
+                            ? 'fixing'
+                            : 'clean',
+                }),
+            })
+        }
+        case 'final_review_fixing':
+            return updateFinal({
+                state,
+                update: (review) => ({
+                    ...review,
+                    state: 'fixing',
+                    fix_round: record.content.round,
+                    tried: withTried({
+                        tried: review.tried,
+                        // Every lens finished clean: only failed slow tests
+                        // open a fix round then (#563).
+                        line: `Fix round ${record.content.round}/${LOOP_CAP} on ${
+                            review.lenses.length > 0 &&
+                            review.lenses.every(
+                                (lens) => lens.state === 'clean'
+                            )
+                                ? 'the failed slow tests'
+                                : "the lenses' findings"
+                        }`,
+                    }),
+                }),
+            })
+        case 'final_review_stuck':
+            return addNeedsYou({
+                state: updateFinal({
+                    state,
+                    update: (review) => ({ ...review, state: 'stuck' }),
+                }),
+                item: {
+                    key: FINAL_KEY,
+                    ticket: null,
+                    subject: 'The final review is stuck',
+                    reason: finalReasonText({ reason: record.content.reason }),
+                    detail: clip({
+                        text: record.content.detail,
+                        max: DETAIL_MAX,
+                    }),
+                    tried: state.final_review.tried,
+                    replies: allowedReplies({ key: FINAL_KEY, ticket: null }),
+                    since: record.time,
+                },
+            })
+        // A `ship` reply to the stuck final review, as the engine journals
+        // it: the same as the reply itself.
+        case 'final_review_shipped':
+            return resolveNeedsYou({
+                state: updateFinal({
+                    state,
+                    update: (review) => ({ ...review, state: 'passed' }),
+                }),
+                key: FINAL_KEY,
+            })
+        case 'final_review_passed':
+            return resolveNeedsYou({
+                state: updateFinal({
+                    state,
+                    update: (review) => ({
+                        ...review,
+                        state: 'passed',
+                        lenses: review.lenses.map((lens) => ({
+                            ...lens,
+                            state: 'clean',
+                        })),
+                    }),
+                }),
+                key: FINAL_KEY,
+            })
+    }
+}