@alecsibilia/luca 14.0.0-alpha.19 → 14.0.0-alpha.20

package/CHANGELOG.md

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

package/board/package.json

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

package/board/server/board-vocabulary-review.ts

@@ -14,6 +14,11 @@ export const REVIEW_VOCABULARY = {
         /** `ship` is only for a stuck final review. */
         word: z.enum(['retry', 'skip', 'stop', 'ship']),
         ticket: z.number().int().nullable().optional(),
+        /**
+         * The tokens a `retry` of the run stuck on its budget added (#543);
+         * absent before top-ups, when it added one whole budget.
+         */
+        top_up: z.number().int().positive().optional().catch(undefined),
     }),
     /** A reply the engine couldn't use; it answered why on the spec issue. */
     reply_ignored: z.looseObject({

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.19"
+export const LUCA_VERSION: string = "14.0.0-alpha.20"

package/board/server/record-texts.ts

@@ -53,6 +53,10 @@ export const ignoredText = ({
             return 'nothing is stuck right now'
         case 'ship_needs_final_review':
             return '`ship` is only for a stuck final review'
+        case 'amount_only_for_run_budget':
+            return 'an amount is only for a run stuck on its budget'
+        case 'bad_amount':
+            return 'the amount is not a whole number above zero'
         default:
             return reason.replaceAll('_', ' ')
     }

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

@@ -75,6 +75,7 @@ export const createBoardState = ({
     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,

package/board/server/reduce-board-needs-you.ts

@@ -151,14 +151,20 @@ const replyReceived = ({
                     key: ticketKey({ ticket }),
                 })
             }
-            // A bare `retry` while the run is stuck on its budget adds one
-            // more full budget; the final review is left as it is.
+            // A bare `retry` while the run is stuck on its budget adds its
+            // top-up (one whole budget for a retry journaled with none,
+            // #543); stuck for another reason, no budget. The final review
+            // is left as it is.
             if (state.needs_you.some((item) => item.key === RUN_KEY)) {
+                const top_up =
+                    state.run_stuck_reason === 'run_budget'
+                        ? (record.content.top_up ?? state.run_budget_each)
+                        : 0
                 return resolveNeedsYou({
                     state: {
                         ...state,
-                        run_budget_tokens:
-                            state.run_budget_tokens + state.run_budget_each,
+                        run_budget_tokens: state.run_budget_tokens + top_up,
+                        run_stuck_reason: null,
                     },
                     key: RUN_KEY,
                 })
@@ -245,7 +251,7 @@ export const applyNeedsYouKind = ({
         }
         case 'run_stuck':
             return addNeedsYou({
-                state,
+                state: { ...state, run_stuck_reason: record.content.reason },
                 item: {
                     key: RUN_KEY,
                     ticket: null,

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

@@ -49,7 +49,7 @@ export const finalReasonText = ({ reason }: { reason: string }): string =>
 /** Why the whole run is stuck (`run_stuck`'s reason), in words. */
 const RUN_STUCK_REASONS: Record<string, string> = {
     run_budget:
-        'The run used up its run budget of tokens. `retry` adds one more full budget.',
+        'The run used up its run budget of tokens. `retry` adds half a budget more, and `retry +3M` the amount named.',
     pull_request_failed:
         "The run's pull request didn't open. `retry` tries again, reusing a PR already open from the run branch.",
 }

package/board/shared/board-state.ts

@@ -74,12 +74,19 @@ export const BoardStateSchema = z.object({
     run_tokens: z.number().min(0).default(0),
     /**
      * The tokens the run may use before it is stuck (#435): one full run
-     * budget, plus one more for each `retry` the owner gave it. Defaulted,
-     * so an older board state still parses.
+     * budget, plus the top-up of each `retry` the owner gave the run stuck
+     * on its budget (#543; one whole budget for a retry journaled with no
+     * top-up). Defaulted, so an older board state still parses.
      */
     run_budget_tokens: z.number().min(0).default(DEFAULT_RUN_BUDGET_TOKENS),
     /** One full run budget: the engine config's, else the default. */
     run_budget_each: z.number().min(0).default(DEFAULT_RUN_BUDGET_TOKENS),
+    /**
+     * Why the whole run is stuck (`run_stuck`'s reason), until the owner's
+     * reply; `null` while it isn't. Defaulted, so an older board state
+     * still parses.
+     */
+    run_stuck_reason: z.string().nullable().default(null),
     /**
      * The engine config's `models.confidence_bar` (#630): the decision
      * model is sharp at or over it. Defaulted, so an older board state

package/board/shared/reply-actions.ts

@@ -54,14 +54,20 @@ export type ReplyParts = {
 
 const REPLY_PATTERN = /^(retry|skip|stop|ship)(?: #(\d+))?$/
 
+/** `retry` with an amount for the run stuck on its budget (#543). */
+const AMOUNT_REPLY_PATTERN = /^retry \+\S+$/
+
 /**
- * Splits one of `allowedReplies` into its word and ticket, to match it
- * with the engine's `reply_received`. `null` for anything else.
+ * Splits one of `allowedReplies`, or a `retry +<amount>` the owner typed,
+ * into its word and ticket, to match it with the engine's `reply_received`.
+ * `null` for anything else.
  *
  * @example
  * replyParts({ reply: 'retry #12' }) // { word: 'retry', ticket: 12 }
+ * replyParts({ reply: 'retry +3M' }) // { word: 'retry', ticket: null }
  */
 export const replyParts = ({ reply }: { reply: string }): ReplyParts | null => {
+    if (AMOUNT_REPLY_PATTERN.test(reply)) return { word: 'retry', ticket: null }
     const match = REPLY_PATTERN.exec(reply)
     const word = z.enum(['retry', 'skip', 'stop', 'ship']).safeParse(match?.[1])
     if (!match || !word.success) return null

package/engine/agents/agent-launcher.ts

@@ -100,7 +100,10 @@ export type LauncherFailure = z.infer<typeof LauncherFailureSchema>
  * the same way; a success with no structured output is a failed try.
  * `session_id` names the session the turn ran in, so the engine can send that
  * same agent a follow-up in a fix loop. `session` is the launcher's summary
- * of the model session, for the journal.
+ * of the model session, for the journal. `session_gone` marks a follow-up
+ * that found its session closed or unknown (#521): no agent ran, and the
+ * engine hands the follow-up's message to a fresh agent. `out_of_turns`
+ * marks a turn that reached its role's turn limit (#543).
  */
 export type AgentTurn =
     | {
@@ -115,6 +118,8 @@ export type AgentTurn =
           error: string
           session_id?: string
           session?: AgentSession
+          session_gone?: boolean
+          out_of_turns?: boolean
       }
 
 /**
@@ -179,7 +184,7 @@ export type AgentLauncher = {
      * as a failed gate's output in a fix loop, and returns the session's new
      * result. The agent keeps everything it knew from its earlier turns, the
      * guards it was launched with, and its model. A session the launcher doesn't know,
-     * or one that has closed, is an engine failure.
+     * or one that has closed, is an engine failure with `session_gone`.
      *
      * @example
      * const turn = await launcher.followUp({ session_id, role: 'implementer', ticket: 11, message: 'lint failed: ...', cwd, config })

package/engine/agents/claude-launcher.ts

@@ -107,6 +107,7 @@ export const createClaudeLauncher = ({
                 ok: false,
                 failure: 'engine',
                 session_id,
+                session_gone: true,
                 error: `No open agent session ${session_id}: it closed or never started.`,
             }
         }

package/engine/agents/claude-messages.ts

@@ -103,6 +103,8 @@ export type Failed = {
     ok: false
     failure: 'agent' | 'engine' | 'stop' | 'plan'
     error: string
+    /** The turn reached its role's turn limit (#543). */
+    out_of_turns?: boolean
 }
 
 export type Outcome = { ok: true; structured_output: unknown } | Failed

package/engine/agents/common-instructions.ts

@@ -1,6 +1,7 @@
 /**
  * The instruction sections more than one role gets: the shell rules, agent
- * messages, helpers, the rules for every agent, and fixing review findings.
+ * messages, helpers, the sandbox, the repo's rule files, the rules for every
+ * agent, and fixing review findings.
  */
 import type { AgentRole } from './role-results'
 
@@ -72,6 +73,28 @@ export const COMMON = `## Rules for every agent
 - "run_notes": at most 3 short facts about this repo that would help later agents in this run. Can be empty.
 - Finish by giving your structured result. A turn without one counts as failed.`
 
+/** What every role's sandbox blocks, and that the gates run outside it (#540). */
+export const SANDBOX = `## Your sandbox
+- The engine runs the gates (tests, types, lint) outside your sandbox and gives you their results.
+- The sandbox blocks the network and local ports, writes outside your worktree, git internals, \`node_modules\`, lockfiles, test setup files, test files for roles that may not edit them, and secret files.
+- A command that fails only inside your sandbox isn't yours to fix or work around. Rely on the engine's gate results, and say so.`
+
+/**
+ * The writers' list of the repo's rule files (#646), named, not pasted in,
+ * or nothing when the repo names none.
+ */
+export const repoRules = ({ config }: { config: EngineConfig }): string[] =>
+    config.rule_files.length === 0
+        ? []
+        : [
+              [
+                  '## Repo rules',
+                  "This repo's rules are in these files:",
+                  ...config.rule_files.map((path) => `- \`${path}\``),
+                  'Read them before you start, and follow them.',
+              ].join('\n'),
+          ]
+
 export const REVIEW_FIXER = `## Fixing review findings
 Sometimes you are sent a ticket review's findings to fix, after the ticket's work is committed, or the final review's findings to fix on the whole run branch, after every ticket joined it. Then:
 - Fix each finding you were sent, keeping to your role's rules.

package/engine/agents/open-session.ts

@@ -161,6 +161,7 @@ export const watch = ({
         ok: false,
         failure: 'agent',
         error: `The agent's turn ended with ${done.subtype}: ${detail}`,
+        ...(done.subtype === 'error_max_turns' ? { out_of_turns: true } : {}),
     }
 }
 

package/engine/agents/role-instructions.ts

@@ -2,7 +2,14 @@
  * Each role's instructions, put together from the role's task section and
  * the shared sections.
  */
-import { COMMON, HELPERS, MESSAGES, shellRules } from './common-instructions'
+import {
+    COMMON,
+    HELPERS,
+    MESSAGES,
+    repoRules,
+    SANDBOX,
+    shellRules,
+} from './common-instructions'
 import { LEARNER, LEARNER_RULES } from './learner-instructions'
 import { LENS, REVIEWER } from './reviewer-instructions'
 import { lensOf, type AgentRole } from './role-results'
@@ -21,7 +28,9 @@ import { canMessage } from '../messages/agent-messages'
  * reviewers aren't. Each final review lens gets its own focus; the
  * integration lens also gives the PR's Summary picture and Merge Danger
  * (#513). The learner (#370) gets its own task and rules: no shell,
- * nothing written. Every role is told about its read-only helpers (#627).
+ * nothing written. Every role is told about its read-only helpers (#627),
+ * and what its sandbox blocks (#540). The writers, as final review fixers
+ * too, are told where the repo's rule files are (#646).
  *
  * @example
  * const append = roleInstructions({ role: 'implementer', may_edit_tests: false, config })
@@ -43,7 +52,7 @@ export const roleInstructions = ({
 }): string => {
     // The learner has no shell and no agent messages, and its rules differ.
     if (role === 'learner')
-        return [LEARNER, HELPERS, LEARNER_RULES].join('\n\n')
+        return [LEARNER, HELPERS, SANDBOX, LEARNER_RULES].join('\n\n')
     const lens = lensOf({ role })
     const task =
         lens !== null
@@ -55,9 +64,13 @@ export const roleInstructions = ({
                 : REVIEWER
     return [
         task,
+        ...(role === 'test-writer' || role === 'implementer'
+            ? repoRules({ config })
+            : []),
         shellRules({ role, config }),
         ...((messaging ?? canMessage({ role })) ? [MESSAGES] : []),
         HELPERS,
+        SANDBOX,
         COMMON,
     ].join('\n\n')
 }

package/engine/agents/scripted-launcher.ts

@@ -50,6 +50,8 @@ export type ScriptedTurn = {
     result?: unknown
     failure?: LauncherFailure
     error?: string
+    /** With `failure`: the turn reached its role's turn limit (#543). */
+    out_of_turns?: boolean
     /** A session summary for the engine to journal. */
     session?: AgentSession
 }
@@ -169,6 +171,7 @@ export const createScriptedLauncher = ({
                 failure: turn.failure,
                 session_id,
                 error: turn.error ?? `The scripted ${role} failed.`,
+                ...(turn.out_of_turns === true ? { out_of_turns: true } : {}),
                 ...session,
             }
         }
@@ -223,6 +226,7 @@ export const createScriptedLauncher = ({
                     ok: false,
                     failure: 'engine',
                     session_id,
+                    session_gone: true,
                     error: `No scripted session ${session_id}.`,
                 }
             }

package/engine/core/agent-guards-helpers.ts

@@ -3,6 +3,7 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
 import { afterAll, beforeAll } from 'bun:test'
+import omit from 'lodash/omit'
 
 import type { ScriptedTurn } from '../agents/scripted-launcher'
 import type { JournalRecord } from '../journal/journal-record'
@@ -18,9 +19,15 @@ import { createPracticeRepo } from '../testing/practice-repo'
 export type Practice = Awaited<ReturnType<typeof createPracticeRepo>>
 export type Ran = Awaited<ReturnType<Practice['run']>>
 
+/**
+ * Each failed turn's content, without `session_gone` (#521) or `out_of_turns`
+ * (#543): no guard test follows up a gone session or reaches a turn limit.
+ */
 export const failures = (records: JournalRecord[]) =>
     records.flatMap((record) =>
-        record.kind === 'agent_failed' ? [record.content] : []
+        record.kind === 'agent_failed'
+            ? [omit(record.content, 'session_gone', 'out_of_turns')]
+            : []
     )
 
 export const commits = (records: JournalRecord[]) =>

package/engine/core/agent-turn.ts

@@ -31,6 +31,8 @@ const failTurn = ({
     error,
     failure,
     session_id,
+    session_gone,
+    out_of_turns,
 }: {
     context: BuildContext
     ticket: number | null
@@ -38,12 +40,21 @@ const failTurn = ({
     error: string
     failure: AgentFailure
     session_id: string | null
+    session_gone: boolean
+    out_of_turns: boolean
 }) => {
     context.journal.append({
         kind: 'agent_failed',
         ticket,
         role,
-        content: { role, error, failure, session_id },
+        content: {
+            role,
+            error,
+            failure,
+            session_id,
+            ...(session_gone ? { session_gone } : {}),
+            ...(out_of_turns ? { out_of_turns } : {}),
+        },
     })
 }
 
@@ -144,27 +155,54 @@ export const runTurn = async ({
         throw new Error(`Run stopped: ${turn.error}`)
     }
     const session_id = turn.session_id ?? null
-    const fail = (failure: AgentFailure, error: string) => {
-        failTurn({ context, ticket, role, error, failure, session_id })
+    const fail = ({
+        failure,
+        error,
+        session_gone = false,
+        out_of_turns = false,
+    }: {
+        failure: AgentFailure
+        error: string
+        session_gone?: boolean
+        out_of_turns?: boolean
+    }) => {
+        failTurn({
+            context,
+            ticket,
+            role,
+            error,
+            failure,
+            session_id,
+            session_gone,
+            out_of_turns,
+        })
         return null
     }
     if (violations.length > 0) {
-        return fail(
-            'guard',
-            describeViolations({ role: guard_role, violations })
-        )
+        return fail({
+            failure: 'guard',
+            error: describeViolations({ role: guard_role, violations }),
+        })
     }
     if (!turn.ok) {
-        return fail(turn.failure === 'engine' ? 'engine' : 'agent', turn.error)
+        return fail({
+            failure: turn.failure === 'engine' ? 'engine' : 'agent',
+            error: turn.error,
+            session_gone: turn.session_gone === true,
+            out_of_turns: turn.out_of_turns === true,
+        })
     }
     if (
         turn.structured_output === undefined ||
         turn.structured_output === null
     ) {
-        return fail('result', `The ${role} finished with no structured output.`)
+        return fail({
+            failure: 'result',
+            error: `The ${role} finished with no structured output.`,
+        })
     }
     const checked = parseRoleResult({ role, output: turn.structured_output })
-    if (!checked.ok) return fail('result', checked.error)
+    if (!checked.ok) return fail({ failure: 'result', error: checked.error })
     // The chores the writer asked for (#618), before any check or commit.
     const problems = await doChores({
         context,
@@ -174,7 +212,10 @@ export const runTurn = async ({
         guard: { role: guard_role, may_edit_tests },
     })
     if (problems.length > 0) {
-        return fail('chore', problems.map((line) => `- ${line}`).join('\n'))
+        return fail({
+            failure: 'chore',
+            error: problems.map((line) => `- ${line}`).join('\n'),
+        })
     }
     context.journal.append({
         kind: 'agent_finished',

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

@@ -112,7 +112,8 @@ export const fixStep = (args: DecideArgs): FinalReviewAction | null => {
     const { review, run_branch, snapshot } = args
     const { fix } = review
     if (fix === null) return null
-    if (fix.round > MAX_FIX_ROUNDS) {
+    // The fresh pass's one fix round runs past the cap (#548).
+    if (fix.round > MAX_FIX_ROUNDS && !review.fresh) {
         return stuck({
             reason: 'changes_requested',
             detail: `The final review still asks for changes after ${MAX_FIX_ROUNDS} fix rounds:\n${openFinalFindingsText({ findings: fix.findings })}`,
@@ -164,14 +165,19 @@ export const fixStep = (args: DecideArgs): FinalReviewAction | null => {
             })
         }
         const session_id = review.sessions.implementer
+        const message = gateFixMessage({ gates })
         if (session_id === undefined) {
-            return launchFixer({ ...args, role: 'implementer' })
+            return launchFixer({
+                ...args,
+                role: 'implementer',
+                follow_up: message,
+            })
         }
         return {
             type: 'follow_up_final_fixer',
             role: 'implementer',
             session_id,
-            message: gateFixMessage({ gates }),
+            message,
         }
     }
     if (review.commit === null) {

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

@@ -61,9 +61,14 @@ const lensStep = ({
  * tests once every lens finished, and settles only once they ran; failing
  * ones open the fix round (or join it). A fix round with no finding, opened only
  * by them, is just its gates (which run the slow tests again) with their
- * fix loop, the commit, and the push, and the review passes there.
+ * fix loop, the commit, and the push, with no lens re-review.
  * A review still asking for changes after `MAX_FIX_ROUNDS` fix
  * rounds is stuck, and so is a failed fix loop, a bad test, or a leftover.
+ * Once a fix commit was pushed and no blocking finding is left, the fresh
+ * pass (#548) has all five lenses read the whole branch again, without
+ * 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
  * 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.
@@ -117,15 +122,31 @@ export const decideFinalReview = (args: DecideArgs): FinalReviewDecision => {
     if (review.slow_due && review.slow_tests === null) {
         return working([{ type: 'run_final_slow_tests' }])
     }
-    if (review.fix === null) return working([{ type: 'pass_final_review' }])
+    // Clean after a fix commit: every lens reads the whole branch once more,
+    // fresh, before the PR opens (#548). Once per final review; with no fix
+    // commit, round 1 was already a full fresh read.
+    const ending: FinalReviewAction =
+        review.fix_pushed && !review.fresh_started
+            ? {
+                  type: 'start_final_review',
+                  round: review.round + 1,
+                  from_sha: run_branch.base_sha,
+                  lenses: [...LENS_NAMES],
+                  fresh: true,
+              }
+            : { type: 'pass_final_review' }
+    if (review.fix === null) return working([ending])
+    // The fresh pass's fix was re-checked: what is still open tops the PR,
+    // and the final review never gets stuck on it (#548).
+    if (review.fresh_started && !review.fresh) {
+        return working([{ type: 'pass_final_review' }])
+    }
     const step = fixStep(args)
     if (step !== null) return working([step])
     // A fix round opened only by failing slow tests ends at its push: its
     // gates ran the slow tests on what was pushed, and no lens had a finding
-    // to look at again (#563).
-    if (review.fix.findings.length === 0) {
-        return working([{ type: 'pass_final_review' }])
-    }
+    // to look at again (#563), so the fresh pass comes next.
+    if (review.fix.findings.length === 0) return working([ending])
     // The fixes are pushed: the lenses with blocking findings look again.
     return working([
         {

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

@@ -1,12 +1,22 @@
-import { pendingReplies, waitForReply, type StuckAction } from './decide-stuck'
+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'
 
@@ -38,13 +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. A run whose PR
- * didn't open (#508) is stuck the same way, told why, and a `retry` tries
- * the PR again, adding no budget. `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.
  *
@@ -62,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 [
             {
@@ -90,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,
         },
     ]
 }