@alexkroman1/aai-cli 5.14.0 → 6.1.0

package/dist/templates/solo-rpg/agent.test.ts

@@ -10,15 +10,15 @@ import {
   MIN_MOMENTUM,
   makeNpc,
   rollAction,
-  type StateSlot,
 } from "./shared.ts";
-import { actionRoll } from "./tools/action_roll.ts";
-import { burnMomentum } from "./tools/burn_momentum.ts";
-import { checkState } from "./tools/check_state.ts";
-import { loadGame } from "./tools/load_game.ts";
-import { saveGame } from "./tools/save_game.ts";
-import { setupCharacter } from "./tools/setup_character.ts";
-import { updateState } from "./tools/update_state.ts";
+import actionRoll from "./tools/action_roll.ts";
+import burnMomentum from "./tools/burn_momentum.ts";
+import checkState from "./tools/check_state.ts";
+import loadGame from "./tools/load_game.ts";
+import oracle from "./tools/oracle.ts";
+import saveGame from "./tools/save_game.ts";
+import setupCharacter from "./tools/setup_character.ts";
+import updateState from "./tools/update_state.ts";
 
 // ── Test doubles ─────────────────────────────────────────────────────────────
 
@@ -48,9 +48,10 @@ function makeDb(): { db: Db; rows: Map<string, unknown> } {
 }
 
 /** `send` is a spy rather than the recorder `createToolContext` installs,
- *  because this suite asserts call counts on it. */
-function makeCtx(sessionId = "session-a", db: Db = makeDb().db): ToolContext<StateSlot> {
-  return createToolContext<StateSlot>({ sessionId, db, send: vi.fn() });
+ *  because this suite asserts call counts on it. Each call gets its own slot
+ *  store, which is what makes two contexts two games. */
+function makeCtx(db: Db = makeDb().db): ToolContext {
+  return createToolContext({ db, send: vi.fn() });
 }
 
 const SETUP_ARGS = {
@@ -98,12 +99,12 @@ describe("setup_character", () => {
     await setupCharacter.execute(SETUP_ARGS, ctx);
 
     // Simulate a played, damaged game between setups.
-    const played = gameSlot.get(ctx);
-    played.health = 1;
-    played.momentum = -4;
-    played.chaosFactor = 8;
-    played.sceneCount = 42;
-    gameSlot.set(ctx, played);
+    gameSlot.update(ctx, (played) => {
+      played.health = 1;
+      played.momentum = -4;
+      played.chaosFactor = 8;
+      played.sceneCount = 42;
+    });
 
     const result = (await setupCharacter.execute(
       { ...SETUP_ARGS, playerName: "Luna" },
@@ -139,10 +140,14 @@ describe("setup_character", () => {
     expect(state.wits).toBe(3);
   });
 
-  test("game state is scoped per session — a second session sees a fresh game", async () => {
-    await setupCharacter.execute(SETUP_ARGS, makeCtx("session-a"));
-    // ctx.state is per-session by construction — a new session, a new game.
-    const other = (await checkState.execute({} as never, makeCtx("session-b"))) as {
+  test("a second, independent context sees a fresh game", async () => {
+    // What this really checks: the state lives in the SLOT and not in a
+    // module-level variable. `createToolContext()` hands each call its own
+    // detached slot store, so the isolation is per CONTEXT — two distinct
+    // session ids would prove nothing extra, and `sessionSlot` could stop
+    // keying by session with this still passing.
+    await setupCharacter.execute(SETUP_ARGS, makeCtx());
+    const other = (await checkState.execute({} as never, makeCtx())) as {
       initialized: boolean;
     };
     expect(other.initialized).toBe(false);
@@ -298,9 +303,9 @@ describe("burn_momentum", () => {
 
     // Strong hits cannot be upgraded
     seedRolledState(8, ctx);
-    const state = gameSlot.get(ctx);
-    state.lastRoll!.result = "STRONG_HIT";
-    gameSlot.set(ctx, state);
+    gameSlot.update(ctx, (state) => {
+      state.lastRoll!.result = "STRONG_HIT";
+    });
     result = (await burnMomentum.execute({} as never, ctx)) as Record<string, unknown>;
     expect(result.error).toMatch(/already a Strong Hit/);
   });
@@ -359,6 +364,122 @@ describe("rollAction", () => {
   });
 });
 
+// ── oracle ───────────────────────────────────────────────────────────────────
+//
+// `chaos_check` is the one oracle branch that WRITES: `checkChaosInterrupt`
+// lowers the chaos factor when the roll lands. It used to read the slot with
+// `gameSlot.get` and assign to what came back, under a comment claiming the
+// value was live — which described the removed `ctx.state` bag, not a slot. The
+// stored value is deep-frozen, so ~1 call in 5 at the default chaos factor (and
+// ~6 in 10 as it climbs) threw a `TypeError` instead of answering. These
+// assertions are on the STORED value for that reason: a body writing to a
+// private copy would pass every check on its own return value.
+
+describe("oracle", () => {
+  /** Force `d(sides)` to roll `value` on the next call. */
+  function mockRoll(value: number, sides: number) {
+    return vi.spyOn(Math, "random").mockReturnValue((value - 0.5) / sides);
+  }
+
+  test("a chaos interrupt that LANDS lowers the stored chaos factor", async () => {
+    const ctx = makeCtx();
+    const state = playingState();
+    state.chaosFactor = 9; // threshold 6 — a roll of 1 lands
+    gameSlot.set(ctx, state);
+    mockRoll(1, 10);
+
+    const result = (await oracle.execute({ type: "chaos_check" }, ctx)) as {
+      interrupted: boolean;
+      interruptType: string | null;
+      chaosFactor: number;
+    };
+
+    expect(result.interrupted).toBe(true);
+    expect(result.interruptType).toBeTruthy();
+    expect(result.chaosFactor).toBe(8);
+    // The half the old code could not do: the write reached the slot.
+    expect(gameSlot.get(ctx).chaosFactor).toBe(8);
+  });
+
+  test("the chaos factor floors at 3, where no roll is taken at all", async () => {
+    const ctx = makeCtx();
+    const state = playingState();
+    state.chaosFactor = 3; // threshold 0 — `checkChaosInterrupt` returns early
+    gameSlot.set(ctx, state);
+
+    const result = (await oracle.execute({ type: "chaos_check" }, ctx)) as {
+      interrupted: boolean;
+      chaosFactor: number;
+    };
+    expect(result.interrupted).toBe(false);
+    expect(gameSlot.get(ctx).chaosFactor).toBe(3);
+  });
+
+  test("a chaos check that MISSES changes nothing", async () => {
+    const ctx = makeCtx();
+    const state = playingState();
+    state.chaosFactor = 5; // threshold 2
+    gameSlot.set(ctx, state);
+    mockRoll(10, 10); // past the threshold
+
+    const result = (await oracle.execute({ type: "chaos_check" }, ctx)) as {
+      interrupted: boolean;
+      chaosFactor: number;
+    };
+    expect(result.interrupted).toBe(false);
+    expect(result.chaosFactor).toBe(5);
+    expect(gameSlot.get(ctx).chaosFactor).toBe(5);
+  });
+
+  test("a chaos check on an untouched session starts from the default factor", async () => {
+    const ctx = makeCtx();
+    mockRoll(1, 10); // DEFAULT_STATE.chaosFactor is 5, so threshold 2 — lands
+    const result = (await oracle.execute({ type: "chaos_check" }, ctx)) as { chaosFactor: number };
+    expect(result.chaosFactor).toBe(DEFAULT_STATE.chaosFactor - 1);
+    expect(gameSlot.get(ctx).chaosFactor).toBe(DEFAULT_STATE.chaosFactor - 1);
+  });
+
+  test("yes_no maps the d6 onto its three answers", async () => {
+    const ctx = makeCtx();
+    for (const [roll, answer] of [
+      [1, "No"],
+      [2, "No"],
+      [3, "Yes, but with a complication"],
+      [4, "Yes, but with a complication"],
+      [5, "Yes"],
+      [6, "Yes"],
+    ] as const) {
+      mockRoll(roll, 6);
+      const result = (await oracle.execute({ type: "yes_no" }, ctx)) as {
+        roll: number;
+        answer: string;
+      };
+      expect.soft(result, `roll ${roll}`).toEqual({ type: "yes_no", roll, answer });
+    }
+  });
+
+  test("the four inspiration branches answer without touching the game", async () => {
+    const ctx = makeCtx();
+    gameSlot.set(ctx, playingState());
+    const before = structuredClone(gameSlot.get(ctx));
+
+    const reaction = (await oracle.execute({ type: "npc_reaction" }, ctx)) as { reaction: string };
+    const twist = (await oracle.execute({ type: "scene_twist" }, ctx)) as { twist: string };
+    const theme = (await oracle.execute({ type: "action_theme" }, ctx)) as {
+      action: string;
+      theme: string;
+      seed: string;
+    };
+
+    expect(reaction.reaction).toBeTruthy();
+    expect(twist.twist).toBeTruthy();
+    expect(theme.action).toBeTruthy();
+    expect(theme.theme).toBeTruthy();
+    expect(theme.seed.split(" ")).toHaveLength(3);
+    expect(gameSlot.get(ctx)).toEqual(before);
+  });
+});
+
 // ── update_state: clocks, caps, validation ───────────────────────────────────
 
 describe("update_state", () => {
@@ -430,7 +551,7 @@ describe("save_game / load_game", () => {
     const { db, rows } = makeDb();
 
     // Session A plays and saves.
-    const sessionA = makeCtx("session-a", db);
+    const sessionA = makeCtx(db);
     const played = playingState();
     played.playerName = "Kael";
     played.sceneCount = 7;
@@ -443,8 +564,8 @@ describe("save_game / load_game", () => {
     expect(saved.slot).toBe("chapter-2");
     expect(rows.get("save:chapter-2")).toMatchObject({ playerName: "Kael", sceneCount: 7 });
 
-    // Session B (fresh ctx.state, same app db) resumes it.
-    const sessionB = makeCtx("session-b", db);
+    // Session B (a fresh game slot, the same app db) resumes it.
+    const sessionB = makeCtx(db);
     const loaded = (await loadGame.execute({ slot: "chapter-2" }, sessionB)) as Record<
       string,
       unknown
@@ -463,10 +584,12 @@ describe("save_game / load_game", () => {
 
   test("saving twice to one slot upserts — the newer save wins", async () => {
     const { db, rows } = makeDb();
-    const ctx = makeCtx("session-a", db);
+    const ctx = makeCtx(db);
     gameSlot.set(ctx, playingState());
     await saveGame.execute({}, ctx); // autosave
-    gameSlot.get(ctx).sceneCount = 9;
+    gameSlot.update(ctx, (game) => {
+      game.sceneCount = 9;
+    });
     await saveGame.execute({}, ctx);
     expect(rows.size).toBe(1);
     expect(rows.get("save:autosave")).toMatchObject({ sceneCount: 9 });

package/dist/templates/solo-rpg/agent.ts

@@ -1,18 +1,8 @@
 import { agent } from "@alexkroman1/aai";
 import { gameSlot } from "./shared.ts";
-import systemPrompt from "./system-prompt.md?raw";
-import { actionRoll } from "./tools/action_roll.ts";
-import { burnMomentum } from "./tools/burn_momentum.ts";
-import { checkState } from "./tools/check_state.ts";
-import { loadGame } from "./tools/load_game.ts";
-import { oracle } from "./tools/oracle.ts";
-import { saveGame } from "./tools/save_game.ts";
-import { setupCharacter } from "./tools/setup_character.ts";
-import { updateState } from "./tools/update_state.ts";
 
 export default agent({
   name: "Solo RPG",
-  systemPrompt,
   greeting:
     "Welcome. Tell me your name, or describe the kind of story you want, and we will begin. You can say something like, dark fantasy warrior named Kael, or just give me a name and I will build a world around you.",
   sttPrompt:
@@ -22,15 +12,7 @@ export default agent({
   // One declaration replaces a `ctx.send("game_state", state)` in every
   // state-mutating tool — six of them, and adding a seventh meant
   // remembering to push or watching the UI quietly fall out of sync.
-  syncState: gameSlot.read,
-  tools: {
-    action_roll: actionRoll,
-    burn_momentum: burnMomentum,
-    check_state: checkState,
-    load_game: loadGame,
-    oracle,
-    save_game: saveGame,
-    setup_character: setupCharacter,
-    update_state: updateState,
-  },
+  // The identity projection: this campaign IS what the client renders, and the
+  // slot's own default is what a session that has run no tool projects.
+  syncState: gameSlot.projection((game) => game),
 });

package/dist/templates/solo-rpg/client.tsx

@@ -1,12 +1,13 @@
 import "@alexkroman1/aai-ui/styles.css";
+import type { DeepReadonly } from "@alexkroman1/aai";
 import { ChatView, client, SidebarLayout, StartScreen, useAgentState } from "@alexkroman1/aai-ui";
 import type { ReactNode } from "react";
 import {
   type Clock,
-  DEFAULT_STATE,
   type Disposition,
   type GameState,
   GENRES,
+  gameSlot,
   MAX_RESOURCE,
   MIN_MOMENTUM,
   type NPC,
@@ -14,6 +15,18 @@ import {
   type TIME_PHASES,
 } from "./shared.ts";
 
+// The campaign before the first tool call, derived from the SAME projection the
+// server pushes rather than from the module default beside it — so a session
+// that has run no tool renders exactly what its first push will replace. Every
+// sibling template derives its fallback this way; this one read `DEFAULT_STATE`
+// directly, which is a second copy of "what an untouched session looks like".
+//
+// It is typed READONLY because that is what the projection produces, and a
+// client only ever renders what the server pushed — so the four components
+// below take a readonly campaign too, which is the deep-readonly slot
+// propagating exactly as far as it should.
+const EMPTY_GAME = gameSlot.projection((game) => game)(undefined);
+
 // ── Color Palette ────────────────────────────────────────────────────────────
 const C = {
   bg: "#0a0a0c",
@@ -290,7 +303,7 @@ function StatPip({ label, value }: { label: string; value: number }) {
   );
 }
 
-function ClockDisplay({ clock }: { clock: Clock }) {
+function ClockDisplay({ clock }: { clock: DeepReadonly<Clock> }) {
   const typeColor =
     clock.clockType === "threat"
       ? C.threat
@@ -355,7 +368,7 @@ function ClockDisplay({ clock }: { clock: Clock }) {
   );
 }
 
-function NpcCard({ npc }: { npc: NPC }) {
+function NpcCard({ npc }: { npc: DeepReadonly<NPC> }) {
   const dispColor = C.disposition[npc.disposition] || C.textMuted;
   const icon = DISP_ICON[npc.disposition] || "\u25CB";
   return (
@@ -390,7 +403,7 @@ function NpcCard({ npc }: { npc: NPC }) {
   );
 }
 
-function StoryArc({ story }: { story: StoryBlueprint }) {
+function StoryArc({ story }: { story: DeepReadonly<StoryBlueprint> }) {
   const totalActs = story.acts.length;
   const currentPhase = story.acts[story.currentAct - 1]?.phase ?? "";
   const pct = totalActs > 0 ? ((story.currentAct - 1) / totalActs) * 100 : 0;
@@ -443,7 +456,7 @@ function StoryArc({ story }: { story: StoryBlueprint }) {
 
 // ── Sidebar ──────────────────────────────────────────────────────────────────
 
-function Sidebar({ game }: { game: GameState }) {
+function Sidebar({ game }: { game: DeepReadonly<GameState> }) {
   return (
     <div
       style={{
@@ -771,7 +784,7 @@ function SoloRPGApp() {
   // The agent's own session state, projected by `syncState` and pushed after
   // every tool call — no per-tool `ctx.send`, and nothing to keep in step
   // when a new tool starts mutating the game.
-  const game = useAgentState<GameState>(DEFAULT_STATE);
+  const game = useAgentState<DeepReadonly<GameState>>(EMPTY_GAME);
 
   return (
     <StartScreen

package/dist/templates/solo-rpg/shared.ts

@@ -1,4 +1,4 @@
-import { type SlotStateOf, sessionSlot, type ToolContext } from "@alexkroman1/aai";
+import { type DeepReadonly, sessionSlot, type ToolContext } from "@alexkroman1/aai";
 import { z } from "zod";
 
 // ── Tuning Constants ─────────────────────────────────────────────────────────
@@ -320,16 +320,24 @@ export const DEFAULT_STATE: GameState = {
   kidMode: false,
 };
 
-// ── Live game state (ctx.state) ─────────────────────────────────────────────
-// The in-play game lives in `ctx.state`, the agent's per-session mutable
-// state — concurrent players get independent games by construction, and the
-// live game needs no persistence of its own (that's what save slots are for).
-// The clone is load-bearing: `DEFAULT_STATE` is one module-level object shared
-// by every session in the process, so a mutation without it would let one
-// player's game show up in another's.
+// ── Live game state (one session slot) ───────────────────────────────────────
+// The in-play game lives in one `sessionSlot`, keyed per session — concurrent
+// players get independent games by construction. The clone is load-bearing:
+// `DEFAULT_STATE` is one module-level object shared by every session in the
+// process, so a factory without it would let one player's game show up in
+// another's.
 export const gameSlot = sessionSlot("game", () => structuredClone(DEFAULT_STATE));
 
-export type StateSlot = SlotStateOf<typeof gameSlot>;
+/**
+ * The game as a READ hands it out: deep-frozen, and typed to say so.
+ *
+ * Every pure helper below takes this rather than {@link GameState}, which is
+ * the widening a deep-readonly slot forces and the reason it is worth doing:
+ * a mutable `GameState` still satisfies it, so a helper called with an
+ * `updateTool` draft is unaffected, while a helper that WOULD have mutated
+ * stops compiling instead of throwing at its first call in production.
+ */
+export type FrozenGameState = DeepReadonly<GameState>;
 
 // ── Persistent save slots (ctx.db) ───────────────────────────────────────────
 // save_game / load_game are genuine cross-session persistence, so they use
@@ -433,7 +441,7 @@ export function makeNpc(opts: {
   };
 }
 
-export function clockSummary(c: Clock) {
+export function clockSummary(c: DeepReadonly<Clock>) {
   return {
     id: c.id,
     name: c.name,
@@ -450,7 +458,7 @@ export function clockSummary(c: Clock) {
  * setup_character, update_state, and check_state. Includes the player's
  * content boundaries (contentLines) so they survive past the setup turn.
  */
-export function stateSummary(state: GameState) {
+export function stateSummary(state: FrozenGameState) {
   return {
     initialized: state.initialized,
     phase: state.phase,

package/dist/templates/solo-rpg/tools/action_roll.ts

@@ -1,4 +1,3 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   applyConsequences,
@@ -12,7 +11,7 @@ import {
   updateChaosFactor,
 } from "../shared.ts";
 
-export const actionRoll = tool({
+export default gameSlot.updateTool({
   description:
     "Core mechanic. Roll 2d6 + stat (capped at 10) vs 2d10 challenge dice. Also applies consequences (health/spirit/supply/momentum changes, clock advancement) based on move type, position, and result. Call for ANY risky action. Pure conversation needs no roll.",
   inputSchema: z.object({
@@ -25,8 +24,7 @@ export const actionRoll = tool({
     purpose: z.string().max(300).describe("What the character is attempting"),
     targetNpcId: z.string().max(32).describe("Target NPC id for social moves").optional(),
   }),
-  async execute(args, ctx) {
-    const state = gameSlot.get(ctx);
+  execute(args, state) {
     const statValue = state[args.stat];
     const roll = rollAction(args.stat, statValue, args.move);
 

package/dist/templates/solo-rpg/tools/burn_momentum.ts

@@ -1,4 +1,3 @@
-import { tool } from "@alexkroman1/aai";
 import {
   applyConsequences,
   canBurnMomentum,
@@ -8,11 +7,10 @@ import {
   revertConsequences,
 } from "../shared.ts";
 
-export const burnMomentum = tool({
+export default gameSlot.updateTool({
   description:
     "Burn momentum to upgrade the most recent action roll. Only valid when current momentum beats the roll's challenge dice (both dice for a full upgrade, one for Miss to Weak Hit). Reverts the original result's consequences, applies the upgraded result, and resets momentum to +2.",
-  async execute(_args, ctx) {
-    const state = gameSlot.get(ctx);
+  execute(_args, state) {
     const last = state.lastRoll;
     if (!last) return { error: "No recent action roll to upgrade. Roll first." };
     if (last.result === "STRONG_HIT") {

package/dist/templates/solo-rpg/tools/check_state.ts

@@ -1,11 +1,11 @@
-import { tool } from "@alexkroman1/aai";
 import { gameSlot, stateSummary } from "../shared.ts";
 
-export const checkState = tool({
+// `gameSlot.tool`, the READING half: the body is handed the value, so it needs
+// neither a context annotation nor an opening `gameSlot.get(ctx)` — and what it
+// is handed is deep-frozen, which is what makes "this tool only reads" a
+// property of the declaration rather than a claim in a comment.
+export default gameSlot.tool({
   description:
     "Returns the full current game state. Call this at the start of every turn, before narrating or rolling, and treat the returned values as ground truth — never guess or remember stats from previous turns.",
-  async execute(_args, ctx) {
-    const state = gameSlot.get(ctx);
-    return stateSummary(state);
-  },
+  execute: (_args, game) => stateSummary(game),
 });

package/dist/templates/solo-rpg/tools/load_game.ts

@@ -5,7 +5,7 @@ import { gameSlot, loadState, saveSlotKey, saveSlotParam } from "../shared.ts";
 
 // Requires storage — `aai storage enable` (or DATABASE_URL in .env under
 // `aai dev`); the rest of the game works without it.
-export const loadGame = tool({
+export default tool({
   description: "Load a previously saved game.",
   inputSchema: z.object({ slot: saveSlotParam }),
   async execute(args, ctx) {

package/dist/templates/solo-rpg/tools/oracle.ts

@@ -202,7 +202,7 @@ const THEMES = [
   "Wound",
 ];
 
-export const oracle = tool({
+export default tool({
   description:
     "Consult the oracle for narrative inspiration. Generates random prompts from thematic tables.",
   inputSchema: z.object({
@@ -210,7 +210,7 @@ export const oracle = tool({
       .enum(["action_theme", "npc_reaction", "scene_twist", "yes_no", "chaos_check"])
       .describe("Type of oracle consultation"),
   }),
-  async execute(args, ctx) {
+  execute(args, ctx) {
     if (args.type === "yes_no") {
       const roll = d(6);
       const answer = roll <= 2 ? "No" : roll <= 4 ? "Yes, but with a complication" : "Yes";
@@ -218,15 +218,22 @@ export const oracle = tool({
     }
 
     if (args.type === "chaos_check") {
-      // gameSlot.get returns the live state object — mutations stick.
-      const state = gameSlot.get(ctx);
-      const interrupt = checkChaosInterrupt(state);
-      return {
-        type: "chaos_check",
-        chaosFactor: state.chaosFactor,
-        interrupted: Boolean(interrupt),
-        interruptType: interrupt,
-      };
+      // `checkChaosInterrupt` LOWERS the chaos factor when the roll lands, so
+      // this branch is a write and has to go through the slot's mutation
+      // window: `gameSlot.get` hands out the deep-frozen stored value, and
+      // assigning to it is a compile error and a `TypeError`. It is one branch
+      // of five, which is why this stays an ordinary `tool()` with a scoped
+      // `update` rather than becoming `gameSlot.updateTool` — the other four
+      // read nothing and store nothing.
+      return gameSlot.update(ctx, (game) => {
+        const interrupt = checkChaosInterrupt(game);
+        return {
+          type: "chaos_check",
+          chaosFactor: game.chaosFactor,
+          interrupted: Boolean(interrupt),
+          interruptType: interrupt,
+        };
+      });
     }
 
     if (args.type === "npc_reaction") {

package/dist/templates/solo-rpg/tools/save_game.ts

@@ -1,20 +1,23 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import { gameSlot, saveSlotKey, saveSlotParam, saveState } from "../shared.ts";
 
 // Requires storage — `aai storage enable` (or DATABASE_URL in .env under
 // `aai dev`); the rest of the game works without it.
-export const saveGame = tool({
+//
+// `gameSlot.tool` even though the body AWAITS: the reading half places no
+// constraint on the body (only `updateTool` must be synchronous, because its
+// draft is stored when it returns). What it does place is the frozen value, and
+// a save is the purest read there is.
+export default gameSlot.tool({
   description: "Save current game to persistent storage.",
   inputSchema: z.object({ slot: saveSlotParam }),
-  async execute(args, ctx) {
-    const state = gameSlot.get(ctx);
-    await saveState(ctx, saveSlotKey(args.slot), state);
+  async execute(args, game, ctx) {
+    await saveState(ctx, saveSlotKey(args.slot), game);
     return {
       saved: true,
       slot: args.slot ?? "autosave",
-      name: state.playerName,
-      scene: state.sceneCount,
+      name: game.playerName,
+      scene: game.sceneCount,
     };
   },
 });

package/dist/templates/solo-rpg/tools/setup_character.ts

@@ -18,7 +18,7 @@ import {
   TONES,
 } from "../shared.ts";
 
-export const setupCharacter = tool({
+export default tool({
   description:
     "Set up the entire game in one call. Starts a completely fresh game (any previous unsaved game is replaced), generates stats, initializes state, and marks the game as ready. After this returns, just narrate the opening scene. No need to call update_state — everything is already done.",
   inputSchema: z.object({

package/dist/templates/solo-rpg/tools/update_state.ts

@@ -1,4 +1,4 @@
-import { pushCapped, tool } from "@alexkroman1/aai";
+import { pushCapped } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   DEFAULT_CLOCK_SEGMENTS,
@@ -19,7 +19,7 @@ import {
   updateCrisisFlags,
 } from "../shared.ts";
 
-export const updateState = tool({
+export default gameSlot.updateTool({
   description:
     "Lightweight state sync for during gameplay. Handles location changes, NPC additions, clock additions, time changes, and session log entries. Resource changes (health/spirit/supply/momentum) are auto-applied by action_roll — only use those fields here for manual adjustments like resting or trading. Pass only what changed.",
   inputSchema: z.object({
@@ -54,8 +54,7 @@ export const updateState = tool({
     storyComplete: z.boolean().describe("Mark story as complete").optional(),
     logEntry: z.string().max(500).describe("Short log entry for this scene").optional(),
   }),
-  async execute(args, ctx) {
-    const state = gameSlot.get(ctx);
+  execute(args, state) {
     const warnings: string[] = [];
     const clockEvents: { clock: string; trigger: string }[] = [];