@alexkroman1/aai-cli 6.11.0 → 8.0.0

package/dist/templates/math-buddy/agent.eval.test.ts

@@ -0,0 +1,146 @@
+// An EVAL: does Math Buddy delegate every calculation to code? Run it with
+// `aai eval`.
+//
+// This tutor's whole design is "the model does the talking, run_code does the
+// arithmetic" — which is also why it runs on Flash-Lite. So the claim worth
+// pinning is not that the answer is right, it is that the answer came from
+// CODE, and that the code is the recipe the prompt gave.
+//
+// Two things this file has to work around, both explained at length in
+// `../code-interpreter/agent.eval.test.ts`: `system-prompt.md` is discovered by
+// the build rather than imported, so an eval has to apply it or it measures a
+// different agent; and `run_code` refuses unless the EVAL supplies an executor,
+// which this suite does — so the cases below assert the answer the code came
+// back with as well as the code the tutor wrote.
+import { runInNewContext } from "node:vm";
+import { withSystemPrompt } from "@alexkroman1/aai/manifest";
+import { errorMessage } from "@alexkroman1/aai/utils";
+import type { RunCodeExecutor } from "@alexkroman1/aai-runtime/eval";
+import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
+import { expect } from "vitest";
+import authored from "./agent.ts";
+import systemPrompt from "./system-prompt.md?raw";
+
+const agentDef = withSystemPrompt(authored, systemPrompt);
+
+/** The code every `run_code` call in this turn carried, joined. */
+const codeIn = (turn: { toolCalls: readonly { name: string; args: Record<string, unknown> }[] }) =>
+  turn.toolCalls
+    .filter((c) => c.name === "run_code")
+    .map((c) => String(c.args.code ?? ""))
+    .join("\n");
+
+/**
+ * A `run_code` executor, so these cases can assert the ANSWER.
+ *
+ * The builtin refuses without one — the Modal container is the security
+ * boundary, and off-platform there is none — so a case could assert the CALL and
+ * the code it carried, and never what the code came back with. A `node:vm`
+ * context with a capturing `console.log` is what a developer would reach for on
+ * their own machine, and it is enough here: what runs is arithmetic, not a
+ * program. It is NOT a sandbox and does not pretend to be one; a deployed agent
+ * still gets the refusal.
+ *
+ * A template eval imports from `@alexkroman1/aai-runtime/eval` and
+ * `/eval/vitest` and nowhere else — the ROOT barrel drags the host runtime's
+ * node-reaching module graph into this project's TypeScript program, which is
+ * three errors in runtime files no eval ever calls. `RunCodeExecutor` is
+ * re-exported from `/eval` for exactly that reason.
+ */
+const runCode: RunCodeExecutor = async (code) => {
+  const lines: string[] = [];
+  const log = (...args: unknown[]): void => {
+    lines.push(args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "));
+  };
+  try {
+    runInNewContext(code, { console: { log } }, { timeout: 1000 });
+  } catch (err) {
+    return { error: errorMessage(err) };
+  }
+  return lines.join("\n");
+};
+
+/** What every `run_code` call in this turn PRINTED, joined. */
+const outputIn = (turn: { toolCalls: readonly { name: string; result?: string }[] }) =>
+  turn.toolCalls
+    .filter((c) => c.name === "run_code")
+    .map((c) => c.result ?? "")
+    .join("\n");
+
+describeEval(
+  agentDef,
+  (test) => {
+    test(
+      "converts units in code, with a real conversion factor",
+      async ({ session }) => {
+        const turn = await session.say("Convert 5 miles to kilometres.");
+
+        // The prompt hands the tutor the factors; the finding it guards against
+        // is a tutor that recites a remembered figure instead. A factor in the
+        // code is the evidence that the conversion was computed, not recalled.
+        expect(turn.toolCalls.map((c) => c.name)).toContain("run_code");
+        const code = codeIn(turn);
+        expect(code).toContain("5");
+        expect(code).toMatch(/1\.60|1\.61|0\.621|8\.04/);
+        // And the factor was applied rather than merely mentioned: five miles is
+        // 8.0467 km, so whatever rounding the tutor chose the answer starts 8.0.
+        const output = outputIn(turn);
+        expect(output, `run_code printed: ${output}`).toMatch(/8\.0/);
+      },
+      { live: true },
+    );
+
+    test(
+      "rolls dice with a random draw rather than inventing numbers",
+      async ({ session }) => {
+        const turn = await session.say("Roll 3 twenty-sided dice for me.");
+
+        // A model asked for dice will happily make three numbers up, and the
+        // reply is indistinguishable from a real roll. `Math.random` in the code
+        // is the only thing that tells them apart.
+        expect(turn.toolCalls.map((c) => c.name)).toContain("run_code");
+        const code = codeIn(turn);
+        expect(code).toMatch(/Math\.random/);
+        expect(code).toContain("20");
+        expect(code).toContain("3");
+
+        // And the draw really happened: three integers, every one of them a legal
+        // face of a twenty-sided die. `Math.random` in the code says the tutor
+        // asked for a roll; this says it GOT one — a `run_code` that refused
+        // prints a sentence with no dice in it at all.
+        const output = outputIn(turn);
+        const rolled = [...output.matchAll(/\d+/g)].map((m) => Number(m[0]));
+        expect(rolled.length, `run_code printed: ${output}`).toBeGreaterThanOrEqual(3);
+        for (const face of rolled) {
+          expect(face, `run_code printed: ${output}`).toBeGreaterThanOrEqual(1);
+          expect(face, `run_code printed: ${output}`).toBeLessThanOrEqual(20);
+        }
+      },
+      { live: true },
+    );
+
+    test(
+      "the run_code builtin is wired to the agent's tool executor",
+      async ({ session }) => {
+        const turn = await session.say("What is 127 times 849?");
+
+        // A tool the agent does not declare produces a `tool.called` with no
+        // result, so the paired result is what says `builtinTools: ["run_code"]`
+        // still resolves to something executable. The ANSWER rather than
+        // `toBeDefined()`, which the refusal string satisfied too.
+        const [call] = turn.toolCalls;
+        expect(call?.name).toBe("run_code");
+        expect(call?.result).toBe("107823");
+        expect(turn.completed).toBe(true);
+      },
+      {
+        stubReply: [
+          { tool: "run_code", args: { code: "console.log(127 * 849)" } },
+          "That's 107,823.",
+        ],
+      },
+    );
+  },
+  // `runCode` is what makes these cases about the ANSWER and not just the call.
+  { runCode },
+);

package/dist/templates/night-owl/agent.eval.test.ts

@@ -0,0 +1,272 @@
+/// <reference types="vite/client" />
+
+// An EVAL: does the companion actually pick from its own shelf?
+//
+// `agent.test.ts` calls `recommend` directly, which settles what the tool does
+// with a category and a mood it is handed. What it cannot settle is whether the
+// MODEL turns "something cozy to watch" into `{ category: "movie", mood:
+// "cozy" }` rather than reciting three films it likes — and whether the night's
+// log, which lives in a `sessionSlot`, is still there two turns later.
+//
+// Run it with `aai eval`. Without a provider key every case runs against a
+// SCRIPTED model (its `stubReply`): the real session, the real slot, the real
+// tool, a fake reply. That proves the wiring and nothing about the choice.
+
+import { runInNewContext } from "node:vm";
+import { withSystemPrompt } from "@alexkroman1/aai/manifest";
+import type { SessionEvent } from "@alexkroman1/aai/protocol";
+import { withDiscoveredTools } from "@alexkroman1/aai/testing";
+import { errorMessage } from "@alexkroman1/aai/utils";
+import {
+  customEventsIn,
+  lastStateIn,
+  type RunCodeExecutor,
+  toolResultIn,
+} from "@alexkroman1/aai-runtime/eval";
+import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
+import { expect } from "vitest";
+import { z } from "zod";
+import authoredAgent from "./agent.ts";
+import { CATEGORIES, MOODS } from "./shared.ts";
+import systemPrompt from "./system-prompt.md?raw";
+
+/**
+ * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
+ *
+ * The glob is written HERE rather than reached for from a shared helper because
+ * this file SHIPS — a scaffolded project has no repo helper to import. Without
+ * it the eval would drive an agent with no `recommend` at all, which is the one
+ * failure a green eval must never be able to hide.
+ *
+ * And plus its PROMPT. `agent.ts` does not declare one — `system-prompt.md` is
+ * resolved by the BUILD (`aai build`/`aai deploy`), so the raw default export
+ * carries the FRAMEWORK DEFAULT prompt. An eval that drives it measures a
+ * different agent than the one that deploys, and every tool-choice claim below
+ * then passes or fails for the wrong reason.
+ */
+const agentDef = withSystemPrompt(
+  withDiscoveredTools(authoredAgent, import.meta.glob("./tools/*.ts", { eager: true })),
+  systemPrompt,
+);
+
+/**
+ * One `recommend` answer, and the whole projection, as the wire carries them.
+ *
+ * Schemas rather than casts, which is what `toolResultIn` and `lastStateIn`
+ * take one for: a shelf or a projection that stopped matching FAILS here naming
+ * the field, where a cast hands the assertions `undefined` and fails a line
+ * later on something unrelated.
+ */
+const RecSchema = z.object({
+  category: z.enum(CATEGORIES),
+  mood: z.enum(MOODS),
+  picks: z.array(z.string()),
+});
+const ProjectedNight = z.object({ recs: z.array(RecSchema) });
+
+/**
+ * The night's log as the PAGE has it: the last `syncState` frame pushed.
+ *
+ * This agent declares one projection, so the frame IS `nightProjection`'s
+ * result — the same `{ recs }` value `useAgentState(nightProjection)` reads in
+ * `client.tsx`. Asserting on it is asserting on what the sidebar shows.
+ */
+const pushedRecs = (events: readonly SessionEvent[]) =>
+  lastStateIn(events, ProjectedNight)?.recs ?? [];
+
+/** The `wind_down` nudges in `events` — `customEventsIn` filters by name. */
+const nudges = (events: readonly SessionEvent[]) => customEventsIn(events, "wind_down");
+
+/**
+ * A `run_code` executor, so the sleep-cycle case can assert the ANSWER.
+ *
+ * The builtin refuses without one — the Modal container is the security
+ * boundary, and off-platform there is none — which left this template's
+ * headline feature assertable as a CALL and never as a number. A `node:vm`
+ * context with a capturing `console.log` is what a developer would reach for on
+ * their own machine, and it is enough: the code under test is arithmetic the
+ * model wrote, not a program.
+ *
+ * A template eval imports from `@alexkroman1/aai-runtime/eval` and
+ * `/eval/vitest` and nowhere else — the ROOT barrel drags the host runtime's
+ * node-reaching module graph into this project's TypeScript program, which is
+ * three errors in runtime files no eval ever calls. `RunCodeExecutor` is
+ * re-exported from `/eval` for exactly that reason.
+ */
+const runCode: RunCodeExecutor = async (code) => {
+  const lines: string[] = [];
+  const log = (...args: unknown[]): void => {
+    lines.push(args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "));
+  };
+  try {
+    runInNewContext(code, { console: { log } }, { timeout: 1000 });
+  } catch (err) {
+    return { error: errorMessage(err) };
+  }
+  return lines.join("\n");
+};
+
+/** Two-digit, for the clock arithmetic below. */
+const pad = (n: number): string => String(n).padStart(2, "0");
+
+/**
+ * Every bedtime `system-prompt.md`'s recipe admits for a given wake-up hour,
+ * in each of the spellings a tutor might print it in.
+ *
+ * Derived from the recipe rather than typed out — 90 minutes a cycle plus 15 to
+ * fall asleep, wrapped into the previous day — so this and the prompt cannot
+ * disagree about the arithmetic the case is checking.
+ */
+const bedtimesFor = (wakeHour: number): string[] =>
+  [3, 4, 5, 6].flatMap((cycles) => {
+    const at = (wakeHour * 60 - (cycles * 90 + 15) + 1440) % 1440;
+    const hour = Math.floor(at / 60);
+    const minute = pad(at % 60);
+    // Three spellings per time, because the prompt asks for HH:MM and a tutor
+    // reasonably prints any of them: padded, unpadded (measured — a live run
+    // printed "0:45" for four cycles), and the 12-hour clock.
+    return [
+      `${pad(hour)}:${minute}`,
+      `${hour}:${minute}`,
+      `${hour % 12 === 0 ? 12 : hour % 12}:${minute}`,
+    ];
+  });
+
+describeEval(
+  agentDef,
+  (test) => {
+    test(
+      "turns a mood into the category and mood the tool takes",
+      async ({ session }) => {
+        const turn = await session.say("I want something cozy to watch tonight.");
+
+        // "to watch" is the category and "cozy" is the mood; the shelf is the
+        // tool's, so answering from the model's own taste is the regression.
+        expect(turn.toolCalls.map((c) => c.name)).toEqual(["recommend"]);
+        const call = turn.toolCalls[0]!;
+        expect(call.args).toEqual({ category: "movie", mood: "cozy" });
+
+        // And what it read out came back from the shelf: the tool answers with
+        // the picks for exactly the pair it was asked for.
+        const rec = toolResultIn(turn.toolCalls, "recommend", RecSchema);
+        expect(rec).toMatchObject({ category: "movie", mood: "cozy" });
+        expect(rec.picks.length).toBeGreaterThan(0);
+        // It read out what the shelf handed back rather than a title of its own.
+        expect(rec.picks.some((pick) => turn.text.includes(pick))).toBe(true);
+      },
+      {
+        stubReply: [
+          { tool: "recommend", args: { category: "movie", mood: "cozy" } },
+          "Paddington 2 is the coziest thing I own.",
+        ],
+      },
+    );
+
+    test(
+      "the night's log keeps what an earlier turn picked, newest first",
+      async ({ session }) => {
+        await session.say("I want something cozy to watch tonight.");
+        const turn = await session.say("Now give me something spooky to read.");
+
+        expect(turn.toolCalls.map((c) => c.name)).toEqual(["recommend"]);
+        expect(turn.toolCalls[0]!.args).toEqual({ category: "book", mood: "spooky" });
+
+        // The slot survived the turn boundary: the frame the page renders after
+        // the second answer still carries the first, and the newest is first —
+        // which is the order the sidebar lists them in.
+        const recs = pushedRecs(session.events());
+        expect(recs.map((r) => `${r.category}/${r.mood}`)).toEqual(["book/spooky", "movie/cozy"]);
+      },
+      {
+        stubReply: [
+          { tool: "recommend", args: { category: "movie", mood: "cozy" } },
+          "Paddington 2 it is.",
+          { tool: "recommend", args: { category: "book", mood: "spooky" } },
+          "Mexican Gothic, then.",
+        ],
+      },
+    );
+
+    test(
+      "the wind-down nudge arrives once, on the third pick",
+      async ({ session }) => {
+        const first = await session.say("I want something cozy to watch tonight.");
+        expect(nudges(first.events)).toEqual([]);
+        const second = await session.say("Now give me something spooky to read.");
+        expect(nudges(second.events)).toEqual([]);
+
+        // Counted in the SLOT, so the third pick is only the third if the two
+        // before it were still there — and it is a `ctx.send`, not a field on the
+        // projection, so it must arrive exactly once and never be replayed.
+        const third = await session.say("And some chill music too.");
+        expect(nudges(third.events)).toHaveLength(1);
+
+        const fourth = await session.say("One funny book as well, please.");
+        expect(nudges(fourth.events)).toEqual([]);
+        expect(nudges(session.events())).toHaveLength(1);
+        expect(pushedRecs(session.events())).toHaveLength(4);
+      },
+      {
+        stubReply: [
+          { tool: "recommend", args: { category: "movie", mood: "cozy" } },
+          "Paddington 2 it is.",
+          { tool: "recommend", args: { category: "book", mood: "spooky" } },
+          "Mexican Gothic, then.",
+          { tool: "recommend", args: { category: "music", mood: "chill" } },
+          "Tycho, Dive.",
+          { tool: "recommend", args: { category: "book", mood: "funny" } },
+          "Good Omens.",
+        ],
+      },
+    );
+    test(
+      "works the bedtime out in CODE, and the number is right",
+      async ({ session }) => {
+        const turn = await session.say(
+          "I need to be up at 7 in the morning. When should I fall asleep?",
+        );
+
+        const ran = turn.toolCalls.filter((c) => c.name === "run_code");
+        expect(
+          ran,
+          `tools called: [${turn.toolCalls.map((c) => c.name).join(", ")}]; said: ${turn.text}`,
+        ).not.toEqual([]);
+        // The recipe is the prompt's, and it is two constants: a 90-minute cycle
+        // plus the 15 minutes it takes to fall asleep. Arithmetic done in the
+        // model's head has neither of them anywhere in the code.
+        const code = ran.map((c) => String(c.args.code ?? "")).join("\n");
+        expect(code).toContain("90");
+        expect(code).toContain("15");
+
+        const output = ran.map((c) => c.result ?? "").join("\n");
+        // The builtin really EXECUTED. With no `runCode` executor this string is
+        // "run_code is only available in the sandboxed runtime", which every
+        // assertion about a CALL sails past — so this template's headline
+        // feature could be checked as a call and never as an answer.
+        expect(output).not.toMatch(/only available in the sandboxed runtime/);
+        // And the answer is a whole number of cycles back from 07:00 with the
+        // quarter hour added. A tutor that dropped the 15 lands on :00 and a
+        // tutor that guessed lands anywhere; both fail here.
+        expect(output, `run_code printed: ${output}`).toMatch(new RegExp(bedtimesFor(7).join("|")));
+      },
+      {
+        stubReply: [
+          {
+            tool: "run_code",
+            args: {
+              code: [
+                "const wake = 7 * 60;",
+                "const at = (wake - (6 * 90 + 15) + 1440) % 1440;",
+                "const two = (n) => String(n).padStart(2, '0');",
+                "console.log(two(Math.floor(at / 60)) + ':' + two(at % 60));",
+              ].join("\n"),
+            },
+          },
+          "Aim for nine forty-five tonight — that's six full cycles before seven.",
+        ],
+      },
+    );
+  },
+  // `runCode` is what makes the case above about an ANSWER rather than a call.
+  { runCode },
+);

package/dist/templates/night-owl/agent.test.ts

@@ -1,10 +1,16 @@
 /// <reference types="vite/client" />
 
 import { toAgentConfig } from "@alexkroman1/aai/manifest";
-import { createToolContext, runTool, withDiscoveredTools } from "@alexkroman1/aai/testing";
+import {
+  createToolContext,
+  parseToolInput,
+  toolInputIssues,
+  toolRunner,
+  withDiscoveredTools,
+} from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
 import authoredAgent from "./agent.ts";
-import { CATEGORIES, MOODS } from "./shared.ts";
+import { CATEGORIES, MOODS, nightProjection, nightSlot } from "./shared.ts";
 
 /**
  * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
@@ -17,6 +23,14 @@ const agentDef = withDiscoveredTools(
   import.meta.glob("./tools/*.ts", { eager: true }),
 );
 
+/**
+ * `runTool` takes the context in the ARGUMENTS' place when a tool needs none,
+ * so `toolRunner`'s second parameter takes either — which is why it is one
+ * signature rather than an overload pair. An omitted context is a fresh one,
+ * i.e. a distinct session with an empty slot.
+ */
+const run = toolRunner(agentDef);
+
 describe("night-owl template", () => {
   test("config passes manifest validation", () => {
     // Same conversion `aai build`/`aai deploy` run.
@@ -33,22 +47,53 @@ describe("night-owl template", () => {
   test("recommend is discovered from tools/", () => {
     expect(Object.keys(agentDef.tools ?? {})).toEqual(["recommend"]);
   });
+
+  test("the projection an untouched session pushes is an empty log", () => {
+    // What `useAgentState(nightProjection)` reads before the first tool call —
+    // derived from the slot's own default rather than guessed at in the page.
+    expect(nightProjection()).toEqual({ recs: [] });
+  });
 });
 
 describe("recommend", () => {
   test("answers with picks for the category and mood asked for", async () => {
-    const ctx = createToolContext();
-    const result = await runTool(agentDef, "recommend", { category: "movie", mood: "cozy" }, ctx);
+    const result = await run("recommend", { category: "movie", mood: "cozy" });
     expect(result).toMatchObject({ category: "movie", mood: "cozy" });
     expect((result as { picks: string[] }).picks.length).toBeGreaterThan(0);
   });
 
-  test("pushes the same picks to the client, which is what the page renders", async () => {
-    // `ctx.send` is the only reason this tool takes a context at all: the
-    // client renders the picks rather than waiting to hear them read aloud.
+  test("the picks land in the session's own log, newest first", async () => {
+    // The log is STATE, not an event stream: `syncState` pushes this projection
+    // after every tool call, so a page that reloads mid-session resumes with it
+    // rather than starting empty.
+    const ctx = createToolContext();
+    const first = await run("recommend", { category: "book", mood: "spooky" }, ctx);
+    const second = await run("recommend", { category: "music", mood: "chill" }, ctx);
+    expect(nightProjection(nightSlot.get(ctx))).toEqual({ recs: [second, first] });
+  });
+
+  test("two calls with no shared context are two sessions", async () => {
+    // The other half of the same rule, and the one that bites: an omitted
+    // context is a FRESH session, so nothing accumulates across these calls.
     const ctx = createToolContext();
-    const result = await runTool(agentDef, "recommend", { category: "book", mood: "spooky" }, ctx);
-    expect(ctx.sent).toEqual([{ event: "recommendations", data: result }]);
+    await run("recommend", { category: "book", mood: "cozy" });
+    expect(nightSlot.get(ctx).recs).toHaveLength(0);
+  });
+
+  test("the wind-down nudge is sent once, on the third pick", async () => {
+    // A moment rather than state, which is why it is a `ctx.send` the page
+    // consumes with `useEvent` and not a field on the projection: re-delivering
+    // it on every reconnect would be nagging.
+    const ctx = createToolContext();
+    await run("recommend", { category: "movie", mood: "cozy" }, ctx);
+    await run("recommend", { category: "music", mood: "cozy" }, ctx);
+    expect(ctx.sent).toEqual([]);
+    await run("recommend", { category: "book", mood: "cozy" }, ctx);
+    expect(ctx.sent).toEqual([
+      { event: "wind_down", data: "Three picks in. Want me to work out your bedtime?" },
+    ]);
+    await run("recommend", { category: "movie", mood: "chill" }, ctx);
+    expect(ctx.sent).toHaveLength(1);
   });
 
   test("every category/mood pair the schema admits has picks behind it", async () => {
@@ -58,23 +103,29 @@ describe("recommend", () => {
     // package's guide records three shipped tools having.
     for (const category of CATEGORIES) {
       for (const mood of MOODS) {
-        const result = await runTool(
-          agentDef,
-          "recommend",
-          { category, mood },
-          createToolContext(),
-        );
+        const result = await run("recommend", { category, mood });
         expect((result as { picks: string[] }).picks, `${category}/${mood}`).not.toHaveLength(0);
       }
     }
   });
 
+  test("the schema accepts a category/mood pair from the enums", async () => {
+    const parsed = await parseToolInput<{ category: string; mood: string }>(agentDef, "recommend", {
+      category: "movie",
+      mood: "cozy",
+    });
+    expect(parsed).toEqual({ category: "movie", mood: "cozy" });
+  });
+
   test("a mood outside the enum is refused by the schema", async () => {
     // The wire boundary: an LLM tool call is untyped, so the schema is the only
     // thing between a hallucinated mood and an index into `undefined`.
-    const schema = agentDef.tools?.recommend?.inputSchema;
-    if (!schema) throw new Error("recommend has no input schema");
-    const bad = await schema["~standard"].validate({ category: "movie", mood: "melancholy" });
-    expect(bad.issues).toBeDefined();
+    // `toolInputIssues` is the SDK's own ask — `~standard` is a vendor wire
+    // contract, and the detail a hand-rolled version gets wrong first is that
+    // `.validate` may be sync or async, so a missing `await` leaves `.issues`
+    // undefined and the negative test passes for the wrong reason.
+    expect(
+      await toolInputIssues(agentDef, "recommend", { category: "movie", mood: "melancholy" }),
+    ).toBeDefined();
   });
 });

package/dist/templates/night-owl/agent.ts

@@ -1,7 +1,12 @@
 import { agent } from "@alexkroman1/aai";
+import { nightProjection } from "./shared.ts";
 
 export default agent({
   name: "Night Owl",
+  // The night's recommendation log, pushed to the client after every tool
+  // call. The page renders `useAgentState(nightProjection)` and keeps no copy
+  // of its own, so a reload resumes with the list intact.
+  syncState: nightProjection,
   greeting:
     "Hey there, night owl. Try asking me for a cozy movie recommendation, or tell me what time you need to wake up and I'll calculate the best time to fall asleep.",
   builtinTools: ["run_code"],