Story Director and TTRPG inference calls

This document answers three questions:

1. Which RoleCall features make an AI request?
2. When can one visible chat turn make more than one request?
3. Which settings make a turn light or token-heavy?

It describes the active worker and orchestration paths as of July 24, 2026. It is both a user-facing cost guide and an operator reference. “Call” below means one logical executeInference request. A logical request may try more than one provider through the managed router before it succeeds or fails.

Prompt Inspector records this same distinction. A logical call appears once in Outbound Calls, while fallback providers appear as ordered attempts under it. Before dispatch, token totals are estimates. After a provider responds, exact reported usage replaces the estimate. Missing usage remains unknown and is not counted as zero.

The short answer

Story Director is not simply “one extra call.”

• A plain Narrator turn normally starts with one Narrator call.
• Story Director adds at least one planning call on every enabled turn.
• The Interpreter adds one more call when enabled.
• Storyboards/dossiers can add one or two calls when the Director decides that a dossier changed.
• Legacy Trackers can add one call when any legacy tracker module is active.
• A corrective planning retry can add one call when the first response does not satisfy the planning contract.
• Narrator Tool Access can turn the visible Narrator response into a multi-round agent loop.
• TTRPG mechanics can add one or two scheduled Mechanics phases, consequence phases, and Narrator continuation calls depending on ownership, delivery, review, and roll settings.

The lightest normal Story Director turn is:

1 Story Director planning call
+ 1 Narrator call
= 2 logical model calls

A feature-rich turn can be:

1 Interpreter shape-read
+ 1 Story Director planning
+ 1 focused Storyboard/dossier update
+ 1 legacy Tracker update
+ 1 Narrator call
= 5 logical model calls

Retries, dossier inspection follow-ups, Narrator tools, TTRPG pauses, post-narration mechanics, Compendium work, and provider fallback can raise that count.

What “token-heavy” means here

Every model request has:

• Input tokens: prompts, recent history, state snapshots, tool schemas, and previous tool results sent to the model.
• Output tokens: prose, structured tool arguments, or JSON returned by the model.
• Repeated context cost: a second round usually resends much of the first round’s prompt and schemas. It is not charged only for the new sentence.

The output limit is a ceiling, not a promise that the model will use every token. The true bill depends on the selected model/provider and the actual token usage returned by that provider.

Production reference

Successful calls recorded with caller = dm during the 14 days ending July 24, 2026 had:

Measurement	Input tokens per successful call	Output tokens per successful call
Median	24,087	804
90th percentile	31,902	2,733
Mean	22,820	1,625

These are per call, not per visible turn. The dm caller currently includes both Story Director rounds and Mechanics Agent rounds because both use the shared DM command transport. It is therefore a realistic weight reference, not a clean per-feature price table.

Manual Tracker generation/refresh calls recorded separately as caller = trackers had:

Measurement	Input tokens per successful call	Output tokens per successful call
Median	5,564	2,215
90th percentile	9,462	4,708
Mean	5,190	2,388

The practical lesson is that an additional Director/Mechanics round is often comparable to, or heavier than, a complete ordinary Narrator request. Count calls before comparing models.

One complete solo turn

The active solo worker orders work this way:

1. Build the canonical chat and scene context.
2. If configured, run a dedicated pre-narration Mechanics phase.
3. Run Story Director and Compendium/TunnelVision pre-generation work concurrently.
4. Inject the safe Story Director directive and retrieved lore.
5. Run the Narrator.
6. If configured, run a dedicated post-narration Mechanics reconciliation phase.
7. Run independent post-generation features such as Compendium writing, images, post-production, participant work, or TTS when those features are enabled.

Story Director failing does not intentionally cancel the Narrator. Compendium and Story Director are independent even though their pre-generation work can overlap in wall-clock time.

Story Director feature ledger

DM Assistant / Story Director planning

Trigger: DM Assistant is enabled for the chat.

Model: The selected Story Director model/provider.

Calls: One planning call on every eligible turn.

Input:

• Story Director system prompt and personality.
• The current user move.
• Up to the 30 most recent messages, clipped to 800 characters each.
• Chapter, arc, seed, memory, pacing, shadow-world, and recent-analysis state.
• Enabled Storyboard/Tracker manifests and allowed tool schemas.
• Character/persona context, custom instructions, and steering when present.

Output ceiling: The service currently supplies max_tokens = 10,000 to Story Director rounds. Normal planning output is usually far smaller.

Weight: Heavy. This is the mandatory base cost of Story Director.

The planning call must emit exactly one valid commit_planning_round command containing the Narrator Directive and planning updates. The Narrator only receives the filtered directive, not the Director’s private working state.

Planning recovery

Trigger: The first planning result is missing, malformed, uses the wrong command, or fails the required planning contract.

Calls: At most one corrective planning call.

Input: Almost the entire planning prompt again, plus a short correction describing the invalid prior attempt.

Weight: Heavy when triggered. It can nearly double planning input for that turn.

Explicit Native and Tagged modes remain on the chosen transport. Compatibility/automatic behavior may move from native tools to Tagged commands where allowed.

Interpreter / shape-read

Trigger: Interpreter is enabled and this is a new user move, not a continuation without a new user message.

Model: The Story Director model/provider. There is no separate Interpreter model selector in the active path.

Calls: Exactly one non-tool call.

Input:

• The Interpreter system prompt.
• The eight most recent user/assistant messages.
• The current user move.
• Optional Orison persona overlay and standing steering note.

Output ceiling: 1,200 tokens. The injected directive is clipped to 1,500 characters.

Timeout: 20 seconds.

Failure behavior: Non-fatal. The turn continues without shape direction.

Weight: Medium. It has a smaller output, but it still resends the recent scene and a substantial system prompt.

Optional Story Director bookkeeping

Trigger: optionalToolBudget.max is greater than zero.

Calls: One optional extras call.

Purpose: Chapter operations, individual arc/seed helpers, private DM notes, invisible arcs, and parallel-timeline bookkeeping after planning.

Default: The current default budget is { min: 0, max: 0 }, so this phase is normally skipped.

Weight: Heavy when enabled. It resends the Director system prompt and user prompt plus the planning directive.

Storyboards / focused dossiers

The five dossier domains are:

• Quests.
• Cast and relationships.
• Calendar.
• Map.
• Renown and gossip.

Trigger: A matching Storyboard is active and the planning result explicitly marks one or more dossier domains as needing updates.

Calls:

• Zero when no domain is due.
• One focused call when one or more domains are due. Multiple due domains are combined into one focused call.
• One additional follow-up call if the first dossier round only inspected state and still needs to write.

Input: Director prompt/state, the planning directive, the selected dossier manifest, and only the relevant dossier tool schemas.

Weight: Heavy, with a bounded very heavy inspect-then-write case.

Enabling five Storyboards does not automatically make five calls every turn. Planning decides which domains moved, and multiple changed domains share a combined call.

Legacy Trackers

Legacy Tracker modules include systems such as battle, resources, inventory, knowledge, party, spellbook, creature codex, biological cycles, bonds, and corruption.

Trigger: At least one legacy Tracker module is active.

Calls: One combined legacy Tracker call per Story Director turn.

Input: Director prompt/state, planning directive, active legacy module snapshots, and their tool schemas.

Weight: Heavy. All active legacy modules share one call, but enabling more modules increases prompt and schema size.

Tracker frequency determines whether modules are included in the due-module set. Lower-frequency modules reduce prompt/schema weight on turns where they are not due.

Narrator Directive

Building and injecting the directive does not make another model call. It is the saved output of the planning phase inserted into the Narrator prompt.

The directive does increase the Narrator’s input by its own length, but it is small compared with the full private Director state.

Story Director state panels

Opening the Story Director wing, Storyboards, activity feed, or a Tracker panel is a database/UI read. It does not call a model.

Editing deterministic state directly also does not inherently call a model unless the button explicitly says generate, refresh, rebuild, ask, or reconcile.

Refresh Enabled Boards and manual Tracker generation

Trigger: The user clicks a Tracker generation/refresh action or Refresh Enabled Boards.

Calls: One separate caller = trackers request per generated/refreshed module. “Refresh all” intentionally processes modules one at a time.

Input: The selected history window, tracker schema, current item/module state, and generation instructions.

Output ceiling:

• 2,000 tokens for most modules.
• 3,500 for map, relationships, or gossip.
• 4,000 for bulk calendar-event population.

Weight: Medium per module; very heavy in a batch. Refreshing ten modules means ten logical calls.

Story Director model controls

Control	Token effect in the active path
Story Director model	Changes provider price, context limits, tool reliability, and retry likelihood; not the amount of context RoleCall tries to send.
DM temperature	Changes sampling behavior, not call count.
Default AI Awareness / module frequency	Can reduce which modules and schemas are due, lowering dossier/tracker work.
Auto-retry invalid tools	Can permit corrective work on invalid output; retries resend context.
Max Tool Rounds	The UI value is retained for compatibility and older/pre-generation agent paths. The active runDM phase orchestrator uses fixed phase bounds and does not currently use this value to cap planning/dossier/legacy calls. Do not estimate active Director cost from this spinner.
Tool mode	Native versus Tagged changes the wire format. Tagged embeds command instructions/schema in text; Native sends provider tools. Automatic recovery can add a request.

The mismatch around Max Tool Rounds is a product/documentation debt: the control’s label implies authority over the active path that it does not have.

Story Director call-count bounds

The active production worker removes TTRPG mutation ownership from Story Director and sends it to the dedicated mechanics boundary. Excluding unrelated systems:

Story Director configuration	Typical extra calls before Narrator	Bounded recovery case
Director only, no due modules	1	2 with planning recovery
Director + one or more due Storyboards	2	4 with planning recovery and inspect follow-up
Director + legacy Trackers	2	3 with planning recovery
Director + Storyboards + legacy Trackers	3	5 with both recoveries
Add Interpreter	+1	+1
Add optional bookkeeping	+1	+1

The highest active Story Director-only path is therefore normally bounded around seven logical calls: Interpreter, failed planning plus corrective planning, optional bookkeeping, dossier round plus inspect follow-up, and legacy Tracker round. Most turns should use fewer.

Provider routing is a separate layer. One of these logical calls can show more than one provider attempt when the first provider times out or rejects the request.

Narrator features that are separate from Story Director

Plain Narrator

Calls: One visible generation call in the simple path.

Weight: Usually the largest output request because it writes the prose. Its input can also be much larger than Director input after the character, preset, lore, chat history, and scene context are assembled.

Narrator Tool Access

Trigger: Narrator Tool Access is enabled.

Calls: A NarratorEngine agent loop instead of a guaranteed single call. The default cap is eight rounds; the accepted setting range is 1–20.

Each tool round can resend the Narrator prompt and accumulated tool results. Turning this on is one of the largest potential call-count multipliers in RoleCall.

Turning Narrator Tool Access off does not disable Story Director, Interpreter, Compendium, or a separate Mechanics Agent.

Compendium / TunnelVision

Compendium is independent of Story Director.

• Pre-generation retrieval can make its own model calls.
• Post-generation bookkeeping/writing can make its own calls.
• Retrieval may run concurrently with Story Director, which reduces elapsed time but not tokens.

Compendium calls are not included in the Story Director count tables above.

Post-Production, images, TTS, summaries, and Character Minds

These are separate features with their own triggers:

• Prompt-only formatting or Author Notes increase Narrator input but do not automatically create a separate call.
• LLM Post-Production passes create one or more additional inference calls.
• Image prompt/generation work is separately metered.
• TTS is a voice-provider request, not a Story Director call.
• Character Minds, participant registration, speaker labeling, and summaries can run their own helpers.

Do not attribute these costs to Story Director simply because they happen on the same visible turn.

TTRPG ownership and call behavior

TTRPG has two independent choices:

1. Who owns mechanics? Separate Mechanics Agent or Narrator.
2. Should an extra Mechanics Agent run before/after narration? None, Before, After, or Before + After.

That means Narrator-owned mechanics can still be paired with an auxiliary dedicated pass.

Separate Mechanics Agent

Trigger: TTRPG is enabled, controller is Separate Mechanics Agent, and the auxiliary timing schedules a phase.

Calls: Normally one Mechanics command call per scheduled phase.

Input bounds:

• At most 30 recent messages.
• At most 1,200 characters per message.
• At most 18,000 total recent-history characters.
• Mechanics system primer, play-style policy, sheet/campaign manifest, active sheets, eligible actors, recent events, shops, and tool schemas.

Output ceiling: The normal service inherits the Director service ceiling of 10,000 tokens. Consequence jobs use a smaller 512–4,096 range.

Weight: Heavy. It is structurally similar to a Director tool round.

The phase is bounded to four command rounds. A later round occurs when the model only inspected/read state or produced a recoverable protocol failure without a terminal mechanics decision.

Mechanics transport recovery

Each Mechanics command round selects Native or Tagged command transport:

• Native may fall back to Tagged after a tools-related inference error.
• Automatic mode may fall back to Tagged when Native returns zero commands.
• A malformed Tagged command may receive one repair request.
• Once a command is admitted to execution, transport retry is forbidden to prevent duplicate mutations.

A normal command round is one model call. The first automatic round can theoretically make three calls: Native, Tagged fallback, and Tagged repair. Later rounds stay Tagged after fallback and can make at most two calls each.

Therefore:

• A normal four-round Mechanics phase usually uses one call and stops on a decision.
• Its protocol-recovery ceiling is nine calls across the bounded phase.
• A three-round consequence phase has a protocol-recovery ceiling of seven calls.

Those ceilings are defensive worst cases, not intended steady-state behavior. Repeatedly approaching them indicates an incompatible or unreliable mechanics model.

Before narration

The Mechanics Agent reads the user move and current sheets before prose is written.

• Typical calls: one Mechanics call.
• It may pause for review, a roll, or a player interaction before Narrator generation begins.
• Approving/resolving the gate resumes the same durable logical turn; it does not rerun completed phases.

Weight: Heavy, but it prevents the Narrator from declaring an outcome before mechanics has resolved it.

After narration

The Mechanics Agent reads the completed Narrator response and reconciles authoritative state with facts already established in prose.

• Typical calls: one Mechanics call after the Narrator.
• Post-narration mechanics cannot retroactively request a roll for an outcome the prose already declared.
• Optional follow-up interactions may be prepared for the player’s next turn.

Weight: Heavy. The completed prose is added to the mechanics history, so its input is often larger than a pre-pass.

Before + After

Runs both phases.

• Typical calls: two Mechanics calls per visible turn.
• Defensive recovery ceiling: two full Mechanics phases, before counting consequences.

This is the most expensive dedicated configuration and should be chosen for strict pre-resolution plus meticulous state reconciliation, not as a default “more is better” switch.

None

Schedules no auxiliary Mechanics Agent phase.

• With Separate Mechanics Agent ownership, this effectively means no proactive dedicated mechanics pass for an ordinary turn.
• With Narrator ownership, mechanics can still happen through Narrator tools.
• Boards, sheets, clock, and manual campaign controls remain available without a model call.

Narrator-owned TTRPG mechanics

Ready-made Branches

Streaming requirement: None.

The Narrator writes sealed branch continuations through a mechanics interaction tool. The player sees labels/options, not every hidden continuation.

Call behavior:

1. The Narrator agent call proposes the branch program.
2. The tool result returns through the Narrator engine; this can require another agent round.
3. After the player selects a branch, RoleCall loads only that sealed continuation and starts a continuation Narrator request to write onward.

Weight: Very heavy when used. A branch moment requires a tool-capable Narrator round and at least one later continuation call after selection. The sealed branch text also consumes output tokens before the player chooses.

Live pauses

Streaming requirement: Required. If streaming is off, RoleCall must block generation until the user enables streaming or changes to Branches.

The Narrator streams prose, proposes a mechanics interaction, and pauses the durable logical turn. After the user answers, a continuation job resumes from the saved checkpoint.

Call behavior:

1. One or more Narrator agent rounds reach the pause.
2. The turn waits without making calls.
3. The player responds.
4. A continuation Narrator call resumes the same logical turn.
5. Another live moment can repeat the cycle.

Weight: Variable to very heavy. Every pause/answer cycle adds at least one later Narrator call, and each segment may itself use tool rounds.

Review policy

Policy	Direct model-call effect
Ask every time	Review UI itself makes no model call, but pausing before narration creates a later continuation Narrator call after resolution.
Ask for risky changes	Same behavior only for changes classified as risky.
Apply automatically	No human pause. This is usually lighter in latency and may avoid a continuation call.

Editing the rationale or approving/rejecting a prepared mutation is database/application work. It is not itself an inference call unless the chosen action explicitly requests regeneration.

Roll policy

Policy	Call behavior
Confirm rolls	The proposal pauses. Committing the roll can run a dedicated consequence Mechanics phase, then the Narrator continues.
Roll automatically	The server commits the canonical roll immediately. If the result needs interpretation/state changes, an inline consequence Mechanics phase runs before narration continues.

The random roll is deterministic server work, not an AI call. Interpreting and applying its consequences can be AI work.

Player interactions

An interaction can be a choice, question, target selection, confirmation, or other structured player moment.

• Presenting and storing the UI event is not a separate model call beyond the model round that proposed it.
• Waiting costs no tokens.
• Resolving an automatic interaction consequence can run a three-round-bounded Mechanics consequence phase.
• Continuing the prose after a pause requires a Narrator continuation call.

Play style and cadence

Cinematic / Balanced / Crunchy changes the Mechanics Agent’s mandate and how frequently it should intervene. It does not directly change a hard call limit.

Cadence affects cost indirectly:

• More frequent interventions produce more mechanics calls, reviews, rolls, and continuations.
• A quiet turn can still end after one scheduled Mechanics call that returns no change.
• Scheduling both before and after always has a larger baseline than changing the prose style alone.

TTRPG campaign feature ledger

The campaign UI contains both deterministic features and opt-in AI assistants.

Feature	Model calls	Token notes
View Encounter Board / sheets / shops	0	Database/UI reads.
Attach, detach, or manually edit a sheet	0	Validated application/database mutation.
Generate a new sheet draft	1	Up to 5,000 output tokens; full schema and character brief make this heavy.
Commit a canonical die roll	0	Server-side randomness and atomic persistence. Consequence interpretation may call Mechanics separately.
Advance World Clock manually	0	Database/RPC work.
Offstage Turn	1 per queued time window	Up to 2,500 output tokens; campaign projection plus up to 80 active chronicle records.
Campaign Chronicle manual edits	0	Database/RPC work.
Create, compare, or restore checkpoints	0	Structured snapshots/diffs; restore remains validated/reviewed.
Reconcile Campaign State	1 per decrypted chat chunk	Up to 3,000 output tokens; up to 14,000 characters of public sheet context plus the chunk and campaign state. Long histories require multiple calls.
Rules Forge: forge/regenerate	1 per action	Up to 4,000 output tokens. Regenerating one section still returns a complete module.
Rules Forge: preview	0	Deterministic compilation/examples.
Rules Kit import/validation	0	Deterministic validation and RPC import.
Rules Counsel question	1	Up to 1,500 output tokens; last 8 messages (max 8,000 chars), authorized sheet/chronicle/rule evidence.
Encounter preparation without model proposal	0	Deterministic pressure envelope.
Encounter preparation with model proposal	1	Up to 3,000 output tokens; model adds opponents/hazards/tactics inside an immutable numeric envelope.
Activity/timeline/transcript receipts	0	Durable reads of already-created events.

Configuration recipes

Lightest long-running story setup

• Story Director on.
• Interpreter off.
• Only the Storyboards you actively use.
• Legacy Trackers off or set to lower awareness.
• Narrator Tool Access off.
• TTRPG off.

Expected core turn: one planning call plus one Narrator call, with an occasional focused dossier call.

Balanced TTRPG setup

• Separate Mechanics Agent.
• Auxiliary timing: Before.
• Review risky changes.
• Confirm rolls if player agency matters more than speed; Auto if uninterrupted flow matters more.
• Story Director on only if you also want persistent plot direction.
• Narrator Tool Access off unless a specific narrator-owned feature needs it.

Expected core turn: one Mechanics call, one Story Director planning call, and one Narrator call. Gates/consequences add calls only when triggered.

Maximum continuity / maximum cost

• Interpreter on.
• Story Director with Storyboards and Legacy Trackers.
• Narrator Tool Access on.
• TTRPG Before + After.
• Confirmed rolls and Live player moments.
• Compendium retrieval/writing and LLM Post-Production also on.

This can produce many logical calls around one visible reply. It is appropriate for deliberate campaign play, not for a low-latency default.

Estimating one turn before you run it

Use this worksheet:

Base Narrator                                  1
Story Director planning                       +1
Interpreter                                   +0 or +1
Story Director planning recovery              +0 or +1
Optional Director bookkeeping                 +0 or +1
Focused dossier update                        +0, +1, or +2
Legacy Tracker batch                          +0 or +1
Dedicated Mechanics Before                    +0 or usually +1
Dedicated Mechanics After                     +0 or usually +1
Mechanics consequence                         +0 or usually +1
Legacy Director loop rounds                   +0 to configured cap when that path is active
Live/Branch continuation                      +0 or at least +1 per resume
Compendium / post-production / other helpers  separate

For a rough token estimate, multiply the expected number of Director/Mechanics calls by the production per-call reference, then add Narrator and other helper usage separately. Do not multiply by output ceilings; use actual usage receipts whenever available.

Prompt Inspector and completed-turn token receipts

Prompt Inspector reviews the request that is actually ready to cross the model boundary. It does not approve a guessed whole turn in advance.

• The first immutable set of ready calls appears before provider dispatch.
• Later Narrator, tool-loop, continuation, and after-narration calls remain separate entries in Outbound Calls.
• Later calls in the same resumable job currently do not open another blocking wave. This prevents an earlier successful phase from being replayed until phase-output checkpoints are complete.
• Refreshing or switching devices does not approve the request. The durable review remains paused and can be reopened after encryption is unlocked.
• Closing the review chooses Review later. It does not discard the request or let it send in the background.

After an assistant reply is saved, Turn tokens opens the durable receipt for that active swipe. The receipt is grouped by system and assigned model, with an optional call split when one system ran more than once.

• A green outline means the provider reported complete input, output, and total token counts.
• A blue outline means RoleCall had to estimate the count locally.
• An unavailable count remains unavailable. Missing provider usage is never displayed as an exact zero.
• Changing swipes changes the receipt to the generation job that created the active swipe.

The receipt reports tokens, not price. Provider fallback attempts remain a separate route trace because a logical model call and a concrete provider attempt are different things.

Failure, retries, and charging

• A provider timeout or HTTP rejection can make the router try another provider for the same logical request.
• A transport repair or orchestration recovery is a new logical model request and resends context.
• A failed attempt with no generated tokens is not equivalent to a successful full completion, but upstream provider accounting differs. The RoleCall ledger should be treated as the authoritative user-facing receipt.
• Completed pre-narration Story Director and Mechanics phases are checkpointed so a same-job Narrator retry does not intentionally rerun and double-apply them.
• A user regenerate/swipe is a new job and can intentionally run the Director again for the new branch.

Failure receipts and observability

Story Director failures are classified at the stage where they occur:

Failure code	Meaning
inference_error	No provider attempt produced a usable response.
completion_error	A provider returned, but the completion envelope could not be read.
prompted_parse_error	Tagged command mode returned text that could not be decoded into commands.
tool_execution_error	Commands were decoded, but their validated execution failed.
no_tool_calls	The planning response returned no executable planning command.
missing_planning_call	The response called something else but omitted commit_planning_round.
missing_directive	The planning command ran without a usable narrator directive.
aborted	The request was cancelled before planning completed.

The Story Director activity event keeps one safe line per planning attempt with:

• transport mode;
• outcome and failure stage;
• elapsed time;
• model echo and finish reason when returned;
• prompt and completion token counts when returned;
• a sanitized error summary.

This distinguishes a provider failure from a protocol, parsing, or tool-execution failure without exposing provider response bodies or private prompt content. Provider bodies are intentionally not retained in the activity feed. The managed operation ledger remains the source of truth for route-level billing and provider fallback. Story Director activity is the source of truth for what happened after the provider returned.

Source-of-truth code

• apps/rc/src/lib/ai/jobs/worker.ts: active turn ordering, Story Director/Compendium concurrency, mechanics ownership, before/after phases, and Narrator loops.
• apps/rc/src/lib/ai/dm-stream/DMStreamService.ts: Director prompt construction, Interpreter entry point, model configuration, and Mechanics Agent adapter.
• apps/rc/src/lib/ai/dm/runDM.ts: planning, optional bookkeeping, dossier, and legacy Tracker phase orchestration.
• apps/rc/src/lib/ai/dm/runDMRound.ts: one Director/Mechanics inference call, schema/message token estimates, and tool execution.
• apps/rc/src/lib/ai/interpreter/run-interpreter.ts: one-call stateless shape-read.
• apps/rc/src/lib/ai/mechanics-agent/runMechanicsAgent.ts: Mechanics prompt and history bounds.
• apps/rc/src/lib/ai/mechanics-agent/runMechanicsPhase.ts: four-round Mechanics phase bound.
• apps/rc/src/lib/ai/mechanics-agent/transport.ts: Native/Tagged fallback and repair.
• apps/rc/src/lib/ai/jobs/mechanics-consequence-worker.ts: roll/interaction consequence phases.
• apps/rc/src/lib/mechanics/campaign/assistant.ts: campaign assistant request bounds.
• apps/rc/src/lib/mechanics/campaign/service.ts: offstage turns, reconciliation, Rules Forge, Rules Counsel, and encounter proposals.
• apps/rc/src/app/api/chat/generate-tracker-item/route.ts: manual Tracker generation and refresh calls.
• apps/rc/src/app/api/mechanics/sheets/generate/route.ts: generated sheet draft call.