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

package/CHANGELOG.md

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

package/board/package.json

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

package/engine/agents/agent-launcher.ts

@@ -3,7 +3,7 @@ import { z } from 'zod'
 import type { AgentRole } from './role-results'
 import type { ProgressListener } from './turn-progress'
 
-import type { EngineConfig } from '../config/engine-config'
+import type { EffortLevel, EngineConfig } from '../config/engine-config'
 
 /** One model's tokens in one agent turn. */
 export const ModelTokensSchema = z.object({
@@ -173,6 +173,11 @@ export type AgentLauncher = {
          * follow-ups run on it too.
          */
         model: string
+        /**
+         * The effort the agent runs at (#659), whatever its model. The
+         * session's follow-ups run at it too.
+         */
+        effort: EffortLevel
         /**
          * 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.
@@ -183,7 +188,7 @@ export type AgentLauncher = {
      * Sends a follow-up message to an agent session that is still open, such
      * 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,
+     * guards it was launched with, its model and its effort. A session the launcher doesn't know,
      * or one that has closed, is an engine failure with `session_gone`.
      *
      * @example

package/engine/agents/claude-launcher-helpers.ts

@@ -10,9 +10,10 @@ import { afterEach, beforeEach } from 'bun:test'
 import type { AgentMessaging, AgentTurn } from './agent-launcher'
 import { createClaudeLauncher, type AgentQuery } from './claude-launcher'
 import { CLAUDE_MODEL } from './claude-options'
+import { REVIEW_EFFORT } from './role-effort'
 import type { AgentRole } from './role-results'
 
-import type { EngineConfig } from '../config/engine-config'
+import type { EffortLevel, EngineConfig } from '../config/engine-config'
 
 /**
  * Helpers shared by the launcher tests (`claude-launcher.test.ts` and the
@@ -199,12 +200,14 @@ export const repoPerTest = () => {
 export const launch = ({
     query,
     model,
+    effort,
     role,
     turn_timeout_ms,
     messaging,
 }: {
     query: AgentQuery
     model?: string
+    effort?: EffortLevel
     role?: AgentRole
     turn_timeout_ms?: number
     messaging?: AgentMessaging
@@ -222,6 +225,8 @@ export const launch = ({
         config: CONFIG,
         messaging: messaging ?? null,
         model: model ?? CLAUDE_MODEL,
+        // One effort for every role unless given, as the default reviewer's.
+        effort: effort ?? REVIEW_EFFORT,
     })
 
 export const IMPLEMENTER_DONE = {

package/engine/agents/claude-launcher.ts

@@ -1,10 +1,6 @@
-import {
-    query as sdkQuery,
-    type EffortLevel,
-} from '@anthropic-ai/claude-agent-sdk'
+import { query as sdkQuery } from '@anthropic-ai/claude-agent-sdk'
 
 import type { AgentLauncher } from './agent-launcher'
-import { AGENT_EFFORT } from './claude-options'
 import { createLaunch, type AgentQuery } from './launch-session'
 import { createSessionPool } from './session-pool'
 
@@ -25,7 +21,7 @@ export const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60_000
  * every guard on. Per launch it:
  *
  * 1. refuses any model but `opus`, `sonnet` or `haiku` before starting
- *    anything; follow-ups stay on their session's model;
+ *    anything; follow-ups stay on their session's model, and at its effort;
  * 2. builds the role's locked-down options (`agentOptions`) with the guard
  *    hook (honoring `may_edit_tests`), the sandbox, and a clean environment;
  *    with `messaging` (test-writers and implementers), the `luca` server's
@@ -55,20 +51,17 @@ export const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60_000
  *
  * @example
  * const launcher = createClaudeLauncher({})
- * const turn = await launcher.launch({ role: 'implementer', ticket: 11, prompt, cwd, may_edit_tests: false, config, messaging, model: 'opus' })
+ * const turn = await launcher.launch({ role: 'implementer', ticket: 11, prompt, cwd, may_edit_tests: false, config, messaging, model: 'opus', effort: 'medium' })
  * // ... later, in a fix loop:
  * if (turn.ok) await launcher.followUp({ session_id: turn.session_id, role: 'implementer', ticket: 11, message, cwd, config })
  * await launcher.closeAll()
  */
 export const createClaudeLauncher = ({
-    effort,
     query,
     claude_path,
     turn_timeout_ms,
     idle_timeout_ms,
 }: {
-    /** Defaults to `AGENT_EFFORT`, the same for every role. */
-    effort?: EffortLevel
     query?: AgentQuery
     claude_path?: string
     /** Defaults to `DEFAULT_TURN_TIMEOUT_MS`. */
@@ -76,7 +69,6 @@ export const createClaudeLauncher = ({
     /** Defaults to `DEFAULT_IDLE_TIMEOUT_MS`. */
     idle_timeout_ms?: number
 }): AgentLauncher & { closeAll: () => Promise<void> } => {
-    const useEffort = effort ?? AGENT_EFFORT
     const startQuery: AgentQuery = query ?? sdkQuery
     const timeoutMs = turn_timeout_ms ?? DEFAULT_TURN_TIMEOUT_MS
     const idleMs = idle_timeout_ms ?? DEFAULT_IDLE_TIMEOUT_MS
@@ -86,7 +78,6 @@ export const createClaudeLauncher = ({
     })
     const { sessions, close, startTurn, runTurn, closeAll } = pool
     const launch = createLaunch({
-        effort: useEffort,
         start_query: startQuery,
         claude_path,
         turn_timeout_ms: timeoutMs,

package/engine/agents/claude-options.ts

@@ -33,9 +33,6 @@ 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
 
-/** Every role runs at the same effort level. */
-export const AGENT_EFFORT: EffortLevel = 'high'
-
 /** How many model turns one agent gets before its try ends. */
 export const MAX_TURNS: Record<AgentRole, number> = {
     'test-writer': 80,
@@ -161,7 +158,7 @@ export const resultJsonSchema = ({
 }
 
 /**
- * The SDK options for one agent: its model at one effort for every role, the
+ * The SDK options for one agent: its model at its launch's effort, the
  * role's instructions, its result schema, `dontAsk` with only its own
  * pre-approved calls, the guard hook, the sandbox, a clean environment, and
  * nothing loaded from the machine: no settings, MCP servers, or skills.
@@ -172,7 +169,7 @@ export const resultJsonSchema = ({
  * hooks.
  *
  * @example
- * const options = agentOptions({ role, may_edit_tests, cwd, model: CLAUDE_MODEL, effort: AGENT_EFFORT, claude_path, config, common_git_dir, home, env, guard_hook, luca_server: null, delivery_hook: null })
+ * const options = agentOptions({ role, may_edit_tests, cwd, model: CLAUDE_MODEL, effort: 'xhigh', claude_path, config, common_git_dir, home, env, guard_hook, luca_server: null, delivery_hook: null })
  */
 export const agentOptions = ({
     role,
@@ -238,7 +235,7 @@ export const agentOptions = ({
         tools: rules.tools,
         allowedTools: rules.allowed,
         disallowedTools: rules.disallowed,
-        // The one helper every role may start (#627), always on Haiku.
+        // The one helper every role may start (#627), always on Haiku at low effort.
         agents: { [HELPER_TYPE]: SEARCHER },
         settingSources: [],
         strictMcpConfig: true,

package/engine/agents/launch-session.ts

@@ -8,11 +8,7 @@ import { randomUUID } from 'node:crypto'
 import { realpathSync } from 'node:fs'
 import { homedir } from 'node:os'
 
-import type {
-    EffortLevel,
-    Options,
-    SDKUserMessage,
-} from '@anthropic-ai/claude-agent-sdk'
+import type { Options, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk'
 
 import {
     AgentSessionSchema,
@@ -54,16 +50,14 @@ export type AgentQuery = (params: {
  * and runs the session's first turn through the pool.
  *
  * @example
- * const launch = createLaunch({ effort, start_query, claude_path, turn_timeout_ms, pool })
+ * const launch = createLaunch({ start_query, claude_path, turn_timeout_ms, pool })
  */
 export const createLaunch = ({
-    effort: useEffort,
     start_query: startQuery,
     claude_path,
     turn_timeout_ms: timeoutMs,
     pool,
 }: {
-    effort: EffortLevel
     start_query: AgentQuery
     claude_path: string | undefined
     turn_timeout_ms: number
@@ -80,6 +74,7 @@ export const createLaunch = ({
         config,
         messaging,
         model,
+        effort,
         on_progress,
     }) => {
         const refused = checkLaunchModel({ model })
@@ -115,7 +110,8 @@ export const createLaunch = ({
             may_edit_tests,
             cwd: worktree,
             model,
-            effort: useEffort,
+            // Kept in the session's options, so its follow-ups run at it too.
+            effort,
             claude_path: claudePath,
             config,
             common_git_dir: gitDir,

package/engine/agents/role-effort.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure: the effort each role runs at (#659), whatever model it runs on.
+ * Writers on tickets and the learner run at the config's `models.effort`,
+ * medium by default (#660); the reviewers, and the last writers before the
+ * pull request, at xhigh. Helpers run at their own definition's effort
+ * (`HELPER_EFFORT`).
+ */
+import type { AgentRole } from './role-results'
+
+import {
+    modelsOf,
+    ModelsConfigSchema,
+    type EffortLevel,
+    type EngineConfig,
+} from '../config/engine-config'
+
+/** The effort the reviewers, and the final review's fixers, always run at. */
+export const REVIEW_EFFORT: EffortLevel = 'xhigh'
+
+/**
+ * Each role's effort on ticket work (and the learner's), with no
+ * `models.effort` set: the writers' and the learner's are the schema's
+ * defaults.
+ */
+export const ROLE_EFFORT: Record<AgentRole, EffortLevel> = {
+    ...ModelsConfigSchema.parse({}).effort,
+    'ticket-reviewer': REVIEW_EFFORT,
+    'architecture-lens': REVIEW_EFFORT,
+    'simplification-lens': REVIEW_EFFORT,
+    'security-lens': REVIEW_EFFORT,
+    'integration-lens': REVIEW_EFFORT,
+    'rules-lens': REVIEW_EFFORT,
+}
+
+/**
+ * The effort a fresh agent launches at: its role's, as the run's config
+ * sets it, or `REVIEW_EFFORT` for a final review's fixer. A follow-up runs
+ * at its session's instead.
+ *
+ * @example
+ * roleEffort({ role: 'implementer', config }) // 'medium'
+ * roleEffort({ role: 'implementer', config, final_fix: true }) // 'xhigh'
+ */
+export const roleEffort = ({
+    role,
+    config,
+    final_fix = false,
+}: {
+    role: AgentRole
+    config: EngineConfig
+    final_fix?: boolean
+}): EffortLevel =>
+    final_fix
+        ? REVIEW_EFFORT
+        : { ...ROLE_EFFORT, ...modelsOf({ config }).effort }[role]

package/engine/agents/scripted-launcher.ts

@@ -10,6 +10,8 @@ import type {
 } from './agent-launcher'
 import type { AgentRole } from './role-results'
 
+import type { EffortLevel } from '../config/engine-config'
+
 /**
  * The engine's tools, as a scripted agent calls them. They reach the
  * messaging the session was launched with; a reviewer has none, so its
@@ -71,6 +73,11 @@ export type ScriptedCall = {
      * for a session the launcher doesn't know.
      */
     model: string | null
+    /**
+     * The effort a launch asked for (#659); a follow-up's is its session's,
+     * `null` for a session the launcher doesn't know.
+     */
+    effort: EffortLevel | null
     /** What each of the turn's tool calls handed over, in order. */
     delivered: string[]
 }
@@ -107,10 +114,14 @@ export const createScriptedLauncher = ({
 }): ScriptedLauncher => {
     const remaining = [...turns]
     const calls: ScriptedCall[] = []
-    /** Each open session's messaging and model, kept for its follow-ups. */
+    /** Each open session's messaging, model and effort, kept for its follow-ups. */
     const sessions = new Map<
         string,
-        { messaging: AgentMessaging | null; model: string }
+        {
+            messaging: AgentMessaging | null
+            model: string
+            effort: EffortLevel
+        }
     >()
 
     const toolsFor = ({
@@ -192,9 +203,10 @@ export const createScriptedLauncher = ({
             may_edit_tests,
             messaging,
             model,
+            effort,
         }) => {
             const session_id = `scripted-${role}-${ticket}-${calls.length + 1}`
-            sessions.set(session_id, { messaging, model })
+            sessions.set(session_id, { messaging, model, effort })
             const call: ScriptedCall = {
                 kind: 'launch',
                 role,
@@ -203,6 +215,7 @@ export const createScriptedLauncher = ({
                 session_id,
                 may_edit_tests,
                 model,
+                effort,
                 delivered: [],
             }
             calls.push(call)
@@ -218,6 +231,7 @@ export const createScriptedLauncher = ({
                 prompt: message,
                 session_id,
                 model: open?.model ?? null,
+                effort: open?.effort ?? null,
                 delivered: [],
             }
             calls.push(call)

package/engine/config/config-fields.ts

@@ -84,8 +84,9 @@ export const decisionModelOf = ({
     config.decision_model?.model ?? DecisionModelConfigSchema.parse({}).model
 
 /**
- * The run's model floors and confidence bar: the config's `models`, else
- * the schema's defaults (every floor `opus`).
+ * The run's model floors, writers' effort and confidence bar: the config's
+ * `models`, else the schema's defaults (every floor `opus`, every effort
+ * `medium`).
  *
  * @example
  * modelsOf({ config }).floors['test-writer'] // 'opus'

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

@@ -71,6 +71,20 @@ export type ModelName = z.infer<typeof ModelNameSchema>
 /** The model reviewers run on, and every fallback of the model pick (#603). */
 export const DEFAULT_MODEL: ModelName = ModelNameSchema.enum.opus
 
+/**
+ * How hard an agent thinks before it acts (#659), lowest first: the levels
+ * the SDK's `effort` option takes.
+ */
+export const EffortLevelSchema = z.enum([
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+])
+
+export type EffortLevel = z.infer<typeof EffortLevelSchema>
+
 /** The roles with a model floor (#603); every other role always runs Opus. */
 export const ROUTED_ROLES = ['test-writer', 'implementer', 'learner'] as const
 
@@ -93,12 +107,33 @@ const ModelFloorsSchema = z.strictObject(
 )
 
 /**
- * The config's `models` block (#603): each routed role's model floor, and
- * how sure the decision model must be (`confidence_bar`) before its model
- * pick is used.
+ * The effort each writer runs at on tickets, and the learner's (#660); a
+ * role left out is `medium`. An effort for any other role, a reviewer or a
+ * lens, is refused: they, and the final review's fixers, always run at
+ * xhigh.
+ */
+const RoleEffortsSchema = z.strictObject(
+    {
+        'test-writer': EffortLevelSchema.default('medium'),
+        implementer: EffortLevelSchema.default('medium'),
+        learner: EffortLevelSchema.default('medium'),
+    },
+    {
+        error: (issue) =>
+            issue.code === 'unrecognized_keys'
+                ? `models.effort can't set ${issue.keys.join(', ')}: reviewers and the final review's fixers always run at xhigh.`
+                : undefined,
+    }
+)
+
+/**
+ * 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.
  */
 export const ModelsConfigSchema = z.object({
     floors: ModelFloorsSchema.prefault({}),
+    effort: RoleEffortsSchema.prefault({}),
     confidence_bar: z.number().min(0).max(1).default(0.8),
 })
 
@@ -223,7 +258,10 @@ export const EngineConfigSchema = z.object({
     muninn: MuninnConfigSchema.optional(),
     /** The decision model shadow mode asks; left out, Clef. */
     decision_model: DecisionModelConfigSchema.optional(),
-    /** Each routed role's model floor and the confidence bar; left out, every role runs Opus. */
+    /**
+     * Each routed role's model floor, each writer's effort, and the
+     * confidence bar; left out, every role runs Opus, and writers at medium.
+     */
     models: ModelsConfigSchema.optional(),
     /**
      * The repo's run budget in tokens; left out, the engine's default

package/engine/config/engine-config.ts

@@ -30,6 +30,7 @@ export {
 export {
     DecisionModelConfigSchema,
     DEFAULT_MODEL,
+    EffortLevelSchema,
     ENGINE_CONFIG_FILE,
     EngineConfigSchema,
     ModelNameSchema,
@@ -39,6 +40,7 @@ export {
     TestResultsSchema,
 } from './engine-config-schema'
 export type {
+    EffortLevel,
     EngineConfig,
     ModelName,
     ModelsConfig,

package/engine/core/agent-turn.ts

@@ -9,12 +9,13 @@ import { doChores } from './engine-chores'
 import { closeSessions } from './session-close'
 
 import type { AgentTurn } from '../agents/agent-launcher'
+import { roleEffort } from '../agents/role-effort'
 import {
     parseRoleResult,
     type AgentRole,
     type RoleResult,
 } from '../agents/role-results'
-import { DEFAULT_MODEL } from '../config/engine-config'
+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'
@@ -239,17 +240,24 @@ const sessionOf = (record: JournalRecord): string | null => {
     }
 }
 
-/** The model a session launched on, and why (`null` before #603). */
-export type SessionModel = { model: string; model_reason: ModelReason | null }
+/**
+ * The model a session launched on, and why (`null` before #603), and the
+ * effort it runs at (`null` before #659).
+ */
+export type SessionModel = {
+    model: string
+    model_reason: ModelReason | null
+    effort: EffortLevel | null
+}
 
 /**
- * The model a session launched on, and why, from the journal: the
+ * The model a session launched on, why, and its effort, from the journal: the
  * `agent_started` of the launch the session's first record came after (same
  * ticket and role), or of an earlier follow-up to it. `null` if the journal
  * names none, as in journals from before #600; every agent ran Opus then.
  *
  * @example
- * sessionModel({ records: journal.read(), session_id }) // { model: 'opus', model_reason: 'locked' }
+ * sessionModel({ records: journal.read(), session_id }) // { model: 'opus', model_reason: 'locked', effort: 'xhigh' }
  */
 export const sessionModel = ({
     records,
@@ -282,11 +290,14 @@ export const sessionModel = ({
                           record.content.follow_up_of === null
                   ))
     if (started?.kind !== 'agent_started') return null
-    const { model, model_reason } = started.content
-    return model === null ? null : { model, model_reason }
+    const { model, model_reason, effort } = started.content
+    return model === null ? null : { model, model_reason, effort }
 }
 
-/** A follow-up's model: its session's, else Opus, as before #600. */
+/**
+ * A follow-up's model and effort: its session's, else Opus at an unknown
+ * effort, as before #600.
+ */
 export const followUpModel = ({
     records,
     session_id,
@@ -297,6 +308,7 @@ export const followUpModel = ({
     sessionModel({ records, session_id }) ?? {
         model: DEFAULT_MODEL,
         model_reason: null,
+        effort: null,
     }
 
 export const launchAgent = async ({
@@ -309,7 +321,8 @@ export const launchAgent = async ({
     const { ticket, role, prompt, may_edit_tests } = action
     // The decision model's answer, journaled just before this step, picks
     // a routed role's model; a reviewer is locked on Opus. A redo keeps
-    // the model its first try journaled.
+    // the model its first try journaled. The role's effort applies on any
+    // model (#659).
     const { model, model_reason } = launchPick({
         records: context.journal.read(),
         state: context.state,
@@ -318,11 +331,19 @@ export const launchAgent = async ({
         role,
         step: context.step,
     })
+    const effort = roleEffort({ role, config: context.config })
     context.journal.append({
         kind: 'agent_started',
         ticket,
         role,
-        content: { role, prompt, follow_up_of: null, model, model_reason },
+        content: {
+            role,
+            prompt,
+            follow_up_of: null,
+            model,
+            model_reason,
+            effort,
+        },
     })
     await runTurn({
         context,
@@ -344,6 +365,7 @@ export const launchAgent = async ({
                     role,
                 }),
                 model,
+                effort,
             }),
     })
 }
@@ -360,7 +382,7 @@ export const followUpAgent = async ({
         value: context.state.snapshot?.tickets[ticket],
         what: `snapshot of #${ticket}`,
     })
-    const { model, model_reason } = followUpModel({
+    const { model, model_reason, effort } = followUpModel({
         records: context.journal.read(),
         session_id,
     })
@@ -374,6 +396,7 @@ export const followUpAgent = async ({
             follow_up_of: session_id,
             model,
             model_reason,
+            effort,
         },
     })
     await runTurn({

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

@@ -15,6 +15,7 @@ import {
 } from './execute-build'
 import { closeSessions, openSessionsIn } from './session-close'
 
+import { roleEffort } from '../agents/role-effort'
 import { hasSlowTests } from '../config/engine-config'
 import type { EngineCommit } from '../git/git-adapter'
 import { LOCKED_PICK } from '../jev/model-pick'
@@ -137,6 +138,7 @@ export const executeFinalReviewAction = async ({
         case 'launch_lens': {
             const { lens, role, prompt } = action
             const round = state.final_review.round
+            const effort = roleEffort({ role, config })
             journal.append({
                 kind: 'lens_started',
                 ticket: null,
@@ -152,6 +154,7 @@ export const executeFinalReviewAction = async ({
                     prompt,
                     follow_up_of: null,
                     ...LOCKED_PICK,
+                    effort,
                 },
             })
             const result = await runTurn({
@@ -171,6 +174,7 @@ export const executeFinalReviewAction = async ({
                         // Lenses are reviewers: no agent messages.
                         messaging: null,
                         model: LOCKED_PICK.model,
+                        effort,
                     }),
             })
             if (result === null || !('verdict' in result.result)) return
@@ -206,7 +210,9 @@ export const executeFinalReviewAction = async ({
             return
         case 'launch_final_fixer': {
             const { role, prompt, may_edit_tests } = action
-            // The last fixes before the PR are never routed: always Opus.
+            // The last fixes before the PR are never routed: always Opus,
+            // and at the reviewers' effort, so the last code is the cleanest.
+            const effort = roleEffort({ role, config, final_fix: true })
             journal.append({
                 kind: 'agent_started',
                 ticket: null,
@@ -216,6 +222,7 @@ export const executeFinalReviewAction = async ({
                     prompt,
                     follow_up_of: null,
                     ...LOCKED_PICK,
+                    effort,
                 },
             })
             await runTurn({
@@ -235,13 +242,14 @@ export const executeFinalReviewAction = async ({
                         // Every ticket is over, so nobody is left to talk to.
                         messaging: null,
                         model: LOCKED_PICK.model,
+                        effort,
                     }),
             })
             return
         }
         case 'follow_up_final_fixer': {
             const { role, session_id, message } = action
-            const { model, model_reason } = followUpModel({
+            const { model, model_reason, effort } = followUpModel({
                 records: journal.read(),
                 session_id,
             })
@@ -255,6 +263,7 @@ export const executeFinalReviewAction = async ({
                     follow_up_of: session_id,
                     model,
                     model_reason,
+                    effort,
                 },
             })
             await runTurn({