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

package/engine/core/execute-repo-wait.ts

@@ -0,0 +1,129 @@
+/**
+ * Carries out the repo wait (#615): a run started while an earlier run on
+ * the same repo is going waits for it, before intake.
+ */
+import { basename, dirname } from 'node:path'
+
+import {
+    earlierRuns,
+    REPO_WAIT_NAP_MS,
+    type RepoWaitAction,
+    type RepoWaitRun,
+} from './decide-repo-wait'
+import { repoBusyDetail, repoWaitComment } from './repo-wait-text'
+
+import type { goingRuns } from '../cli/going-runs'
+import type { Journal } from '../journal/journal'
+import type { EngineClock } from '../limits/limit-wait'
+import { postCommentOnce, type CommentStep } from '../tracker/post-comment-once'
+import type { Tracker } from '../tracker/tracker'
+
+/** Lists the unfinished runs on this computer, as `goingRuns` does. */
+export type GoingRunsReader = () => ReturnType<typeof goingRuns>
+
+/**
+ * The earlier runs going on this run's repo (see `earlierRuns`), by
+ * `going_runs`. None when the board's registry can't be read: the wait
+ * never holds a run up on a list it can't trust. `ps_error` says why `ps`
+ * failed, when it did: then every unfinished run counts as going (#624).
+ */
+export const readEarlierRuns = async ({
+    going_runs,
+    journal,
+}: {
+    going_runs: GoingRunsReader
+    journal: Journal
+}): Promise<{ runs: RepoWaitRun[]; ps_error: string | null }> => {
+    const listing = await going_runs()
+    if (!listing.ok) return { runs: [], ps_error: null }
+    return {
+        runs: earlierRuns({
+            runs: listing.runs,
+            run_id: basename(dirname(journal.file)),
+            records: journal.read(),
+        }),
+        ps_error: listing.ps_error,
+    }
+}
+
+/**
+ * Carries out a repo wait. Its start tells the spec issue once which runs
+ * it waits for, then is journaled. The wait reads the going runs, then
+ * naps by `clock` and reads them again, until no earlier run on the repo is
+ * going (`repo_wait_ended`) or `until` comes (the run is stuck as
+ * `repo_busy`). Without `going_runs`, none is going. A `ps` that fails is
+ * journaled once (`repo_wait_ps_failed`), and the wait goes on.
+ */
+export const executeRepoWaitAction = async ({
+    action,
+    journal,
+    tracker,
+    clock,
+    going_runs,
+    step,
+}: {
+    action: RepoWaitAction
+    journal: Journal
+    tracker: Tracker
+    clock: EngineClock
+    going_runs: GoingRunsReader | undefined
+    step: CommentStep
+}): Promise<void> => {
+    if (action.type === 'start_repo_wait') {
+        await postCommentOnce({
+            tracker,
+            number: action.spec_number,
+            body: repoWaitComment({ runs: action.runs }),
+            step,
+            n: 0,
+        })
+        journal.append({
+            kind: 'repo_wait_started',
+            ticket: null,
+            role: null,
+            content: { runs: action.runs },
+        })
+        return
+    }
+    const end = Date.parse(action.until)
+    let ps_error: string | null = null
+    for (;;) {
+        const read =
+            going_runs === undefined
+                ? { runs: [], ps_error: null }
+                : await readEarlierRuns({ going_runs, journal })
+        const { runs } = read
+        if (read.ps_error !== null && ps_error === null) {
+            ps_error = read.ps_error
+            journal.append({
+                kind: 'repo_wait_ps_failed',
+                ticket: null,
+                role: null,
+                content: { error: ps_error },
+            })
+        }
+        if (runs.length === 0) {
+            journal.append({
+                kind: 'repo_wait_ended',
+                ticket: null,
+                role: null,
+                content: {},
+            })
+            return
+        }
+        const left = end - clock.now()
+        if (left <= 0) {
+            journal.append({
+                kind: 'run_stuck',
+                ticket: null,
+                role: null,
+                content: {
+                    reason: 'repo_busy',
+                    detail: repoBusyDetail({ runs, ps_error }),
+                },
+            })
+            return
+        }
+        await clock.sleep(Math.min(left, REPO_WAIT_NAP_MS))
+    }
+}

package/engine/core/execute-stuck.ts

@@ -3,7 +3,6 @@ import sortBy from 'lodash/sortBy'
 import type { RunBudgetAction } from './decide-run-budget'
 import type { StuckAction } from './decide-stuck'
 import { need, ticketWorktree, type BuildContext } from './execute-build'
-import { shipFinalReview } from './execute-final-review'
 
 import { checkIntake } from '../intake/intake-checks'
 import type { TicketSnapshot } from '../intake/intake-schemas'
@@ -15,7 +14,11 @@ import {
     postCommentOnce,
     type CommentStep,
 } from '../tracker/post-comment-once'
-import type { Tracker, TrackerIssue } from '../tracker/tracker'
+import {
+    HUMAN_LABEL,
+    type Tracker,
+    type TrackerIssue,
+} from '../tracker/tracker'
 
 /**
  * How long the engine waits between reads of the spec issue while stuck
@@ -40,8 +43,8 @@ export const ticketChanged = ({
  * marking the run stuck on its budget, telling the spec issue a ticket, the
  * run, or the final review is stuck, waiting for
  * and reading its comments, taking or sending back a reply, skipping a
- * ticket (with a comment on it), and shipping (`shipFinalReview`) or
- * retrying the stuck final review. Its comments are posted once
+ * ticket (with a comment on it), and retrying the stuck final review
+ * (shipping it is `shipFinalReviewIn`'s). Its comments are posted once
  * (`postCommentOnce`), even when a crash cut off the step after posting.
  */
 export const executeStuckAction = async ({
@@ -52,8 +55,12 @@ export const executeStuckAction = async ({
     reply_poll_ms,
     step,
 }: {
+    /** Shipping is `shipFinalReviewIn`'s: it commits edits left over. */
     action:
-        | Exclude<StuckAction, { type: 'undo_join' | 'retry_ticket' }>
+        | Exclude<
+              StuckAction,
+              { type: 'undo_join' | 'retry_ticket' | 'ship_final_review' }
+          >
         | RunBudgetAction
     journal: Journal
     tracker: Tracker
@@ -115,6 +122,9 @@ export const executeStuckAction = async ({
                     ticket: action.ticket,
                     comment_id: action.comment_id,
                     author: comment?.author ?? '',
+                    ...(action.top_up === undefined
+                        ? {}
+                        : { top_up: action.top_up }),
                 },
             })
             return
@@ -158,11 +168,6 @@ export const executeStuckAction = async ({
             })
             return
         }
-        case 'ship_final_review': {
-            const shipped = shipFinalReview({ journal })
-            if (!shipped.ok) throw new Error(shipped.reason)
-            return
-        }
         case 'retry_final_review':
             journal.append({
                 kind: 'final_review_retried',
@@ -303,6 +308,16 @@ export const retryTicket = async ({
                   (ticket) => ticket.number === number
               )
             : undefined
+    const leftOut = (
+        checked.outcome === 'passed'
+            ? checked.snapshot.left_out
+            : checked.left_out
+    ).some((ticket) => ticket.number === number)
+    if (fresh === undefined && leftOut) {
+        return refuse([
+            `The ticket is now for a person (\`${HUMAN_LABEL}\`), or waits on one, so a run can't build it.`,
+        ])
+    }
     if (fresh === undefined) return refuse(['The ticket is no longer open.'])
     const sha = await resetToRunBranch()
     journal.append({

package/engine/core/execute-waits.ts

@@ -0,0 +1,158 @@
+/**
+ * Carries out the run's waits: a plan limit wait or a billing stop, and a
+ * usage-line wait.
+ */
+import type { PlanAction } from './decide-plan'
+import type { UsageLineAction } from './decide-usage-line'
+
+import type { Journal } from '../journal/journal'
+import {
+    LIMIT_WAIT_NAP_MS,
+    limitWaitComment,
+    waitUntil,
+    type EngineClock,
+} from '../limits/limit-wait'
+import {
+    LINE_OF,
+    usageLineEndedComment,
+    usageLineWaitComment,
+    type UsageLines,
+} from '../limits/usage-line'
+import { postCommentOnce, type CommentStep } from '../tracker/post-comment-once'
+import type { Tracker } from '../tracker/tracker'
+
+/**
+ * Carries out a limit wait or a billing stop. A limit wait's start tells the
+ * spec issue (unless it already heard of this reset) before it is journaled;
+ * the wait itself sleeps by `clock` until its end, so a restarted engine
+ * waits out only what is left.
+ */
+export const executePlanAction = async ({
+    action,
+    journal,
+    tracker,
+    clock,
+    step,
+}: {
+    action: Exclude<PlanAction, { type: 'done' }>
+    journal: Journal
+    tracker: Tracker
+    clock: EngineClock
+    step: CommentStep
+}): Promise<void> => {
+    switch (action.type) {
+        case 'start_limit_wait': {
+            const { rate_limit_type, resets_at, until, ticket, role } = action
+            if (action.announce) {
+                await postCommentOnce({
+                    tracker,
+                    number: action.spec_number,
+                    body: limitWaitComment({
+                        rate_limit_type,
+                        resets_at,
+                        until,
+                    }),
+                    step,
+                    n: 0,
+                })
+            }
+            journal.append({
+                kind: 'limit_wait_started',
+                ticket: null,
+                role: null,
+                content: {
+                    resets_at,
+                    until,
+                    rate_limit_type,
+                    hit_ticket: ticket,
+                    hit_role: role,
+                },
+            })
+            return
+        }
+        case 'wait_for_limit':
+            await waitUntil({ clock, until: action.until })
+            journal.append({
+                kind: 'limit_wait_ended',
+                ticket: null,
+                role: null,
+                content: { until: action.until },
+            })
+            return
+        case 'stop_for_billing':
+            journal.append({
+                kind: 'run_stopped',
+                ticket: null,
+                role: null,
+                content: { reason: action.reason, role: null, billing: true },
+            })
+            return
+    }
+}
+
+/**
+ * Carries out a usage-line wait. Its start tells the spec issue, then is
+ * journaled. The wait sleeps by `clock` in naps until its end, re-reading
+ * the lines before each nap: a line raised above the reading ends it at
+ * once. Its end tells the spec issue why the run carries on, then is
+ * journaled.
+ */
+export const executeUsageLineAction = async ({
+    action,
+    journal,
+    tracker,
+    clock,
+    read_usage_lines,
+    step,
+}: {
+    action: UsageLineAction
+    journal: Journal
+    tracker: Tracker
+    clock: EngineClock
+    read_usage_lines: () => Promise<UsageLines>
+    step: CommentStep
+}): Promise<void> => {
+    const { spec_number, window, line, percent, until } = action
+    if (action.type === 'start_usage_line_wait') {
+        const { resets_at } = action
+        await postCommentOnce({
+            tracker,
+            number: spec_number,
+            body: usageLineWaitComment({ window, line, percent, resets_at }),
+            step,
+            n: 0,
+        })
+        journal.append({
+            kind: 'usage_line_wait_started',
+            ticket: null,
+            role: null,
+            content: { window, line, percent, resets_at, until },
+        })
+        return
+    }
+    const end = Date.parse(until)
+    let reason: 'reset' | 'line_raised' = 'reset'
+    for (;;) {
+        const lines = await read_usage_lines()
+        if (lines[LINE_OF[window]] > percent) {
+            reason = 'line_raised'
+            break
+        }
+        const left = end - clock.now()
+        if (left <= 0) break
+        await clock.sleep(Math.min(left, LIMIT_WAIT_NAP_MS))
+    }
+    await postCommentOnce({
+        tracker,
+        number: spec_number,
+        body: usageLineEndedComment({ window, percent, reason }),
+        step,
+        n: 0,
+    })
+    journal.append({
+        kind: 'usage_line_wait_ended',
+        ticket: null,
+        role: null,
+        content: { until, reason },
+    })
+}

package/engine/core/execute-with-jev.ts

@@ -0,0 +1,118 @@
+/**
+ * Carries out one action with the decision model asked around it in shadow
+ * mode.
+ */
+import type { EngineAction } from './decide'
+import { isFinalReviewAction } from './decide-final-review'
+import { executeAction, type StepTry } from './execute-action'
+import type { BuildDeps } from './execute-build'
+import type { GoingRunsReader } from './execute-repo-wait'
+import { ticketOf } from './schedule-rules'
+
+import { jevAsksAfter, jevAsksBefore } from '../jev/jev-jobs'
+import type { ShadowAsker } from '../jev/jev-shadow'
+import { asksModel } from '../jev/model-pick'
+import type { Journal } from '../journal/journal'
+import type { JournalRecord } from '../journal/journal-record'
+import { replayRun } from '../journal/replay'
+import type { EngineClock } from '../limits/limit-wait'
+import type { UsageLines } from '../limits/usage-line'
+import type { MemoryDeps } from '../memory/memory-client'
+import type { Tracker } from '../tracker/tracker'
+
+/**
+ * Carries out one action with the decision model in shadow mode: asks it
+ * before the action (ticket order, model, skills), then after it about the
+ * records it appended (failure kinds, finding severities). Only the action's
+ * own ticket's new records count, since other tickets append at the same
+ * time. The answers change nothing, but for the model pick of a role whose
+ * floor is below Opus, which the launch step reads (#603). A launch whose
+ * model is set without the decision model (after a failed try on a cheaper
+ * model, or a redo) gets no model ask (#604).
+ */
+export const executeWithJev = async ({
+    ask,
+    action,
+    journal,
+    tracker,
+    build,
+    clock,
+    reply_poll_ms,
+    memory,
+    step,
+    read_usage_lines,
+    going_runs,
+}: {
+    ask: ShadowAsker
+    action: EngineAction
+    journal: Journal
+    tracker: Tracker
+    build?: BuildDeps
+    clock?: EngineClock
+    reply_poll_ms?: number
+    memory?: MemoryDeps
+    step?: StepTry
+    read_usage_lines?: () => Promise<UsageLines>
+    going_runs?: GoingRunsReader
+}): Promise<void> => {
+    const before = journal.read()
+    const state = replayRun({ records: before })
+    await ask(
+        jevAsksBefore({ action, state }).filter(
+            // No model ask once the launch's model is set without one (#604).
+            ({ job, ticket, role }) =>
+                job !== 'agent_model' ||
+                role === null ||
+                asksModel({ records: before, state, ticket, role, step })
+        )
+    )
+    const lastSeq = journal.read().at(-1)?.seq ?? 0
+    await executeAction({
+        action,
+        journal,
+        tracker,
+        build,
+        clock,
+        reply_poll_ms,
+        memory,
+        step,
+        read_usage_lines,
+        going_runs,
+    })
+    const records = journal.read()
+    await ask(
+        jevAsksAfter({
+            records: records.filter(
+                (record) =>
+                    record.seq > lastSeq && ownsRecord({ action, record })
+            ),
+            state: replayRun({ records }),
+        })
+    )
+}
+
+/**
+ * Whether a record appended while `action` ran is that action's own, since
+ * other tickets (or other lenses) append at the same time: a ticket's
+ * records for a ticket's step, a lens's for its lens, and the final
+ * review's other ticket-less records for its other steps.
+ */
+const ownsRecord = ({
+    action,
+    record,
+}: {
+    action: EngineAction
+    record: JournalRecord
+}): boolean => {
+    if (action.type === 'launch_lens') {
+        return (
+            record.ticket === null &&
+            (record.role === null || record.role === action.role)
+        )
+    }
+    if (isFinalReviewAction(action)) {
+        return record.ticket === null && !record.role?.endsWith('-lens')
+    }
+    const ticket = ticketOf(action)
+    return ticket === null || record.ticket === ticket
+}