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

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

@@ -0,0 +1,129 @@
+import { decideRunBudget, type RunBudgetAction } from './decide-run-budget'
+import type { StuckAction } from './decide-stuck'
+
+import type { GoingRun } from '../cli/going-runs'
+import type { JournalRecord } from '../journal/journal-record'
+import type { RunState } from '../journal/replay'
+
+/** How long a repo wait lasts before the run is stuck (`repo_busy`). */
+export const REPO_WAIT_MAX_MS = 24 * 60 * 60 * 1000
+
+/** How long each nap of a repo wait is, between looks at the going runs. */
+export const REPO_WAIT_NAP_MS = 60_000
+
+/** An earlier run on the repo that a repo wait waits for. */
+export type RepoWaitRun = { run_id: string; spec: number | null }
+
+/** The run's steps for the repo wait (#615), before intake. */
+export type RepoWaitAction =
+    /** Tell the spec issue which runs the run waits for, and journal it. */
+    | { type: 'start_repo_wait'; spec_number: number; runs: RepoWaitRun[] }
+    /**
+     * Nap and look again until no earlier run is going, then journal the
+     * wait's end; at `until`, the run is stuck as `repo_busy`.
+     */
+    | { type: 'wait_for_repo'; spec_number: number; until: string }
+
+/**
+ * The going runs a repo wait waits for: those on the same repo as this
+ * run, started earlier by `run_started` time, then by run id, so two runs
+ * started together never wait for each other. A run with no repo (an older
+ * journal) or no start time never counts, and neither does this run. Pure.
+ *
+ * @example
+ * earlierRuns({ runs: going.runs, run_id: 'run-b', records })
+ * // [{ run_id: 'run-a', spec: 7 }]
+ */
+export const earlierRuns = ({
+    runs,
+    run_id,
+    records,
+}: {
+    runs: Pick<GoingRun, 'run_id' | 'spec' | 'repo' | 'started_at'>[]
+    /** This run's id. */
+    run_id: string
+    /** This run's journal. */
+    records: JournalRecord[]
+}): RepoWaitRun[] => {
+    const start = records.find((record) => record.kind === 'run_started')
+    if (start?.kind !== 'run_started' || start.content.repo === null) return []
+    const { repo } = start.content
+    const own = Date.parse(start.time)
+    return runs
+        .filter((run) => {
+            if (run.repo !== repo || run.run_id === run_id) return false
+            if (run.started_at === null) return false
+            const at = Date.parse(run.started_at)
+            return at < own || (at === own && run.run_id < run_id)
+        })
+        .map(({ run_id: id, spec }) => ({ run_id: id, spec }))
+}
+
+/**
+ * Whether the run has yet to look for earlier runs on its repo: intake
+ * hasn't read the tickets, and no repo wait began or was skipped. Pure, and
+ * cheap: it reads only the record kinds.
+ */
+export const repoWaitUnchecked = ({
+    records,
+}: {
+    records: JournalRecord[]
+}): boolean =>
+    records.length > 0 &&
+    !records.some(
+        ({ kind }) =>
+            kind === 'intake_read' ||
+            kind === 'repo_wait_started' ||
+            kind === 'repo_wait_skipped'
+    )
+
+/**
+ * The repo wait half of the decision step, before intake (#615). Pure. A
+ * run with `earlier_runs` going on its repo waits for them: it tells the
+ * spec issue once, then naps until none is going. A run that waited 24
+ * hours is stuck (`repo_busy`) until the owner's `retry` (another 24
+ * hours) or `stop`. A skipped or ended wait, and a run with no earlier
+ * runs (or none given), go on to intake: `null`.
+ */
+export const decideRepoWait = ({
+    state,
+    records,
+    spec_number,
+    earlier_runs,
+}: {
+    state: RunState
+    records: JournalRecord[]
+    spec_number: number
+    /** The earlier runs going on the repo; left out, there is no wait. */
+    earlier_runs: RepoWaitRun[] | undefined
+}):
+    | (
+          | RepoWaitAction
+          | RunBudgetAction
+          | StuckAction
+          | { type: 'done'; outcome: 'stopped_by_user' }
+      )[]
+    | null => {
+    if (state.phase !== 'started') return null
+    if (state.stop !== null) {
+        return [{ type: 'done', outcome: 'stopped_by_user' }]
+    }
+    if (state.run_budget.stuck !== null) {
+        return decideRunBudget({ state, records, spec_number })
+    }
+    const { status, since } = state.repo_wait
+    if (status === 'waiting' && since !== null) {
+        return [
+            {
+                type: 'wait_for_repo',
+                spec_number,
+                until: new Date(
+                    Date.parse(since) + REPO_WAIT_MAX_MS
+                ).toISOString(),
+            },
+        ]
+    }
+    if (status !== 'none' || earlier_runs === undefined) return null
+    if (earlier_runs.length === 0) return null
+    return [{ type: 'start_repo_wait', spec_number, runs: earlier_runs }]
+}

package/engine/core/decide-run-budget.ts

@@ -1,10 +1,43 @@
-import { pendingReplies, waitForReply, type StuckAction } from './decide-stuck'
-import { runBudgetDetail, runStuckComment } from './stuck-text'
+import {
+    amountTokens,
+    pendingReplies,
+    waitForReply,
+    type StuckAction,
+} from './decide-stuck'
+import { repoBusyStuckComment } from './repo-wait-text'
+import {
+    pullRequestStuckComment,
+    replyAnswer,
+    runBudgetDetail,
+    runStuckComment,
+} from './stuck-text'
 
-import type { JournalRecord, RunStuckReason } from '../journal/journal-record'
+import type {
+    JournalRecord,
+    ReplyProblem,
+    RunStuckReason,
+} from '../journal/journal-record'
 import type { RunState } from '../journal/replay'
 import { runBudgetOf, runTokensIn } from '../limits/run-budget'
 
+/** The spec issue's comment for the stuck run, by why it is stuck. */
+const stuckBody = ({
+    stuck,
+    budget,
+}: {
+    stuck: { reason: RunStuckReason; detail: string }
+    budget: number
+}): string => {
+    switch (stuck.reason) {
+        case 'pull_request_failed':
+            return pullRequestStuckComment({ detail: stuck.detail })
+        case 'repo_busy':
+            return repoBusyStuckComment({ detail: stuck.detail })
+        case 'run_budget':
+            return runStuckComment({ detail: stuck.detail, budget })
+    }
+}
+
 /** The run's steps with its budget of tokens (#435). */
 export type RunBudgetAction =
     /** The run used up its budget: journal it as stuck. */
@@ -15,11 +48,16 @@ export type RunBudgetAction =
 /**
  * The run budget half of the decision step. Pure. Once the run's tokens
  * (`runTokensIn`) reach its budget (the config's `run_budget_tokens`, else
- * the default, once more for each `retry`), the run is stuck with the
- * reason "run budget": that is its only step, and nothing new starts. The
- * spec issue is told, then the run waits for the owner: a bare `retry`
- * adds one more full budget (replay does that), and `stop` ends the run.
- * The owner's other replies wait until the run carries on. `null` when
+ * the default, plus every top-up a `retry` granted), the run is stuck with
+ * the reason "run budget": that is its only step, and nothing new starts.
+ * The spec issue is told, then the run waits for the owner: a bare `retry`
+ * tops the budget up by half a budget, rounded down, and `retry +3M` by the
+ * amount named (#543; replay adds the top-up); `stop` ends the run. A zero
+ * or unreadable amount is sent back (`bad_amount`). The owner's other
+ * replies wait until the run carries on. A run whose PR didn't open (#508)
+ * or whose repo wait ran out is stuck the same way, told why, and a bare
+ * `retry` tries again, adding no budget; an amount there is sent back
+ * (`amount_only_for_run_budget`). `null` when
  * the budget has nothing to say: the run is under it, stopping, or its PR
  * is open.
  *
@@ -37,11 +75,11 @@ export const decideRunBudget = ({
     spec_number: number
 }): (RunBudgetAction | StuckAction)[] | null => {
     if (state.stop !== null || state.pull_request !== null) return null
-    const { stuck, report, retries } = state.run_budget
+    const { stuck, report, top_ups } = state.run_budget
     const budget = runBudgetOf({ config: state.config })
     if (stuck === null) {
         const tokens = runTokensIn({ records })
-        const allowed = budget * (1 + retries)
+        const allowed = budget + top_ups
         if (tokens < allowed) return null
         return [
             {
@@ -56,7 +94,7 @@ export const decideRunBudget = ({
             {
                 type: 'report_run_stuck',
                 spec_number,
-                body: runStuckComment({ detail: stuck.detail, budget }),
+                body: stuckBody({ stuck, budget }),
             },
         ]
     }
@@ -65,12 +103,48 @@ export const decideRunBudget = ({
             word === 'stop' || (word === 'retry' && ticket === null)
     )
     if (reply === undefined) return [waitForReply({ state, spec_number })]
+    const ignore = (reason: ReplyProblem): StuckAction[] => [
+        {
+            type: 'ignore_reply',
+            comment_id: reply.comment_id,
+            spec_number,
+            reason,
+            answer: replyAnswer({ problem: reason, named: null, stuck: [] }),
+        },
+    ]
+    if (reply.word === 'stop') {
+        return [
+            {
+                type: 'take_reply',
+                comment_id: reply.comment_id,
+                word: 'stop',
+                ticket: null,
+            },
+        ]
+    }
+    if (stuck.reason !== 'run_budget') {
+        if (reply.amount !== null) return ignore('amount_only_for_run_budget')
+        return [
+            {
+                type: 'take_reply',
+                comment_id: reply.comment_id,
+                word: 'retry',
+                ticket: null,
+            },
+        ]
+    }
+    const top_up =
+        reply.amount === null
+            ? Math.floor(budget / 2)
+            : amountTokens({ amount: reply.amount })
+    if (top_up === null) return ignore('bad_amount')
     return [
         {
             type: 'take_reply',
             comment_id: reply.comment_id,
-            word: reply.word === 'stop' ? 'stop' : 'retry',
+            word: 'retry',
             ticket: null,
+            top_up,
         },
     ]
 }

package/engine/core/decide-stuck-helpers.ts

@@ -0,0 +1,127 @@
+import { decideSteps } from './decide'
+import { MAX_FIX_ROUNDS } from './decide-build'
+
+import type { TicketSnapshot } from '../intake/intake-schemas'
+import type { JournalEntry } from '../journal/journal-record'
+import {
+    agentStarted,
+    baselineTests,
+    gatesRun,
+    implemented,
+    intakePassed,
+    practiceTicket,
+    SESSIONS,
+    ticketBuilt,
+    ticketStuck,
+    worktreeReset,
+    ticketWorktreeCreated,
+    withInstalls,
+} from '../testing/build-fixtures'
+import { recordsFrom } from '../testing/intake-fixtures'
+
+/**
+ * Fixtures shared by the decide-stuck tests (#366): the tickets, the helpers
+ * that decide the next steps, and journals of a ticket stuck for good.
+ */
+
+export const SUM = practiceTicket({ number: 11, title: 'Add sum' })
+export const PRODUCT = practiceTicket({ number: 12, title: 'Add product' })
+export const AVERAGE = practiceTicket({
+    number: 13,
+    title: 'Add average',
+    blockers: [11],
+})
+
+export const stepsAfter = ({
+    tickets,
+    entries,
+}: {
+    tickets: TicketSnapshot[]
+    entries: JournalEntry[]
+}) =>
+    decideSteps({
+        records: recordsFrom({
+            entries: [
+                ...intakePassed({ tickets }),
+                ...withInstalls({ entries }),
+            ],
+        }),
+    })
+
+export const twoSteps = (entries: JournalEntry[]) =>
+    stepsAfter({ tickets: [SUM, PRODUCT], entries })
+
+export const oneSteps = (entries: JournalEntry[]) =>
+    stepsAfter({ tickets: [SUM], entries })
+
+/** #11 failed its gates after every fix round. */
+export const gatesFailedForGood = (): JournalEntry[] => [
+    ticketWorktreeCreated({ ticket: 11 }),
+    baselineTests({ ticket: 11 }),
+    ...ticketBuilt({ ticket: 11 }).slice(2, 6),
+    implemented({ ticket: 11 }),
+    gatesRun({ ticket: 11, target: 'ticket', ok: false }),
+    ...Array.from({ length: MAX_FIX_ROUNDS }, () => [
+        agentStarted({
+            ticket: 11,
+            role: 'implementer',
+            follow_up_of: SESSIONS.implementer,
+        }),
+        implemented({ ticket: 11 }),
+        gatesRun({ ticket: 11, target: 'ticket', ok: false }),
+    ]).flat(),
+    ticketStuck({
+        ticket: 11,
+        reason: 'gates_failed',
+        detail: 'The gates still fail after 3 fix rounds:\ntest: 1 fail',
+    }),
+]
+
+/**
+ * #11's one mapped test passed with no expect() twice (#581): the engine sent
+ * it back once, and the second time the ticket is stuck as `bad_test`.
+ */
+export const emptyTestForGood = (): JournalEntry[] => {
+    const emptyGates = gatesRun({
+        ticket: 11,
+        target: 'ticket',
+        ok: true,
+        cases: [
+            {
+                file: 'src/sum.test.ts',
+                full_name: 'sum adds two numbers',
+                status: 'passed',
+                assertions: 0,
+            },
+        ],
+    })
+    return [
+        ticketWorktreeCreated({ ticket: 11 }),
+        baselineTests({ ticket: 11 }),
+        ...ticketBuilt({ ticket: 11 }).slice(2, 6),
+        implemented({ ticket: 11 }),
+        emptyGates,
+        worktreeReset({
+            ticket: 11,
+            bad_test: {
+                file: 'src/sum.test.ts',
+                name: 'sum adds two numbers',
+                reason: 'It passes but runs no expect(), so it checks nothing (#581).',
+            },
+        }),
+        ...ticketBuilt({ ticket: 11 }).slice(2, 6),
+        implemented({ ticket: 11, session_id: 'impl-2' }),
+        emptyGates,
+        ticketStuck({
+            ticket: 11,
+            reason: 'bad_test',
+            detail: 'A mapped test still checks nothing after a fresh test-writer.',
+        }),
+    ]
+}
+
+/** #12 has its worktree and baseline: its test-writer is next. */
+export const productStarted = (): JournalEntry[] => [
+    ticketWorktreeCreated({ ticket: 12 }),
+    baselineTests({ ticket: 12 }),
+]

package/engine/core/decide-stuck.ts

@@ -32,12 +32,16 @@ export type StuckAction =
      * work waits for a reply; other tickets keep building meanwhile.
      */
     | { type: 'wait_for_reply'; spec_number: number; since_id: number }
-    /** The owner's comment is a reply: journal it. */
+    /**
+     * The owner's comment is a reply: journal it. A `retry` of the run stuck
+     * on its budget carries the tokens it adds (`top_up`, #543).
+     */
     | {
           type: 'take_reply'
           comment_id: number
           word: ReplyWord
           ticket: number | null
+          top_up?: number
       }
     /** The owner's comment looks like a reply but can't be used: say why. */
     | {
@@ -70,24 +74,64 @@ export type StuckAction =
           body: string
       }
 
-/** A reply word, and the ticket it names if any, from a comment's text. */
-type ParsedReply = { word: ReplyWord | 'ship'; ticket: number | null }
+/**
+ * A reply word, the ticket it names if any, and the text after `retry +`
+ * (`amount`, #543) if any, from a comment's text.
+ */
+type ParsedReply = {
+    word: ReplyWord | 'ship'
+    ticket: number | null
+    amount: string | null
+}
 
 const REPLY_PATTERN = /^(retry|skip|stop|ship)(?:\s+#?(\d+))?[\s.!]*$/i
 
+const AMOUNT_REPLY_PATTERN = /^retry\s+\+(\S*?)[\s.!]*$/i
+
 /**
  * Reads a one-word reply: `retry`, `skip`, `stop`, or `ship`, optionally
- * naming a ticket (`retry #12`, `skip 12`). Anything else is not a reply.
+ * naming a ticket (`retry #12`, `skip 12`), or `retry` with an amount
+ * (`retry +3M`). Anything else is not a reply.
  *
  * @example
- * parseReply({ body: 'Retry #12' }) // { word: 'retry', ticket: 12 }
+ * parseReply({ body: 'Retry #12' }) // { word: 'retry', ticket: 12, amount: null }
+ * parseReply({ body: 'retry +3M' }) // { word: 'retry', ticket: null, amount: '3M' }
  * parseReply({ body: 'Looking at it.' }) // null
  */
 export const parseReply = ({ body }: { body: string }): ParsedReply | null => {
+    const amount = AMOUNT_REPLY_PATTERN.exec(body.trim())
+    if (amount !== null) {
+        return { word: 'retry', ticket: null, amount: amount[1] ?? '' }
+    }
     const match = REPLY_PATTERN.exec(body.trim())
     if (match === null) return null
     const word = match[1]?.toLowerCase() as ParsedReply['word']
-    return { word, ticket: match[2] === undefined ? null : Number(match[2]) }
+    return {
+        word,
+        ticket: match[2] === undefined ? null : Number(match[2]),
+        amount: null,
+    }
+}
+
+const AMOUNT_PATTERN = /^(\d+)([km]?)$/i
+
+const AMOUNT_SCALES: Record<string, number> = { '': 1, k: 1_000, m: 1_000_000 }
+
+/**
+ * The tokens an amount after `retry +` names: a whole number, optionally
+ * followed by `k` or `M` in any case. `null` for zero, or for anything that
+ * can't be read.
+ *
+ * @example
+ * amountTokens({ amount: '500k' }) // 500_000
+ * amountTokens({ amount: '1.5M' }) // null
+ */
+export const amountTokens = ({ amount }: { amount: string }): number | null => {
+    const match = AMOUNT_PATTERN.exec(amount)
+    if (match === null) return null
+    const scale = AMOUNT_SCALES[(match[2] ?? '').toLowerCase()] ?? 1
+    const tokens = Number(match[1]) * scale
+    return tokens > 0 && Number.isSafeInteger(tokens) ? tokens : null
 }
 
 /**
@@ -137,7 +181,9 @@ const awaitingReply = (progress: TicketProgress): boolean =>
 /**
  * The next steps of one stuck ticket: undo a join its stuck left on the run
  * branch (so no other ticket builds on it), tell the spec issue, then act
- * on the owner's reply. Nothing while it waits for one.
+ * on the owner's reply. Nothing while it waits for one. A ticket stuck
+ * because its undo was refused (`undo_refused`, #519) is never undone again
+ * before a reply: it is told at once, with its join left where it is.
  */
 export const stuckTicketSteps = ({
     spec_number,
@@ -151,7 +197,11 @@ export const stuckTicketSteps = ({
     const { stuck, joined } = progress
     if (stuck === null) return []
     const number = ticket.number
-    if (joined?.ok === true && progress.pushed === null) {
+    if (
+        joined?.ok === true &&
+        progress.pushed === null &&
+        stuck.reason !== 'undo_refused'
+    ) {
         const first_sha = joined.shas[0]
         if (first_sha !== undefined) {
             return [{ type: 'undo_join', ticket: number, first_sha }]
@@ -315,6 +365,8 @@ export const replySteps = ({
                 },
             ]
         }
+        // Only the run stuck on its budget takes an amount (decideRunBudget).
+        if (next.amount !== null) return ignore('amount_only_for_run_budget')
         if (next.ticket !== null && !waiting.includes(next.ticket)) {
             return ignore('not_stuck')
         }

package/engine/core/decide-ticket-review.ts

@@ -0,0 +1,95 @@
+/**
+ * A ticket's review step: a fresh reviewer after the green commit, and the
+ * review's fix rounds, each re-reviewed.
+ */
+
+import { stuck, type BuildAction, type StepArgs } from './build-action'
+import { launch } from './build-launch'
+import { commitStep, gateStep } from './decide-red-green'
+import { MAX_FIX_ROUNDS } from './loop-caps'
+import { openFindingsText, reviewFixMessage } from './review-text'
+import { badTestDetail } from './stuck-text'
+
+import { handoffRole } from '../journal/replay'
+
+/**
+ * The ticket review and its fix loop, after the green commit. A fresh
+ * reviewer checks the committed diff. Blockers and should-fixes open a fix
+ * round: test findings go to a fresh test-writer first, then code findings
+ * to the same implementer session (a fresh one if it is gone), then the
+ * findings a fixer answered `other_role` to a fresh agent of the other
+ * writer role (#616). The fixes
+ * pass the gates, get their own commit, and a fresh reviewer checks only
+ * the new changes. A review that still asks for changes after
+ * `MAX_FIX_ROUNDS` fix rounds is stuck. `null` once a review approves.
+ */
+export const reviewStep = ({
+    snapshot,
+    ticket,
+    progress,
+    run_notes,
+}: StepArgs): BuildAction | null => {
+    const number = ticket.number
+    const reviewer = () =>
+        launch({
+            role: 'ticket-reviewer',
+            snapshot,
+            ticket,
+            progress,
+            run_notes,
+        })
+    if (progress.review === null) return reviewer()
+    const fix = progress.review_fix
+    if (fix === null) return null
+    if (fix.round > MAX_FIX_ROUNDS) {
+        return stuck({
+            ticket: number,
+            reason: 'changes_requested',
+            detail: `The ticket review still asks for changes after ${MAX_FIX_ROUNDS} fix rounds:\n${openFindingsText({ findings: fix.findings })}`,
+        })
+    }
+    if (!fix.tests_answered) {
+        return launch({
+            role: 'test-writer',
+            snapshot,
+            ticket,
+            progress,
+            run_notes,
+        })
+    }
+    if (!fix.code_answered) {
+        const session_id = progress.sessions.implementer
+        if (session_id === undefined) {
+            return launch({
+                role: 'implementer',
+                snapshot,
+                ticket,
+                progress,
+                run_notes,
+            })
+        }
+        return {
+            type: 'follow_up_agent',
+            ticket: number,
+            role: 'implementer',
+            session_id,
+            message: reviewFixMessage({ fix }),
+        }
+    }
+    if (fix.bad_test !== null) {
+        return stuck({
+            ticket: number,
+            reason: 'bad_test',
+            detail: `While fixing review findings, the implementer sent a test back as bad: ${badTestDetail({ bad_test: fix.bad_test })}`,
+        })
+    }
+    const handoff = handoffRole({ fix })
+    if (handoff !== null) {
+        return launch({ role: handoff, snapshot, ticket, progress, run_notes })
+    }
+    return (
+        gateStep({ snapshot, ticket, progress, run_notes }) ??
+        commitStep({ stage: 'fix', ticket, progress }) ??
+        reviewer()
+    )
+}