@alecsibilia/luca 14.0.0-alpha.26 → 14.0.0-alpha.28

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.28
+
+No changes in this release.
+
+## 14.0.0-alpha.27
+
+No changes in this release.
+
 ## 14.0.0-alpha.26
 
 ### Patch Changes

package/board/client/model-line.tsx

@@ -36,8 +36,8 @@ const capital = ({ text }: { text: string }): string =>
  * doesn't know.
  *
  * @example
- * clefLine({ model: { role: 'implementer', name: 'opus', reason: 'unsure', answer: { role: 'implementer', pick: 'sonnet', confidence: 0.56 } }, bar: 0.8 })
- * // { short: '0.56 split → stayed on opus', full: 'Clef picked sonnet but was only 0.56 sure (split: under 0.8), so Luca stayed on opus.', confidence: 0.56, sharp: false }
+ * clefLine({ model: { role: 'implementer', name: 'opus', reason: 'unsure', answer: { role: 'implementer', pick: 'sonnet', confidence: 0.36 } }, bar: 0.5 })
+ * // { short: '0.36 split → stayed on opus', full: 'Clef picked sonnet but was only 0.36 sure (split: under 0.5), so Luca stayed on opus.', confidence: 0.36, sharp: false }
  */
 export const clefLine = ({
     model,
@@ -54,10 +54,11 @@ export const clefLine = ({
     const sure = confidence?.toFixed(2) ?? ''
     const judged = `${word}: ${sharp ? 'at or over' : 'under'} ${bar}`
     const plain = { confidence: null, sharp: false }
+    const picked = `${confidence === null ? 'clef' : `${sure} ${word}`} → ${name}`
     switch (reason) {
         case 'decision_model':
             return {
-                short: `${confidence === null ? 'clef' : `${sure} ${word}`} → ${name}`,
+                short: picked,
                 full:
                     confidence === null
                         ? `Clef picked ${name}, so Luca ran the ${role} on it.`
@@ -65,6 +66,16 @@ export const clefLine = ({
                 confidence,
                 sharp,
             }
+        case 'trial':
+            return {
+                short: `${picked} (trial)`,
+                full:
+                    confidence === null
+                        ? `Clef picked ${name}, and Luca ran the ${role} on it in a model trial.`
+                        : `Clef picked ${name} and was ${sure} sure (${judged}), and Luca ran the ${role} on it in a model trial.`,
+                confidence,
+                sharp,
+            }
         case 'unsure':
             return {
                 short: `${confidence === null ? 'unsure' : `${sure} ${word}`} → stayed on ${name}`,

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.26",
+    "version": "14.0.0-alpha.28",
     "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.26"
+export const LUCA_VERSION: string = "14.0.0-alpha.28"

package/board/shared/board-state-run.ts

@@ -94,7 +94,7 @@ export const DEFAULT_RUN_BUDGET_TOKENS = 9_000_000
  * `engine/src/config/engine-config-schema.ts`): the decision model is sharp at or
  * over it, split under it. Kept here for the same reason.
  */
-export const DEFAULT_CONFIDENCE_BAR = 0.8
+export const DEFAULT_CONFIDENCE_BAR = 0.5
 
 export const EngineEndedSchema = z.object({
     ok: z.boolean(),

package/engine/agents/agent-launcher.ts

@@ -103,7 +103,9 @@ export type LauncherFailure = z.infer<typeof LauncherFailureSchema>
  * 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).
+ * marks a turn that reached its role's turn limit (#543). `session_closed`
+ * marks a turn interrupted for running past its time limit (#685): the
+ * launcher closed its session, so no follow-up can reach it.
  */
 export type AgentTurn =
     | {
@@ -120,6 +122,7 @@ export type AgentTurn =
           session?: AgentSession
           session_gone?: boolean
           out_of_turns?: boolean
+          session_closed?: boolean
       }
 
 /**
@@ -178,6 +181,12 @@ export type AgentLauncher = {
          * session's follow-ups run at it too.
          */
         effort: EffortLevel
+        /**
+         * The turn limit for this launch (#684), in place of its role's: a
+         * lens whose last try ran out of turns gets twice its role's. Left
+         * out, the role's limit.
+         */
+        max_turns?: number
         /**
          * Hears the turn's live progress (#628) each time it changes, before
          * the turn ends, for the engine's live file. Left out, nothing hears it.

package/engine/agents/claude-messages.ts

@@ -105,6 +105,8 @@ export type Failed = {
     error: string
     /** The turn reached its role's turn limit (#543). */
     out_of_turns?: boolean
+    /** The turn ran past its time limit, and its session was closed (#685). */
+    session_closed?: boolean
 }
 
 export type Outcome = { ok: true; structured_output: unknown } | Failed

package/engine/agents/claude-options.ts

@@ -16,6 +16,7 @@ import {
     TicketReviewResultSchema,
     type AgentRole,
 } from './role-results'
+import { MAX_TURNS } from './role-turns'
 
 import {
     DEFAULT_MODEL,
@@ -27,29 +28,14 @@ import { HELPER_TYPE, SEARCHER } from '../guards/helper-rules'
 import { guardRoleOf, permissionRules } from '../guards/role-rules'
 import { sandboxSettings } from '../guards/sandbox-settings'
 
+export { MAX_TURNS } from './role-turns'
+
 /** The models an agent may launch on, by short name (`ModelNameSchema`). */
 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. 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: 150,
-    'ticket-reviewer': 60,
-    'architecture-lens': 60,
-    'simplification-lens': 60,
-    'security-lens': 60,
-    'integration-lens': 100,
-    'rules-lens': 60,
-    learner: 40,
-}
-
 /**
  * Why a model may not launch an agent, or `null` if it may: exactly one of
  * `MODEL_NAMES`. Every other short name is refused, since some (such as
@@ -181,6 +167,7 @@ export const agentOptions = ({
     cwd,
     model,
     effort,
+    max_turns,
     claude_path,
     config,
     common_git_dir,
@@ -199,6 +186,8 @@ export const agentOptions = ({
     cwd: string
     model: string
     effort: EffortLevel
+    /** The launch's own turn limit (#684), in place of the role's; left out, the role's. */
+    max_turns?: number
     /** The real path of the installed `claude` binary. */
     claude_path: string
     config: EngineConfig
@@ -264,7 +253,7 @@ export const agentOptions = ({
         // Streamed chunks only feed the live file's heartbeat (#631); the
         // launcher keeps nothing of them.
         includePartialMessages: true,
-        maxTurns: MAX_TURNS[role],
+        maxTurns: max_turns ?? MAX_TURNS[role],
         hooks: {
             PreToolUse: [{ hooks: [guard_hook] }],
             ...(delivery_hook === null

package/engine/agents/launch-session.ts

@@ -80,6 +80,7 @@ export const createLaunch = ({
         messaging,
         model,
         effort,
+        max_turns,
         on_progress,
     }) => {
         const refused = checkLaunchModel({ model })
@@ -117,6 +118,7 @@ export const createLaunch = ({
             model,
             // Kept in the session's options, so its follow-ups run at it too.
             effort,
+            max_turns,
             claude_path: claudePath,
             config,
             common_git_dir: gitDir,

package/engine/agents/refactor-update-prompts.ts

@@ -0,0 +1,62 @@
+/**
+ * The texts of a refactor test update (#686): the section a fresh
+ * test-writer gets in place of the rejoin's test update section, the
+ * follow-up the implementer gets once it answered, and what the
+ * ticket-reviewer is told once it closed.
+ */
+
+/**
+ * The section a test-writer gets when a refactor ticket's implementer sent
+ * a test back as bad: why, and that it may change only that file.
+ *
+ * @example
+ * refactorUpdateSection({ file: 'src/rows.test.ts', reason: 'It pins the old order.' })
+ */
+export const refactorUpdateSection = ({
+    file,
+    reason,
+}: {
+    file: string
+    reason: string
+}): string =>
+    [
+        "## A refactor ticket's test was sent back as bad",
+        `The implementer says this test is wrong:\n\n- File: ${file}\n- Reason: ${reason || 'no reason given'}`,
+        `This is a refactor ticket. Change only ${file}, and only so it checks what the ticket's criteria say.`,
+        "The implementer's work is already in the worktree, so the test may pass now. That is fine here.",
+    ].join('\n\n')
+
+/**
+ * The follow-up a refactor ticket's implementer gets once the test-writer
+ * fixed the test it sent back.
+ *
+ * @example
+ * refactorTestFixedMessage({ file: 'src/rows.test.ts' })
+ */
+export const refactorTestFixedMessage = ({ file }: { file: string }): string =>
+    `The test-writer changed ${file} so it checks what the ticket's criteria say. Carry on with the refactor. You may follow renames into test files, but don't change what a test checks.`
+
+/**
+ * The section a refactor ticket's reviewer gets once a refactor test update
+ * fixed a test: which file, why, and that only that change to what a test
+ * checks is expected.
+ *
+ * @example
+ * refactorFixedReviewSection({ fixed: [{ file: 'src/rows.test.ts', reason: 'It pins the old order.' }] })
+ */
+export const refactorFixedReviewSection = ({
+    fixed,
+}: {
+    fixed: { file: string; reason: string }[]
+}): string =>
+    [
+        '## Tests a test-writer changed on purpose',
+        "The implementer sent these tests back as bad, and a test-writer changed them so they check what the ticket's criteria say. The engine checked it changed no other test file.",
+        fixed
+            .map(
+                ({ file, reason }) =>
+                    `- File: ${file}\n  Reason: ${reason || 'no reason given'}`
+            )
+            .join('\n'),
+        "This change to what these tests check is expected: judge it against the ticket's criteria, not as a behavior change. Any other change to what a test checks is still a blocker.",
+    ].join('\n\n')

package/engine/agents/role-turns.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure: how many model turns each role gets, whatever launcher runs it. A
+ * launch's own `max_turns` (#684) replaces its role's.
+ */
+import type { AgentRole } from './role-results'
+
+/**
+ * How many model turns one agent gets before its try ends. The integration
+ * lens reads how every ticket fits together on the whole branch, and the
+ * rules lens reads every rule file against it (#684), so they get more than
+ * the other lenses.
+ */
+export const MAX_TURNS: Record<AgentRole, number> = {
+    'test-writer': 80,
+    implementer: 150,
+    'ticket-reviewer': 60,
+    'architecture-lens': 60,
+    'simplification-lens': 60,
+    'security-lens': 60,
+    'integration-lens': 100,
+    'rules-lens': 100,
+    learner: 40,
+}

package/engine/agents/scripted-launcher.ts

@@ -78,6 +78,8 @@ export type ScriptedCall = {
      * `null` for a session the launcher doesn't know.
      */
     effort: EffortLevel | null
+    /** The turn limit a launch asked for (#684); left out when it asked for none. */
+    max_turns?: number
     /** What each of the turn's tool calls handed over, in order. */
     delivered: string[]
 }
@@ -204,6 +206,7 @@ export const createScriptedLauncher = ({
             messaging,
             model,
             effort,
+            max_turns,
         }) => {
             const session_id = `scripted-${role}-${ticket}-${calls.length + 1}`
             sessions.set(session_id, { messaging, model, effort })
@@ -216,6 +219,7 @@ export const createScriptedLauncher = ({
                 may_edit_tests,
                 model,
                 effort,
+                ...(max_turns === undefined ? {} : { max_turns }),
                 delivered: [],
             }
             calls.push(call)

package/engine/agents/session-pool.ts

@@ -93,6 +93,7 @@ export const createSessionPool = ({
                       ok: false,
                       failure: 'agent',
                       error: `No result within ${timeoutMs} ms; the agent was interrupted.`,
+                      session_closed: true,
                   }
                 : raced
         if (raced === 'timeout') {

package/engine/config/engine-config-schema.ts

@@ -51,46 +51,84 @@ const JunitPathSchema = z.string().min(1).refine(isFileInsideRepo, {
         'must be a file inside the repo, relative to its root: not an absolute path, not one that leaves the repo with "..", and not ending in "/"',
 })
 
+/** The text a slow command's `run_files` must hold, where the files go (#683). */
+export const RUN_FILES_PLACEHOLDER = '{files}'
+
 /**
- * One entry of a `checks.test` list: a command, or a command and its kind.
- * A `junit` command names the JUnit files it writes in `junit_path` (#668),
- * one path or a list; no other kind may have one.
+ * One entry of a `checks.test` or `checks.slow_test` list: a command, or a
+ * command and its kind. A `junit` command names the JUnit files it writes in
+ * `junit_path` (#668), one path or a list; no other kind may have one. A slow
+ * entry may also name the test files it owns (`file_patterns`) and how to run
+ * some of them (`run_files`, #683); they come together, and a `checks.test`
+ * entry may have neither.
  */
-const TestCommandEntrySchema = z.union([
-    z.string().min(1),
-    z
-        .object({
-            run: z.string().min(1),
-            results: TestResultsSchema.optional(),
-            junit_path: z
-                .union([JunitPathSchema, z.array(JunitPathSchema).min(1)])
-                .optional(),
-        })
-        .refine(
-            ({ results, junit_path }) =>
-                results !== 'junit' || junit_path !== undefined,
-            {
-                message:
-                    'a "junit" test command needs junit_path: the JUnit files it writes, relative to the repo root',
-                path: ['junit_path'],
-            }
-        )
-        .refine(
-            ({ results, junit_path }) =>
-                results === 'junit' || junit_path === undefined,
-            {
-                message:
-                    'junit_path is only for a test command with "results": "junit"',
-                path: ['junit_path'],
-            }
-        ),
-])
+const testCommandEntrySchema = ({ slow }: { slow: boolean }) =>
+    z.union([
+        z.string().min(1),
+        z
+            .object({
+                run: z.string().min(1),
+                results: TestResultsSchema.optional(),
+                junit_path: z
+                    .union([JunitPathSchema, z.array(JunitPathSchema).min(1)])
+                    .optional(),
+                file_patterns: z.array(z.string().min(1)).min(1).optional(),
+                run_files: z.string().min(1).optional(),
+            })
+            .refine(
+                ({ file_patterns, run_files }) =>
+                    slow ||
+                    (file_patterns === undefined && run_files === undefined),
+                {
+                    message:
+                        'checks.test: file_patterns and run_files belong only on checks.slow_test entries.',
+                }
+            )
+            .refine(
+                ({ file_patterns, run_files }) =>
+                    !slow ||
+                    (file_patterns === undefined) === (run_files === undefined),
+                {
+                    message:
+                        'checks.slow_test: file_patterns and run_files come together; this entry has only one of them.',
+                }
+            )
+            .refine(
+                ({ run_files }) =>
+                    !slow ||
+                    run_files === undefined ||
+                    run_files.includes(RUN_FILES_PLACEHOLDER),
+                {
+                    message: `checks.slow_test: run_files must contain ${RUN_FILES_PLACEHOLDER}.`,
+                    path: ['run_files'],
+                }
+            )
+            .refine(
+                ({ results, junit_path }) =>
+                    results !== 'junit' || junit_path !== undefined,
+                {
+                    message:
+                        'a "junit" test command needs junit_path: the JUnit files it writes, relative to the repo root',
+                    path: ['junit_path'],
+                }
+            )
+            .refine(
+                ({ results, junit_path }) =>
+                    results === 'junit' || junit_path === undefined,
+                {
+                    message:
+                        'junit_path is only for a test command with "results": "junit"',
+                    path: ['junit_path'],
+                }
+            ),
+    ])
 
-/** A test command setting: one command, or a list of them (see `testCommands`). */
-const TestCommandsSchema = z.union([
-    z.string().min(1),
-    z.array(TestCommandEntrySchema),
-])
+/**
+ * A test command setting: one command, or a list of them (see
+ * `testCommands`). Only a slow one's entries may own files (#683).
+ */
+const testCommandsSchema = ({ slow }: { slow: boolean }) =>
+    z.union([z.string().min(1), z.array(testCommandEntrySchema({ slow }))])
 
 /** The config's `muninn` block. */
 export const MuninnConfigSchema = z.object({
@@ -178,12 +216,15 @@ const RoleEffortsSchema = z.strictObject(
 /**
  * The config's `models` block (#603): each routed role's model floor, each
  * writer's effort (#660), and how sure the decision model must be
- * (`confidence_bar`) before its model pick is used.
+ * (`confidence_bar`) before its model pick is used, and the share of its
+ * unsure but cheaper picks that run anyway in a model trial (`trial_share`,
+ * #698).
  */
 export const ModelsConfigSchema = z.object({
     floors: ModelFloorsSchema.prefault({}),
     effort: RoleEffortsSchema.prefault({}),
-    confidence_bar: z.number().min(0).max(1).default(0.8),
+    confidence_bar: z.number().min(0).max(1).default(0.5),
+    trial_share: z.number().min(0).max(1).default(0),
 })
 
 export type ModelsConfig = z.infer<typeof ModelsConfigSchema>
@@ -204,13 +245,15 @@ export type ModelsConfig = z.infer<typeof ModelsConfigSchema>
 export const EngineConfigSchema = z.object({
     checks: z
         .object({
-            test: TestCommandsSchema.optional(),
+            test: testCommandsSchema({ slow: false }).optional(),
             /**
              * The slow tests (#563): the tests `test` leaves out, run only at
-             * the final review. Same shape as `test`. Left out, nothing
+             * the final review. Same shape as `test`, and an entry may also
+             * own some test files and run them in a ticket's gates
+             * (`file_patterns`, `run_files`, #683). Left out, nothing
              * changes.
              */
-            slow_test: TestCommandsSchema.optional(),
+            slow_test: testCommandsSchema({ slow: true }).optional(),
             types: z.string().min(1).optional(),
             lint: z.string().min(1).optional(),
         })

package/engine/config/engine-config.ts

@@ -37,6 +37,7 @@ export {
     ModelsConfigSchema,
     MuninnConfigSchema,
     ROUTED_ROLES,
+    RUN_FILES_PLACEHOLDER,
     TestResultsSchema,
 } from './engine-config-schema'
 export type {
@@ -55,8 +56,10 @@ export {
     hasSlowTests,
     isBunTestCommand,
     junitCommands,
+    ownSlowCommands,
     slowTestCommands,
     testCommands,
+    type OwnSlowCommand,
     type TestCommand,
 } from './test-commands'
 

package/engine/config/test-commands.ts

@@ -77,6 +77,41 @@ export const slowTestCommands = ({
     config: EngineConfig
 }): TestCommand[] => commandsOf(config.checks.slow_test)
 
+/**
+ * A slow test command that runs some of its files (#683): the test files it
+ * owns, and the command with `{files}` where they go.
+ */
+export type OwnSlowCommand = { file_patterns: string[]; run_files: string }
+
+/**
+ * The slow test commands with `run_files` (#683), in config order: a
+ * ticket's gates run its own files that match `file_patterns` through them.
+ *
+ * @example
+ * ownSlowCommands({ config: { ...config, checks: { test: 'bun test src', slow_test: [{ run: 'bun run ui', file_patterns: ['ui/**'], run_files: 'bun run ui-files {files}' }] } } })
+ * // [{ file_patterns: ['ui/**'], run_files: 'bun run ui-files {files}' }]
+ */
+export const ownSlowCommands = ({
+    config,
+}: {
+    config: EngineConfig
+}): OwnSlowCommand[] => {
+    const value = config.checks.slow_test
+    if (value === undefined || typeof value === 'string') return []
+    return value.flatMap((entry) =>
+        typeof entry === 'string' ||
+        entry.file_patterns === undefined ||
+        entry.run_files === undefined
+            ? []
+            : [
+                  {
+                      file_patterns: entry.file_patterns,
+                      run_files: entry.run_files,
+                  },
+              ]
+    )
+}
+
 /** Whether the config has a slow test command (#563). */
 export const hasSlowTests = ({ config }: { config: EngineConfig }): boolean =>
     slowTestCommands({ config }).length > 0

package/engine/core/agent-turn.ts

@@ -3,6 +3,8 @@
  * ended, journaled. Also the `launch_agent` and `follow_up_agent` steps,
  * which start a turn.
  */
+import { basename } from 'node:path'
+
 import { need, ticketWorktree, type BuildContext } from './build-context'
 import { mayEditTests, type BuildAction } from './decide-build'
 import { doChores } from './engine-chores'
@@ -19,7 +21,11 @@ import { DEFAULT_MODEL, type EffortLevel } from '../config/engine-config'
 import { describeViolations } from '../guards/after-turn-check'
 import { guardRoleOf } from '../guards/role-rules'
 import { enforceAfterTurn, snapshotWorktree } from '../guards/worktree-state'
-import { launchPick, type ModelReason } from '../jev/model-pick'
+import {
+    launchPick,
+    type ModelReason,
+    type TrialGroup,
+} from '../jev/model-pick'
 import type { AgentFailure, JournalRecord } from '../journal/journal-record'
 import type { ReplayedWorktree } from '../journal/replay'
 import { sessionSignal } from '../limits/plan-signals'
@@ -66,7 +72,9 @@ const failTurn = ({
  * every launcher alike; what others changed in the shared `.git` meanwhile
  * is journaled as `shared_git_changed`. Then the result is judged by its
  * structured output. Each failed turn is journaled once as `agent_failed`
- * with how it failed; the decision step picks what happens next. A writer's
+ * with how it failed; the decision step picks what happens next. A turn the
+ * launcher interrupted for its time limit then journals its session closed
+ * (#685), since the launcher closed it. A writer's
  * result then gets its chores done (`doChores`, #618); one the engine could
  * not do fails the turn as a `chore` failure. A launcher stop journals
  * `run_stopped` and ends the run. A turn the plan cut off (a rejected limit,
@@ -177,6 +185,16 @@ export const runTurn = async ({
             session_gone,
             out_of_turns,
         })
+        // A timed-out turn's session was closed by the launcher (#685):
+        // journal the close, so the next try is a fresh agent.
+        if (!turn.ok && turn.session_closed === true && session_id !== null) {
+            context.journal.append({
+                kind: 'agent_session_closed',
+                ticket,
+                role,
+                content: { role, session_id },
+            })
+        }
         return null
     }
     if (violations.length > 0) {
@@ -241,13 +259,15 @@ const sessionOf = (record: JournalRecord): string | null => {
 }
 
 /**
- * The model a session launched on, and why (`null` before #603), and the
- * effort it runs at (`null` before #659).
+ * The model a session launched on, and why (`null` before #603), the
+ * effort it runs at (`null` before #659), and its model trial group
+ * (`null` when not eligible, or before #698).
  */
 export type SessionModel = {
     model: string
     model_reason: ModelReason | null
     effort: EffortLevel | null
+    trial_group: TrialGroup | null
 }
 
 /**
@@ -290,8 +310,8 @@ export const sessionModel = ({
                           record.content.follow_up_of === null
                   ))
     if (started?.kind !== 'agent_started') return null
-    const { model, model_reason, effort } = started.content
-    return model === null ? null : { model, model_reason, effort }
+    const { model, model_reason, effort, trial_group } = started.content
+    return model === null ? null : { model, model_reason, effort, trial_group }
 }
 
 /**
@@ -309,6 +329,7 @@ export const followUpModel = ({
         model: DEFAULT_MODEL,
         model_reason: null,
         effort: null,
+        trial_group: null,
     }
 
 export const launchAgent = async ({
@@ -323,10 +344,11 @@ export const launchAgent = async ({
     // a routed role's model; a reviewer is locked on Opus. A redo keeps
     // the model its first try journaled. The role's effort applies on any
     // model (#659).
-    const { model, model_reason } = launchPick({
+    const { model, model_reason, trial_group } = launchPick({
         records: context.journal.read(),
         state: context.state,
         config: context.config,
+        run_id: basename(context.run_dir),
         ticket,
         role,
         step: context.step,
@@ -343,6 +365,7 @@ export const launchAgent = async ({
             model,
             model_reason,
             effort,
+            trial_group,
         },
     })
     await runTurn({
@@ -382,7 +405,7 @@ export const followUpAgent = async ({
         value: context.state.snapshot?.tickets[ticket],
         what: `snapshot of #${ticket}`,
     })
-    const { model, model_reason, effort } = followUpModel({
+    const { model, model_reason, effort, trial_group } = followUpModel({
         records: context.journal.read(),
         session_id,
     })
@@ -397,6 +420,7 @@ export const followUpAgent = async ({
             model,
             model_reason,
             effort,
+            trial_group,
         },
     })
     await runTurn({