@alecsibilia/luca 14.0.0-alpha.22 → 14.0.0-alpha.23

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.23
+
+No changes in this release.
+
 ## 14.0.0-alpha.22
 
 No changes in this release.

package/board/package.json

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

package/board/server/luca-version.ts

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

package/engine/agents/claude-options.ts

@@ -33,15 +33,19 @@ export const MODEL_NAMES = ModelNameSchema.options
 /** The model reviewers run on, and every agent the decision model doesn't route (#603). */
 export const CLAUDE_MODEL = DEFAULT_MODEL
 
-/** How many model turns one agent gets before its try ends. */
+/**
+ * How many model turns one agent gets before its try ends. The integration
+ * lens reads how every ticket fits together on the whole branch, so it gets
+ * more than the other lenses.
+ */
 export const MAX_TURNS: Record<AgentRole, number> = {
     'test-writer': 80,
-    implementer: 120,
+    implementer: 150,
     'ticket-reviewer': 60,
     'architecture-lens': 60,
     'simplification-lens': 60,
     'security-lens': 60,
-    'integration-lens': 60,
+    'integration-lens': 100,
     'rules-lens': 60,
     learner: 40,
 }

package/engine/core/decide-final-fix.ts

@@ -29,10 +29,11 @@ import type { AgentRole } from '../agents/role-results'
 import { handoffRole, type ReplayedAgentFailure } from '../journal/replay'
 
 /**
- * A fresh fixer of this role, told its findings (or the failed gates). With
- * `follow_up`, it stands in for a follow-up whose session is gone, and its
- * prompt carries the message. A fixer taking a turn a crash cut off is told
- * of the crash.
+ * A fresh fixer of this role, told its findings (or the failed gates). The
+ * implementer that starts a round whose slow tests failed is told of them
+ * too (#563). With `follow_up`, it stands in for a follow-up whose session
+ * is gone, and its prompt carries the message. A fixer taking a turn a
+ * crash cut off is told of the crash.
  */
 const launchFixer = ({
     role,
@@ -49,6 +50,11 @@ const launchFixer = ({
     // An implementer with no code findings left is here for failed gates.
     const gates =
         role === 'implementer' && fix.code_answered ? review.gates : null
+    // The implementer with code findings also fixes the round's slow tests.
+    const slow_tests =
+        role === 'implementer' && !fix.code_answered && review.slow_due
+            ? review.slow_tests
+            : null
     const sections = [
         ...(follow_up === undefined
             ? []
@@ -63,6 +69,7 @@ const launchFixer = ({
             snapshot,
             fix,
             gates,
+            slow_tests,
             run_notes,
             sections,
         }),

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

@@ -69,7 +69,9 @@ const lensStep = ({
  * earlier findings; its blocking findings get one fix round (past the round
  * cap, too) and one re-review, and what is still open then tops the PR
  * instead of getting the review stuck.
- * Failed tries are capped per role like a ticket's. A stuck final review
+ * Failed tries are capped per role, in a row: a finished turn of the role
+ * gives its tries back, so one failed try in an early round doesn't count
+ * against it in a later one. A stuck final review
  * waits for a reply; `ship` opens the PR anyway. A final review step cut
  * off by a crash `MAX_CRASHES` times in a row is stuck too.
  *

package/engine/core/final-failure-cap.ts

@@ -1,6 +1,7 @@
 /**
  * The cap on a final review role's failed tries (`failureCap`): the stuck step
- * once a failed turn used up the role's tries, or its engine failures in a row.
+ * once a failed turn used up the role's tries in a row, or its engine
+ * failures in a row. A finished turn of the role gives its tries back.
  */
 import { stuck, type FinalReviewAction } from './final-review-action'
 import { MAX_ENGINE_FAILURES, MAX_FIX_ROUNDS } from './loop-caps'
@@ -8,8 +9,11 @@ import { MAX_ENGINE_FAILURES, MAX_FIX_ROUNDS } from './loop-caps'
 import type { FinalReviewState, ReplayedAgentFailure } from '../journal/replay'
 
 /**
- * The stuck step when a failed turn used up its role's tries (or engine
- * failures in a row), else `null`: the role gets another go.
+ * The stuck step when a failed turn used up its role's tries in a row (or
+ * engine failures in a row), else `null`: the role gets another go.
+ *
+ * @example
+ * failureCap({ review, failed }) // null while the role has tries left
  */
 export const failureCap = ({
     review,
@@ -32,7 +36,7 @@ export const failureCap = ({
     return tries >= MAX_FIX_ROUNDS
         ? stuck({
               reason: 'agent_failed',
-              detail: `The ${role} failed ${tries} tries in the final review; the last one: ${error}`,
+              detail: `The ${role} failed ${tries} tries in a row in the final review; the last one: ${error}`,
           })
         : null
 }

package/engine/core/final-review-text.ts

@@ -190,13 +190,27 @@ const findingsSection = ({
         FIX_RULES,
     ].join('\n\n')
 
+/** The round's failed slow tests, beside the implementer's code findings (#563). */
+const slowTestsSection = ({
+    slow_tests,
+}: {
+    slow_tests: ReplayedGates
+}): string =>
+    [
+        '## The slow tests failed too',
+        'Once every lens finished, the engine ran the slow tests on the run branch, and these failed. Fix the code so they pass too: the gates run them again after you answer.',
+        failedChecks({ gates: slow_tests }),
+    ].join('\n\n')
+
 /**
  * The prompt a fresh final review fixer starts with: its task, the spec,
  * every ticket, and its findings (the test findings for the test-writer,
  * the code findings for the implementer, or the findings the other fixer
- * answered `other_role`, #616). An implementer launched only to
- * fix failed gates (the round had only test findings) gets the gates'
- * output instead. The engine journals it word for word.
+ * answered `other_role`, #616). The implementer that starts a round whose
+ * slow tests failed (#563) gets their output beside its code findings. An
+ * implementer launched only to fix failed gates (the round had only test
+ * findings) gets the gates' output instead. The engine journals it word
+ * for word.
  *
  * @example
  * const prompt = finalFixerPrompt({ role: 'implementer', snapshot, fix, gates: null })
@@ -206,6 +220,7 @@ export const finalFixerPrompt = ({
     snapshot,
     fix,
     gates,
+    slow_tests,
     run_notes,
     sections,
 }: {
@@ -214,6 +229,8 @@ export const finalFixerPrompt = ({
     fix: FinalReviewFix
     /** Failed gates to fix, for an implementer with no findings left. */
     gates: ReplayedGates | null
+    /** The round's failed slow tests, for the implementer that starts it. */
+    slow_tests?: ReplayedGates | null
     /** Notes earlier agents in the run left, oldest first. */
     run_notes?: PromptRunNote[]
     /** More sections after the task, such as a follow-up's message. */
@@ -239,6 +256,7 @@ export const finalFixerPrompt = ({
         FIXER_TASKS[role],
         ...workSections({ snapshot }),
         task,
+        ...(slow_tests?.ok === false ? [slowTestsSection({ slow_tests })] : []),
         ...(sections ?? []),
         ...runNotesSection({ run_notes: run_notes ?? [] }),
     ].join('\n\n')

package/engine/core/pull-request-text.ts

@@ -15,6 +15,7 @@ import { reasonLine } from './stuck-text'
 import type { AgentRole, MergeDanger } from '../agents/role-results'
 import {
     EMPTY_FINAL_REVIEW,
+    finalPullRequestFindings,
     type FinalReviewState,
     type ReplayedSnapshot,
     type TicketProgress,
@@ -114,7 +115,9 @@ const outOfTurnsSection = ({
  * agents ran out of turns (#543), the reviews' nits,
  * the findings declined through "won't fix", and the memories the learner
  * added or updated (#370). A final review shipped
- * while stuck puts its open findings at the very top. Right after the
+ * while stuck puts its open findings at the very top; a round it never
+ * settled counts the findings, nits, and rulings of the lenses that
+ * finished it (see `finalPullRequestFindings`). Right after the
  * "Built by" line come the Summary picture and the Merge Danger (from the
  * final review's integration lens, or "Not available" without them) and
  * the Evidence that each ticket's new tests failed first and pass now
@@ -137,6 +140,8 @@ export const pullRequestText = ({
     memory_saves?: MemorySave[]
 }): { title: string; body: string } => {
     const review = final_review ?? EMPTY_FINAL_REVIEW
+    // A round a stuck lens never settled keeps its finished lenses' findings.
+    const findings = finalPullRequestFindings({ review })
     const { spec } = snapshot
     const title = (number: number) => snapshot.tickets[number]?.title ?? ''
     const isSkipped = (number: number) =>
@@ -175,7 +180,7 @@ export const pullRequestText = ({
                     `- #${number} ${id}${fileText(file)}: ${title}`
             )
         ),
-        ...review.nits.map(
+        ...findings.nits.map(
             ({ lens, id, title, file }) =>
                 `- final review, ${lens} lens: ${id}${fileText(file)}: ${title}`
         ),
@@ -206,23 +211,22 @@ export const pullRequestText = ({
                 declinedLine({ where: `#${number} `, ...entry })
             )
         ),
-        ...review.declined.map((entry) =>
+        ...findings.declined.map((entry) =>
             declinedLine({
                 where: `final review, ${entry.lens} lens: `,
                 ...entry,
             })
         ),
     ]
-    const stillOpen = review.fix?.findings ?? []
     const shipped =
         review.shipped && review.stuck !== null
             ? shippedFindingsSection({
-                  findings: stillOpen,
+                  findings: findings.open,
                   stuck: review.stuck,
                   edits: review.shipped_edits,
               })
-            : review.fresh_started && stillOpen.length > 0
-              ? freshFindingsSection({ findings: stillOpen })
+            : review.fresh_started && findings.open.length > 0
+              ? freshFindingsSection({ findings: findings.open })
               : ''
     const body = [
         shipped,

package/engine/core/stuck-format.ts

@@ -18,5 +18,17 @@ export const fenced = (text: string): string => {
     return `${fence}\n${clipped}\n${fence}`
 }
 
-export const plural = (count: number, word: string): string =>
-    `${count} ${word}${count === 1 ? '' : 's'}`
+/**
+ * `count` and `word`, with `s` past one; a word ending in a consonant and
+ * `y` ends in `ies` instead.
+ *
+ * @example
+ * plural(2, 'fix round') // '2 fix rounds'
+ * plural(3, 'failed try') // '3 failed tries'
+ */
+export const plural = (count: number, word: string): string => {
+    if (count === 1) return `${count} ${word}`
+    return /[^aeiou]y$/.test(word)
+        ? `${count} ${word.slice(0, -1)}ies`
+        : `${count} ${word}s`
+}

package/engine/journal/final-review-replay.ts

@@ -143,7 +143,10 @@ export const finalReviewAfter = ({
             return finalResultChange({
                 review: {
                     ...review,
+                    // A finished turn gives the role its tries back: the
+                    // cap is on failed tries in a row.
                     agent_failures: omit(review.agent_failures, role),
+                    failed_tries: omit(review.failed_tries, role),
                     engine_failures: omit(review.engine_failures, role),
                     sessions: sessionsAfter({
                         sessions: review.sessions,

package/engine/journal/final-review-round.ts

@@ -13,7 +13,11 @@ import {
     handoffRole,
     type FinishedContent,
 } from './agent-turn-replay'
-import type { FinalFinding, FinalReviewState } from './final-review-state'
+import type {
+    FinalDeclined,
+    FinalFinding,
+    FinalReviewState,
+} from './final-review-state'
 import { setupChangeOf } from './ticket-result-replay'
 
 import {
@@ -112,6 +116,21 @@ const lensResultOf = ({
     }
 }
 
+/**
+ * The blocking findings of each due lens that finished this round, with
+ * its lens.
+ */
+const roundBlocking = ({
+    review,
+}: {
+    review: FinalReviewState
+}): FinalFinding[] =>
+    review.lenses_due.flatMap((lens) =>
+        (review.results[lens]?.findings ?? [])
+            .filter(isBlocking)
+            .map((entry) => ({ ...entry, lens }))
+    )
+
 /**
  * Every due lens finished this round, and its slow tests ran if they were
  * due (#563): the round can settle.
@@ -161,9 +180,7 @@ export const settleRound = ({
             result.findings.filter((entry) => !isBlocking(entry))
         )
     )
-    const blocking = due.flatMap(({ lens, result }) =>
-        tagged(lens, result.findings.filter(isBlocking))
-    )
+    const blocking = roundBlocking({ review })
     const settled: FinalReviewState = {
         ...review,
         declined: [...review.declined, ...declined],
@@ -199,6 +216,51 @@ export const settleRound = ({
     }
 }
 
+/** The final review's findings as its PR lists them. */
+export type PullRequestFindings = {
+    /** The blocking findings still open. */
+    open: FinalFinding[]
+    nits: FinalFinding[]
+    declined: FinalDeclined[]
+}
+
+/**
+ * The final review's findings as its PR lists them: the blocking ones still
+ * open, the nits, and the "won't fix" answers a lens let go. A round that
+ * never settled (a lens failed on every try, or a step crashed, and the
+ * owner replied `ship`) is settled over the lenses that finished it, as
+ * `settleRound` would: their blocking findings, nits, and rulings count,
+ * and a finding one of them cleared is no longer open. The open fix round's
+ * findings stay open only for the lenses that never finished. A settled
+ * round's findings are as they stand.
+ *
+ * @example
+ * finalPullRequestFindings({ review }).open
+ * // [{ id: 'simplification-F1', lens: 'simplification', severity: 'should_fix', ... }]
+ */
+export const finalPullRequestFindings = ({
+    review,
+}: {
+    review: FinalReviewState
+}): PullRequestFindings => {
+    const earlier = review.fix?.findings ?? []
+    const finished = review.lenses_due.filter(
+        (lens) => review.results[lens] !== undefined
+    )
+    if (roundDone({ review }) || finished.length === 0) {
+        return { open: earlier, nits: review.nits, declined: review.declined }
+    }
+    const settled = settleRound({ review: { ...review, lenses_due: finished } })
+    return {
+        open: [
+            ...earlier.filter(({ lens }) => !finished.includes(lens)),
+            ...(settled.fix?.findings ?? []),
+        ],
+        nits: settled.nits,
+        declined: settled.declined,
+    }
+}
+
 /**
  * Where a finished agent's result goes in the final review: a lens's
  * result this round (settling the round once every due lens finished), or

package/engine/journal/final-review-state.ts

@@ -72,7 +72,10 @@ export type FinalReviewState = {
     sessions: Partial<Record<AgentRole, string>>
     /** Each role's failed turn, if no agent of that role finished after it. */
     agent_failures: Partial<Record<AgentRole, ReplayedAgentFailure>>
-    /** Failed tries (agent, result, guard) per role, over the whole final review. */
+    /**
+     * Failed tries (agent, result, guard) per role, in a row: a finished
+     * turn of the role starts its count again.
+     */
     failed_tries: Partial<Record<AgentRole, number>>
     /** Engine failures in a row, per role. */
     engine_failures: Partial<Record<AgentRole, number>>

package/engine/journal/replay.ts

@@ -71,7 +71,7 @@ export { EMPTY_FINAL_REVIEW } from './final-review-state'
 export type { PlanState } from './plan-replay'
 export type { LearnerState, MemoryState } from './memory-replay'
 export { EMPTY_MEMORY } from './memory-replay'
-export { namespacedId } from './final-review-round'
+export { finalPullRequestFindings, namespacedId } from './final-review-round'
 export { isFinalKey } from './final-review-replay'
 export { handoffRole } from './agent-turn-replay'
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@alecsibilia/luca",
     "description": "Luca: turns a spec on GitHub Issues into a reviewed pull request, run from Paseo with Claude Code",
-    "version": "14.0.0-alpha.22",
+    "version": "14.0.0-alpha.23",
     "license": "Apache-2.0",
     "author": "Alec Sibilia <sibilia.alec@gmail.com>",
     "homepage": "https://github.com/asibilia/luca-framework#readme",