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

package/engine/journal/ticket-result-replay.ts

@@ -0,0 +1,364 @@
+/**
+ * Where an agent's answer goes in its ticket's progress: a finished agent's
+ * result (fix rounds, bad tests, ticket reviews), the test setup change it
+ * asked for, and the engine's check of `already_done` evidence.
+ */
+import {
+    badTestOf,
+    declinedBy,
+    fixerAnswered,
+    handoffAnswered,
+    handoffRole,
+    ranCheaper,
+    type FinishedContent,
+} from './agent-turn-replay'
+import type { JournalRecord } from './journal-record'
+import type { TicketProgress } from './ticket-progress'
+
+import {
+    isBlocking,
+    type AgentRole,
+    type BadTestSource,
+    type TicketReviewResult,
+} from '../agents/role-results'
+
+/**
+ * A failed try for `role` on its ticket: one more of its tries used up,
+ * and, if its agent ran on a model cheaper than Opus, its later fresh
+ * agents on the ticket step up to Opus (#604). Engine failures are no try.
+ */
+export const failedTryChange = ({
+    progress,
+    role,
+}: {
+    progress: TicketProgress
+    role: AgentRole
+}): Pick<TicketProgress, 'failed_tries' | 'failed_cheaper'> => ({
+    failed_tries: {
+        ...progress.failed_tries,
+        [role]: (progress.failed_tries[role] ?? 0) + 1,
+    },
+    failed_cheaper:
+        ranCheaper(progress.launched_on[role]) &&
+        !progress.failed_cheaper.includes(role)
+            ? [...progress.failed_cheaper, role]
+            : progress.failed_cheaper,
+})
+
+/**
+ * The bounce sources once `by` sends one more test back as bad (#581), each
+ * kept in order so a stuck detail can name who sent the first and who the
+ * second. They go together with `bad_test_bounces`.
+ */
+export const bouncedBy = ({
+    progress,
+    by,
+}: {
+    progress: TicketProgress
+    by: BadTestSource
+}): BadTestSource[] => [...progress.bad_test_sources, by]
+
+/**
+ * Where a finished agent's result goes in its ticket's progress. A result
+ * that answers a fix-loop follow-up counts a round and clears the failed
+ * check, so it runs again.
+ */
+export const resultChange = ({
+    progress,
+    finished,
+    seq,
+}: {
+    progress: TicketProgress
+    finished: FinishedContent
+    seq: number
+}): Partial<TicketProgress> => {
+    const fix = progress.review_fix
+    const { rejoin, test_update } = progress
+    switch (finished.role) {
+        case 'test-writer':
+            // The test-writer's answer to a test update after a rebase: the
+            // red check stands, as for clashed tests (#489).
+            if (test_update !== null && test_update.result === null) {
+                return {
+                    test_update: { ...test_update, result: finished.result },
+                }
+            }
+            // The fresh test-writer after a rebase fixed the clashed tests:
+            // no fix round, and the red check stands.
+            if (rejoin?.tests_pending) {
+                return { rejoin: { ...rejoin, tests_pending: false } }
+            }
+            if (fix !== null && !fix.tests_answered) {
+                return {
+                    review_fix: {
+                        ...fix,
+                        tests_answered: true,
+                        ...fixerAnswered({
+                            fix,
+                            role: 'test-writer',
+                            responses: finished.result.finding_responses,
+                        }),
+                    },
+                }
+            }
+            if (fix !== null && handoffRole({ fix }) === 'test-writer') {
+                return {
+                    review_fix: {
+                        ...fix,
+                        ...handoffAnswered({
+                            fix,
+                            role: 'test-writer',
+                            responses: finished.result.finding_responses,
+                        }),
+                    },
+                }
+            }
+            // An `environment` answer to a failed red check reruns it with
+            // the earlier tests, using no fix round (#613).
+            if (
+                finished.result.outcome === 'environment' &&
+                progress.red_check !== null &&
+                !progress.red_check.ok
+            ) {
+                return {
+                    red_check: null,
+                    environment_reruns: progress.environment_reruns + 1,
+                    environment: {
+                        role: 'test-writer',
+                        evidence: finished.result.environment?.evidence ?? '',
+                        check: 'red_check',
+                        failed: progress.red_check,
+                    },
+                }
+            }
+            // A new answer is checked afresh if it is `already_done` (#495).
+            return progress.red_check === null
+                ? { test_writer: finished.result, already_done_check: null }
+                : {
+                      test_writer: finished.result,
+                      already_done_check: null,
+                      red_check: null,
+                      red_fix_rounds: progress.red_fix_rounds + 1,
+                  }
+        case 'implementer': {
+            const { result } = finished
+            const bad_test = badTestOf(result)
+            // Its answer after the test-writer updated the tests closes the
+            // update; a done answer settles the bad test (#489).
+            if (test_update !== null && test_update.result !== null) {
+                return {
+                    implementer: result,
+                    test_update: null,
+                    ...(bad_test === null
+                        ? { bad_test: null, bad_test_source: null }
+                        : {
+                              bad_test,
+                              bad_test_source: 'implementer',
+                              bad_test_sources: bouncedBy({
+                                  progress,
+                                  by: 'implementer',
+                              }),
+                              bad_test_bounces: progress.bad_test_bounces + 1,
+                          }),
+                }
+            }
+            // The implementer's answer to the clash message is no fix round.
+            // A bad test is kept, for the test update or the stuck text.
+            if (rejoin?.code_pending) {
+                return {
+                    implementer: result,
+                    rejoin: { ...rejoin, code_pending: false },
+                    ...(bad_test === null
+                        ? {}
+                        : {
+                              bad_test,
+                              bad_test_source: 'implementer',
+                              bad_test_sources: bouncedBy({
+                                  progress,
+                                  by: 'implementer',
+                              }),
+                              bad_test_bounces: progress.bad_test_bounces + 1,
+                          }),
+                }
+            }
+            if (fix !== null && fix.tests_answered && !fix.code_answered) {
+                return {
+                    review_fix: {
+                        ...fix,
+                        code_answered: true,
+                        ...fixerAnswered({
+                            fix,
+                            role: 'implementer',
+                            responses: result.finding_responses,
+                        }),
+                        bad_test,
+                    },
+                }
+            }
+            if (fix !== null && handoffRole({ fix }) === 'implementer') {
+                return {
+                    review_fix: {
+                        ...fix,
+                        ...handoffAnswered({
+                            fix,
+                            role: 'implementer',
+                            responses: result.finding_responses,
+                        }),
+                        bad_test,
+                    },
+                }
+            }
+            // An `environment` answer to failed gates reruns them, using no
+            // fix round (#613).
+            if (
+                result.outcome === 'environment' &&
+                progress.gates !== null &&
+                !progress.gates.ok
+            ) {
+                return {
+                    gates: null,
+                    environment_reruns: progress.environment_reruns + 1,
+                    environment: {
+                        role: 'implementer',
+                        evidence: result.environment?.evidence ?? '',
+                        check: 'gates',
+                        failed: progress.gates,
+                    },
+                }
+            }
+            const bounce: Partial<TicketProgress> =
+                bad_test === null
+                    ? {}
+                    : {
+                          bad_test_bounces: progress.bad_test_bounces + 1,
+                          bad_test,
+                          bad_test_source: 'implementer',
+                          bad_test_sources: bouncedBy({
+                              progress,
+                              by: 'implementer',
+                          }),
+                      }
+            const round: Partial<TicketProgress> =
+                progress.gates === null
+                    ? {}
+                    : {
+                          gates: null,
+                          gate_fix_rounds: progress.gate_fix_rounds + 1,
+                      }
+            return { implementer: result, ...round, ...bounce }
+        }
+        case 'ticket-reviewer':
+            return reviewChange({ progress, review: finished.result, seq })
+        // Lenses review the run branch, never a ticket.
+        default:
+            return {}
+    }
+}
+
+/**
+ * A finished ticket review: counts the round, settles the last round's
+ * "won't fix" answers, keeps its nits, and opens a fix round when a finding
+ * is a blocker or a should-fix. A new fix round starts its gates, gate fix
+ * rounds, and fix commit afresh.
+ */
+const reviewChange = ({
+    progress,
+    review,
+    seq,
+}: {
+    progress: TicketProgress
+    review: TicketReviewResult
+    /** The review's record, for the join queue's order once it approves. */
+    seq: number
+}): Partial<TicketProgress> => {
+    const review_rounds = progress.review_rounds + 1
+    const blocking = review.findings.filter(isBlocking)
+    const newNits = review.findings.filter(
+        (finding) =>
+            !isBlocking(finding) &&
+            !progress.nits.some(({ id }) => id === finding.id)
+    )
+    const settled: Partial<TicketProgress> = {
+        review,
+        review_rounds,
+        reviewed_sha: progress.commits.fix ?? progress.commits.green,
+        nits: [...progress.nits, ...newNits],
+        declined: [
+            ...progress.declined,
+            ...declinedBy({ fix: progress.review_fix, review }),
+        ],
+    }
+    if (blocking.length === 0) {
+        return { ...settled, review_fix: null, approved_seq: seq }
+    }
+    return {
+        ...settled,
+        approved_seq: null,
+        review_fix: {
+            round: review_rounds,
+            findings: blocking,
+            tests_answered: !blocking.some(({ kind }) => kind === 'test'),
+            code_answered: !blocking.some(({ kind }) => kind === 'code'),
+            responses: [],
+            handed_off: {},
+            bad_test: null,
+        },
+        gates: null,
+        gate_fix_rounds: 0,
+        leftovers: { ...progress.leftovers, fix: null },
+        commits: { ...progress.commits, fix: null },
+        commit_files: { ...progress.commit_files, fix: [] },
+    }
+}
+
+/** The test setup change an agent asked for in its result, if any. */
+export const setupChangeOf = ({
+    finished,
+}: {
+    finished: FinishedContent
+}): TicketProgress['setup_change'] => {
+    if (finished.role !== 'test-writer' && finished.role !== 'implementer') {
+        return null
+    }
+    const { outcome, setup_change } = finished.result
+    if (outcome !== 'needs_setup_change') return null
+    return {
+        role: finished.role,
+        file: setup_change?.file ?? '',
+        reason: setup_change?.reason ?? finished.result.summary,
+    }
+}
+
+type AlreadyDoneCheckedContent = Extract<
+    JournalRecord,
+    { kind: 'already_done_checked' }
+>['content']
+
+/**
+ * The engine's check of a test-writer's `already_done` evidence (#495). A
+ * failed one is a failed try for the test-writer, in the session that gave
+ * the evidence, as if its turn had failed: the decision step sends it what
+ * did not check out, or makes the ticket stuck once its tries run out.
+ */
+export const alreadyDoneCheckedChange = ({
+    progress,
+    checked,
+}: {
+    progress: TicketProgress
+    checked: AlreadyDoneCheckedContent
+}): Partial<TicketProgress> => {
+    const { ok, problems } = checked
+    if (ok) return { already_done_check: { ok, problems } }
+    const role = 'test-writer'
+    return {
+        already_done_check: { ok, problems },
+        agent_failure: {
+            role,
+            error: problems.map((problem) => `- ${problem}`).join('\n'),
+            failure: 'evidence',
+            session_id: progress.sessions[role] ?? null,
+        },
+        engine_failures: 0,
+        ...failedTryChange({ progress, role }),
+    }
+}

package/engine/journal/ticket-retry-replay.ts

@@ -0,0 +1,142 @@
+/**
+ * A stuck ticket's `retry` in replay: refused, restarted from scratch, or
+ * resumed where it stopped with a fresh agent and fresh counts.
+ */
+import type { JournalRecord } from './journal-record'
+import { EMPTY_TICKET_PROGRESS, type TicketProgress } from './ticket-progress'
+
+type RetriedContent = Extract<
+    JournalRecord,
+    { kind: 'ticket_retried' }
+>['content']
+
+/**
+ * A `retry` of a stuck ticket. `refused` leaves it stuck, waiting for the
+ * next reply. `restart` starts it over from scratch (its new snapshot was
+ * journaled just before), in its worktree reset to the run branch's tip.
+ * `resume` picks up where it stopped (see `resumedProgress`).
+ */
+export const retriedChange = ({
+    progress,
+    retried,
+}: {
+    progress: TicketProgress
+    retried: RetriedContent
+}): Partial<TicketProgress> => {
+    switch (retried.mode) {
+        case 'refused':
+            return { reply: null }
+        case 'restart':
+            return {
+                ...EMPTY_TICKET_PROGRESS,
+                worktree:
+                    progress.worktree === null || retried.base_sha === null
+                        ? progress.worktree
+                        : { ...progress.worktree, base_sha: retried.base_sha },
+            }
+        case 'resume':
+            return resumedProgress({ progress })
+    }
+}
+
+/**
+ * A stuck ticket resumed by `retry`: it picks up where it stopped, with a
+ * fresh agent (no session is kept) and fresh counts (fix rounds, failed
+ * tries, bad-test bounces, environment reruns, rebases, test updates), and keeps whatever the
+ * user changed in its worktree. An open test update is dropped. The step that got stuck runs again:
+ * - before the red commit, a fresh test-writer writes the tests;
+ * - before the green commit, a fresh implementer builds (on top of the run
+ *   branch after a rebase), then the gates;
+ * - in a review fix round, the round starts over as round 1 with fresh
+ *   fixers, so the user's changes are gated, committed, and re-reviewed;
+ * - a leftover scan, a failed install, a failed prepare command at the
+ *   baseline, a reviewer's failed tries, a failed join, a refused undo of
+ *   its join (#519), or a step crashes cut off just run again.
+ */
+const resumedProgress = ({
+    progress,
+}: {
+    progress: TicketProgress
+}): Partial<TicketProgress> => {
+    const { stuck, commits, review_fix, rejoin } = progress
+    const base: Partial<TicketProgress> = {
+        stuck: null,
+        stuck_report: null,
+        reply: null,
+        retried: stuck,
+        setup_change: null,
+        agent_failure: null,
+        failed_tries: {},
+        engine_failures: 0,
+        sessions: {},
+        red_fix_rounds: 0,
+        gate_fix_rounds: 0,
+        environment_reruns: 0,
+        environment: null,
+        bad_test_bounces: 0,
+        bad_test_sources: [],
+        rejoins: 0,
+        test_updates: 0,
+        test_update: null,
+        install:
+            progress.install?.check?.ok === false ? null : progress.install,
+        prepare: progress.prepare?.ok === false ? null : progress.prepare,
+        leftovers: {
+            red: commits.red === null ? null : progress.leftovers.red,
+            green: commits.green === null ? null : progress.leftovers.green,
+            fix: commits.fix === null ? null : progress.leftovers.fix,
+        },
+    }
+    const reason = stuck?.reason
+    const reviewerFailed = progress.agent_failure?.role === 'ticket-reviewer'
+    if (
+        reason === 'leftovers_found' ||
+        reason === 'install_failed' ||
+        reason === 'prepare_failed' ||
+        reason === 'join_failed' ||
+        reason === 'join_gates_failed' ||
+        reason === 'undo_refused' ||
+        reason === 'crashed' ||
+        reviewerFailed
+    ) {
+        return base
+    }
+    if (commits.green === null) {
+        if (
+            rejoin === null &&
+            commits.red === null &&
+            progress.test_writer !== null
+        ) {
+            return {
+                ...base,
+                test_writer: null,
+                red_check: null,
+                red_tests: [],
+                already_done_check: null,
+            }
+        }
+        return { ...base, implementer: null, gates: null }
+    }
+    if (review_fix === null) return base
+    return {
+        ...base,
+        review_rounds: 1,
+        review_fix: {
+            ...review_fix,
+            round: 1,
+            tests_answered: !review_fix.findings.some(
+                ({ kind }) => kind === 'test'
+            ),
+            code_answered: !review_fix.findings.some(
+                ({ kind }) => kind === 'code'
+            ),
+            responses: [],
+            handed_off: {},
+            bad_test: null,
+        },
+        gates: null,
+        leftovers: { ...base.leftovers!, fix: null },
+        commits: { ...commits, fix: null },
+        commit_files: { ...progress.commit_files, fix: [] },
+    }
+}

package/engine/journal/worktree-entries.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod'
+
+import { ENTRY_FIELDS } from './entry-fields'
+
+import { BadTestSchema } from '../agents/role-results'
+import { GateCheckSchema, TestRunSchema } from '../gates/gate-schemas'
+
+/**
+ * The journal entries of the run's worktrees: made, prepared, their
+ * baseline tests, reset, and removed.
+ */
+
+/** A git worktree the engine made: where, on which branch, from which commit. */
+const WorktreeSchema = z.object({
+    branch: z.string().min(1),
+    path: z.string().min(1),
+    base_sha: z.string().min(1),
+})
+
+/**
+ * The run branch's worktree. `changesets` is true when the repo had
+ * `.changeset/config.json` there, so the engine writes a changeset before
+ * the PR (#461).
+ */
+export const RunBranchCreatedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('run_branch_created'),
+    content: WorktreeSchema.extend({
+        changesets: z.boolean().default(false),
+    }),
+})
+
+export const TicketWorktreeCreatedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('ticket_worktree_created'),
+    content: WorktreeSchema,
+})
+
+/**
+ * The config's prepare command (#481), run in a new ticket worktree before
+ * its baseline tests. Journaled only with a prepare command. A failed one
+ * leaves the baseline tests unrun.
+ */
+export const BaselinePreparedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('baseline_prepared'),
+    content: z.object({ check: GateCheckSchema }),
+})
+
+/**
+ * New untracked paths a run of the config's prepare command made in a
+ * checkout (#486): there after it ran, not before, such as a symlinked
+ * tools folder or a build file the repo's `.gitignore` misses. They are not
+ * an agent's work, so the engine never commits them or judges them by role
+ * rules, in any checkout of the run. Journaled right after the prepare run
+ * (at the baseline, the red check, or the gates), only when it made any.
+ * `ticket` is the step's, as on its `gates_run`: `null` in the final review.
+ *
+ * With `outside_links`, the paths are untracked symlinks pointing outside
+ * their checkout, found just before a commit rather than around a prepare
+ * run (#496): most likely a prepare run's from before the engine noted what
+ * prepare made (an older engine's run, resumed). No commit may hold such a
+ * link, so the engine leaves them out the same way.
+ */
+export const PrepareMadeEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('prepare_made'),
+    content: z.object({
+        /** Worktree-relative, as git lists them (`git ls-files --others`). */
+        paths: z.array(z.string()),
+        /** `true` when found as outside-pointing links before a commit. */
+        outside_links: z.boolean().optional(),
+    }),
+})
+
+/** The tests as they stood before any agent worked on a ticket. */
+export const BaselineTestsEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('baseline_tests'),
+    content: TestRunSchema,
+})
+
+/**
+ * A ticket took another ticket's baseline instead of running the tests
+ * again: both worktrees started from the same run-branch commit, `base_sha`.
+ */
+export const BaselineReusedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('baseline_reused'),
+    content: z.object({
+        from_ticket: z.number().int().positive(),
+        base_sha: z.string().min(1),
+    }),
+})
+
+/**
+ * The engine threw away every uncommitted change in a ticket's worktree, back
+ * to `sha`, so a fresh test-writer starts clean after a bad test.
+ */
+export const WorktreeResetEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('worktree_reset'),
+    content: z.object({
+        sha: z.string().min(1),
+        /**
+         * The engine found this mapped test checks nothing (#581); a fresh
+         * test-writer replaces it. Left out when the implementer sent a test
+         * back.
+         */
+        bad_test: BadTestSchema.optional(),
+    }),
+})
+
+/**
+ * The engine removed these git worktrees at the end of a run. Their branches
+ * and the journal are kept.
+ */
+export const WorktreesRemovedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('worktrees_removed'),
+    content: z.object({ paths: z.array(z.string().min(1)) }),
+})