diff --git a/eslint.config.mjs b/eslint.config.mjs
index 0f90235..a9fc9aa 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -3,7 +3,7 @@ import tsparser from "@typescript-eslint/parser";
 
 export default tseslint.config(
   {
-    ignores: ["**/convex/_generated/"],
+    ignores: ["**/convex/_generated/", "scripts/**", "evals/**/grader.test.ts"],
   },
   tseslint.configs.recommendedTypeChecked,
   {
diff --git a/evals/000-fundamentals/000-empty_functions/grader.test.ts b/evals/000-fundamentals/000-empty_functions/grader.test.ts
index 0d39906..c5cf34f 100644
--- a/evals/000-fundamentals/000-empty_functions/grader.test.ts
+++ b/evals/000-fundamentals/000-empty_functions/grader.test.ts
@@ -1,169 +1,89 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseAdminClient, responseClient } from "../../../grader";
 import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
+test("empty public query", async () => {
+  expect(await responseClient.query(anyApi.index.emptyPublicQuery, {})).toBe(
+    null,
+  );
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
+  await expect(
+    responseClient.query(anyApi.index.emptyPublicQuery, { arg: "test" }),
+  ).rejects.toThrow(/ArgumentValidationError/);
 
-test("empty public query", async () => {
-  const result = await responseClient.query(anyApi.index.emptyPublicQuery, {});
-  expect(result).toBe(null);
+  await expect(
+    responseClient.mutation(anyApi.index.emptyPublicQuery, {}),
+  ).rejects.toBeDefined();
 
-  let error: any = undefined;
-  try {
-    await responseClient.query(anyApi.index.emptyPublicQuery, {
-      arg: "test",
-    });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
-
-  error = undefined;
-  try {
-    await responseClient.mutation(anyApi.index.emptyPublicQuery, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-
-  error = undefined;
-  try {
-    await responseClient.action(anyApi.index.emptyPublicQuery, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
+  await expect(
+    responseClient.action(anyApi.index.emptyPublicQuery, {}),
+  ).rejects.toBeDefined();
 });
 
 test("empty public mutation", async () => {
-  const result = await responseClient.mutation(
-    anyApi.index.emptyPublicMutation,
-    {},
-  );
-  expect(result).toBe(null);
+  expect(
+    await responseClient.mutation(anyApi.index.emptyPublicMutation, {}),
+  ).toBe(null);
 
-  let error: any = undefined;
-  try {
-    await responseClient.mutation(anyApi.index.emptyPublicMutation, {
+  await expect(
+    responseClient.mutation(anyApi.index.emptyPublicMutation, {
       arg: "test",
-    });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
-
-  error = undefined;
-  try {
-    await responseClient.query(anyApi.index.emptyPublicMutation, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-
-  error = undefined;
-  try {
-    await responseClient.action(anyApi.index.emptyPublicMutation, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
+    }),
+  ).rejects.toThrow(/ArgumentValidationError/);
+
+  await expect(
+    responseClient.query(anyApi.index.emptyPublicMutation, {}),
+  ).rejects.toBeDefined();
+
+  await expect(
+    responseClient.action(anyApi.index.emptyPublicMutation, {}),
+  ).rejects.toBeDefined();
 });
 
 test("empty public action", async () => {
-  const result = await responseClient.action(
-    anyApi.index.emptyPublicAction,
-    {},
+  expect(await responseClient.action(anyApi.index.emptyPublicAction, {})).toBe(
+    null,
   );
-  expect(result).toBe(null);
 
-  let error: any = undefined;
-  try {
-    await responseClient.action(anyApi.index.emptyPublicAction, {
-      arg: "test",
-    });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
-
-  error = undefined;
-  try {
-    await responseClient.query(anyApi.index.emptyPublicAction, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-
-  error = undefined;
-  try {
-    await responseClient.mutation(anyApi.index.emptyPublicAction, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
+  await expect(
+    responseClient.action(anyApi.index.emptyPublicAction, { arg: "test" }),
+  ).rejects.toThrow(/ArgumentValidationError/);
+
+  await expect(
+    responseClient.query(anyApi.index.emptyPublicAction, {}),
+  ).rejects.toBeDefined();
+
+  await expect(
+    responseClient.mutation(anyApi.index.emptyPublicAction, {}),
+  ).rejects.toBeDefined();
 });
 
 test("empty private query", async () => {
-  let error: any = undefined;
-  try {
-    await responseClient.query(anyApi.index.emptyPrivateQuery, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("Could not find public function");
-
-  const result = await responseAdminClient.query(
-    anyApi.index.emptyPrivateQuery,
-    {},
-  );
-  expect(result).toBe(null);
+  await expect(
+    responseClient.query(anyApi.index.emptyPrivateQuery, {}),
+  ).rejects.toThrow(/Could not find public function/);
+
+  expect(
+    await responseAdminClient.query(anyApi.index.emptyPrivateQuery, {}),
+  ).toBe(null);
 });
 
 test("empty private mutation", async () => {
-  let error: any = undefined;
-  try {
-    await responseClient.mutation(anyApi.index.emptyPrivateMutation, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("Could not find public function");
-
-  const result = await responseAdminClient.mutation(
-    anyApi.index.emptyPrivateMutation,
-    {},
-  );
-  expect(result).toBe(null);
+  await expect(
+    responseClient.mutation(anyApi.index.emptyPrivateMutation, {}),
+  ).rejects.toThrow(/Could not find public function/);
+
+  expect(
+    await responseAdminClient.mutation(anyApi.index.emptyPrivateMutation, {}),
+  ).toBe(null);
 });
 
 test("empty private action", async () => {
-  let error: any = undefined;
-  try {
-    await responseClient.action(anyApi.index.emptyPrivateAction, {});
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("Could not find public function");
-
-  const result = await responseAdminClient.action(
-    anyApi.index.emptyPrivateAction,
-    {},
-  );
-  expect(result).toBe(null);
+  await expect(
+    responseClient.action(anyApi.index.emptyPrivateAction, {}),
+  ).rejects.toThrow(/Could not find public function/);
+
+  expect(
+    await responseAdminClient.action(anyApi.index.emptyPrivateAction, {}),
+  ).toBe(null);
 });
diff --git a/evals/000-fundamentals/001-basic_schema/grader.test.ts b/evals/000-fundamentals/001-basic_schema/grader.test.ts
index 4f79f92..881e08c 100644
--- a/evals/000-fundamentals/001-basic_schema/grader.test.ts
+++ b/evals/000-fundamentals/001-basic_schema/grader.test.ts
@@ -1,16 +1,93 @@
 import { expect, test } from "vitest";
 import {
   responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
+  getSchema,
+  addDocuments,
+  listTable,
+  deleteAllDocuments,
 } from "../../../grader";
-import { api } from "./answer/convex/_generated/api";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+type SimpleSchema = { tables: Array<{ tableName: string }> };
+
+test("has exactly two tables: users and messages", async () => {
+  const schemaUnknown: unknown = await getSchema(responseAdminClient);
+  expect(schemaUnknown).not.toBeNull();
+  const { tables } = schemaUnknown as SimpleSchema;
+  const tableNames = tables.map((t) => t.tableName);
+  expect(tableNames).toEqual(["messages", "users"]);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("users table enforces single string field: name", async () => {
+  await deleteAllDocuments(responseAdminClient, ["users", "messages"]);
+
+  // valid insert
+  await addDocuments(responseAdminClient, "users", [{ name: "Alice" }]);
+  const users = await listTable(responseAdminClient, "users");
+  expect(users.length).toBe(1);
+
+  // extra field should fail
+  await expect(
+    addDocuments(responseAdminClient, "users", [
+      { name: "Bob", extra: "nope" },
+    ]),
+  ).rejects.toBeDefined();
+
+  // wrong type should fail
+  await expect(
+    addDocuments(responseAdminClient, "users", [
+      { name: 123 as unknown as string },
+    ]),
+  ).rejects.toBeDefined();
+
+  // missing required field should fail
+  await expect(
+    addDocuments(responseAdminClient, "users", [
+      {} as unknown as { name: string },
+    ]),
+  ).rejects.toBeDefined();
+});
+
+test("messages table enforces two string fields: text and authorName", async () => {
+  await deleteAllDocuments(responseAdminClient, ["users", "messages"]);
+
+  // valid insert
+  await addDocuments(responseAdminClient, "messages", [
+    { text: "Hello", authorName: "Alice" },
+  ]);
+  const messages = await listTable(responseAdminClient, "messages");
+  expect(messages.length).toBe(1);
+
+  // extra field should fail
+  await expect(
+    addDocuments(responseAdminClient, "messages", [
+      { text: "Hi", authorName: "Bob", extra: "nope" },
+    ]),
+  ).rejects.toBeDefined();
+
+  // wrong types should fail
+  await expect(
+    addDocuments(responseAdminClient, "messages", [
+      { text: 42 as unknown as string, authorName: "Alice" },
+    ]),
+  ).rejects.toBeDefined();
+  await expect(
+    addDocuments(responseAdminClient, "messages", [
+      { text: "Hello", authorName: 99 as unknown as string },
+    ]),
+  ).rejects.toBeDefined();
+
+  // missing required fields should fail
+  await expect(
+    addDocuments(responseAdminClient, "messages", [
+      { text: "Hello" } as unknown as { text: string; authorName: string },
+    ]),
+  ).rejects.toBeDefined();
+  await expect(
+    addDocuments(responseAdminClient, "messages", [
+      { authorName: "Alice" } as unknown as {
+        text: string;
+        authorName: string;
+      },
+    ]),
+  ).rejects.toBeDefined();
 });
diff --git a/evals/000-fundamentals/002-basic_http_endpoint/TASK.txt b/evals/000-fundamentals/002-basic_http_endpoint/TASK.txt
index 6f099e7..4669ee6 100644
--- a/evals/000-fundamentals/002-basic_http_endpoint/TASK.txt
+++ b/evals/000-fundamentals/002-basic_http_endpoint/TASK.txt
@@ -1,3 +1,13 @@
-Create a backend with only two HTTP routes. Serve the text "there" concatenated
-onto the request body for GETs at `/api/hello`. Serve an empty response for POSTs 
-at `/api/messages/*`.
\ No newline at end of file
+Create a backend with only two HTTP routes.
+
+1) GET `/api/hello`
+   - Read the request body as text (treat missing/empty body as empty string)
+   - Respond with the body text concatenated with the literal string "there"
+   - Examples:
+     - body: "" -> response: "there"
+     - body: "hello" -> response: "hellothere"
+   - Set `Content-Type: text/plain`
+
+2) POST `/api/messages/*`
+   - Return HTTP 200 with an empty response body
+   - This route should match any path under `/api/messages/` (e.g. `/api/messages/123`). In Convex, use a wildcard route (e.g. `pathPrefix: "/api/messages/"`).
\ No newline at end of file
diff --git a/evals/000-fundamentals/002-basic_http_endpoint/grader.test.ts b/evals/000-fundamentals/002-basic_http_endpoint/grader.test.ts
index 79fc647..778cf24 100644
--- a/evals/000-fundamentals/002-basic_http_endpoint/grader.test.ts
+++ b/evals/000-fundamentals/002-basic_http_endpoint/grader.test.ts
@@ -1,12 +1,21 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
-import { api } from "./answer/convex/_generated/api";
+import { siteUrl } from "../../../grader";
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("GET /api/hello returns body + 'there' (empty body => 'there')", async () => {
+  const res = await fetch(`${siteUrl}/api/hello`, { method: "GET" });
+  expect(res.ok).toBe(true);
+  const text = await res.text();
+  expect(text).toBe("there");
+  const contentType = res.headers.get("content-type");
+  expect(contentType && contentType.includes("text/plain")).toBe(true);
+});
+
+test("POST /api/messages/* returns empty response body", async () => {
+  const res = await fetch(`${siteUrl}/api/messages/123`, {
+    method: "POST",
+    body: "ignored",
+  });
+  expect(res.ok).toBe(true);
+  const text = await res.text();
+  expect(text).toBe("");
 });
diff --git a/evals/000-fundamentals/003-crons/grader.test.ts b/evals/000-fundamentals/003-crons/grader.test.ts
index 4f79f92..3d06a72 100644
--- a/evals/000-fundamentals/003-crons/grader.test.ts
+++ b/evals/000-fundamentals/003-crons/grader.test.ts
@@ -1,16 +1,34 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
-import { api } from "./answer/convex/_generated/api";
+import { responseAdminClient } from "../../../grader";
+import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+test("internal emptyAction callable with and without scheduleDescription", async () => {
+  const resultNoArg: unknown = await responseAdminClient.action(
+    anyApi.crons.emptyAction,
+    {},
+  );
+  expect(resultNoArg).toBe(null);
+
+  const resultWithArg: unknown = await responseAdminClient.action(
+    anyApi.crons.emptyAction,
+    { scheduleDescription: "run every minute" },
+  );
+  expect(resultWithArg).toBe(null);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("defines four cron schedules with expected labels and timing", async () => {
+  type AdminQuery = {
+    query: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  };
+  const adminClient = responseAdminClient as unknown as AdminQuery;
+  const spec: unknown = await adminClient.query(
+    "_system/cli/modules:apiSpec",
+    {},
+  );
+  const specText = JSON.stringify(spec);
+  expect(specText).toContain("run every second");
+  expect(specText).toContain("run every minute");
+  expect(specText).toContain("run every hour");
+  expect(specText).toContain("run every month on the 11th day at 1pm UTC");
+  expect(specText).toContain("0 13 11 * *");
 });
diff --git a/evals/000-fundamentals/004-scheduler/TASK.txt b/evals/000-fundamentals/004-scheduler/TASK.txt
index e499e3a..b1325ad 100644
--- a/evals/000-fundamentals/004-scheduler/TASK.txt
+++ b/evals/000-fundamentals/004-scheduler/TASK.txt
@@ -1,18 +1,20 @@
 Create a demo that demonstrates all of the ways to interact with the scheduler in Convex.
 
 Start by implementing two internal logging functions in `index.ts`:
-- An internal mutation `logMutation` that takes a message string and logs it
-- An internal action `logAction` that takes a message string and logs it
+- An internal mutation `logMutation` that takes a message string argument named "message" and logs it
+- An internal action `logAction` that takes a message string argument named "message" and logs it
 
 Then create two public caller functions in `index.ts` to demonstrate scheduler functionality:
 
 1. Create a mutation called `callerMutation` that demonstrates:
+   - Takes no arguments
    - Scheduling the logging mutation to run immediately (with runAfter and 0 delay)
    - Canceling a scheduled task using the returned scheduler ID
    - Scheduling the logging action to run 10 seconds in the future using runAt
    - Returning null.
 
 2. Create an action called `callerAction` that demonstrates:
+   - Takes no arguments
    - Scheduling the logging action to run after a random delay between 0-10 seconds
    - Scheduling the logging mutation to run immediately and then canceling it
    - Returning null.
diff --git a/evals/000-fundamentals/004-scheduler/grader.test.ts b/evals/000-fundamentals/004-scheduler/grader.test.ts
index 4f79f92..1534b38 100644
--- a/evals/000-fundamentals/004-scheduler/grader.test.ts
+++ b/evals/000-fundamentals/004-scheduler/grader.test.ts
@@ -1,16 +1,59 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
-import { api } from "./answer/convex/_generated/api";
-
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+import { responseClient, responseAdminClient } from "../../../grader";
+import { anyApi } from "convex/server";
+
+test("callerMutation schedules tasks and returns null", async () => {
+  expect(await responseClient.mutation(anyApi.index.callerMutation, {})).toBe(
+    null,
+  );
+  await expect(
+    responseClient.mutation(anyApi.index.callerMutation, { extra: true }),
+  ).rejects.toThrow(/ArgumentValidationError/);
+});
+
+test("callerAction schedules tasks and returns null", async () => {
+  expect(await responseClient.action(anyApi.index.callerAction, {})).toBe(null);
+  await expect(
+    responseClient.action(anyApi.index.callerAction, { extra: true }),
+  ).rejects.toThrow(/ArgumentValidationError/);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("internal logMutation returns null and is private", async () => {
+  expect(
+    await responseAdminClient.mutation(anyApi.index.logMutation, {
+      message: "Hello, world!",
+    }),
+  ).toBe(null);
+
+  await expect(
+    responseClient.mutation(anyApi.index.logMutation, {
+      message: "Hello, world!",
+    }),
+  ).rejects.toThrow(/Could not find public function/);
+
+  await expect(
+    responseAdminClient.mutation(anyApi.index.logMutation, {
+      message: 123 as unknown as string,
+    }),
+  ).rejects.toThrow(/ArgumentValidationError/);
+});
+
+test("internal logAction returns null and is private", async () => {
+  expect(
+    await responseAdminClient.action(anyApi.index.logAction, {
+      message: "Hello, world!",
+    }),
+  ).toBe(null);
+
+  await expect(
+    responseClient.action(anyApi.index.logAction, {
+      message: "Hello, world!",
+    }),
+  ).rejects.toThrow(/Could not find public function/);
+
+  await expect(
+    responseAdminClient.action(anyApi.index.logAction, {
+      message: 123 as unknown as string,
+    }),
+  ).rejects.toThrow(/ArgumentValidationError/);
 });
diff --git a/evals/000-fundamentals/005-function_calling/TASK.txt b/evals/000-fundamentals/005-function_calling/TASK.txt
index 724dfa9..3e6e788 100644
--- a/evals/000-fundamentals/005-function_calling/TASK.txt
+++ b/evals/000-fundamentals/005-function_calling/TASK.txt
@@ -1,18 +1,20 @@
 Create a demo that demonstrates all the ways to call functions from other functions in Convex.
 
 Start by implementing three internal callee functions in `convex/index.ts`:
-- An internal query `calleeQuery` that takes x and y numbers and returns their sum
-- An internal mutation `calleeMutation` that takes x and y numbers and returns their difference
-- An internal action `calleeAction` that takes x and y numbers and returns their product
+- An internal query `calleeQuery` that takes numbers named "x" and "y" and returns their sum
+- An internal mutation `calleeMutation` that takes numbers named "x" and "y" and returns their difference
+- An internal action `calleeAction` that takes numbers named "x" and "y" and returns their product
 
 Then create two caller functions in `convex/index.ts`:
 
 1. Create a mutation called `callerMutation` that demonstrates:
+   - Takes no arguments
    - Calling the internal query with x=1 and y=2
-   - Using the result to call the internal mutation with y=2
+   - Using the result to call the internal mutation with y=2 (keep the parameter names "x" and "y")
    - Return the final result
 
 2. Create an action called `callerAction` that demonstrates:
+   - Takes no arguments
    - Calling the internal query with x=1 and y=2
    - Using the result to call the internal mutation with y=2
    - Using that result to call the internal action with y=2
diff --git a/evals/000-fundamentals/005-function_calling/grader.test.ts b/evals/000-fundamentals/005-function_calling/grader.test.ts
index e8b70b1..e63435e 100644
--- a/evals/000-fundamentals/005-function_calling/grader.test.ts
+++ b/evals/000-fundamentals/005-function_calling/grader.test.ts
@@ -1,20 +1,7 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseAdminClient, responseClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("callerMutation chains calls correctly", async () => {
   const result = await responseAdminClient.mutation(
     api.index.callerMutation,
@@ -25,71 +12,62 @@ test("callerMutation chains calls correctly", async () => {
   expect(result).toBe(1);
 
   // Test with invalid arguments
-  let error: any = undefined;
-  try {
-    await responseAdminClient.mutation(api.index.callerMutation, { x: 1 });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
+  await expect(
+    responseAdminClient.mutation(api.index.callerMutation, { x: 1 } as any),
+  ).rejects.toThrow(/ArgumentValidationError/);
 });
 
 test("callerAction chains calls correctly", async () => {
-  const result = await responseAdminClient.action(
-    api.index.callerAction,
-    {},
-  );
+  const result = await responseAdminClient.action(api.index.callerAction, {});
   // calleeQuery(1,2) = 3
   // calleeMutation(3,2) = 1
   // calleeAction(1,2) = 2
   expect(result).toBe(2);
 
   // Test with invalid arguments
-  let error: any = undefined;
-  try {
-    await responseAdminClient.action(api.index.callerAction, { x: 1 });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
+  await expect(
+    responseAdminClient.action(api.index.callerAction, { x: 1 } as any),
+  ).rejects.toThrow(/ArgumentValidationError/);
 });
 
 test("internal functions work correctly", async () => {
   // Test calleeQuery
   const queryResult = await responseAdminClient.query(
+    // @ts-ignore
     api.index.calleeQuery,
-    { x: 5, y: 3 },
+    {
+      x: 5,
+      y: 3,
+    },
   );
   expect(queryResult).toBe(8);
 
   // Test calleeMutation
+
   const mutationResult = await responseAdminClient.mutation(
+    // @ts-ignore
     api.index.calleeMutation,
     { x: 5, y: 3 },
   );
   expect(mutationResult).toBe(2);
 
   // Test calleeAction
+  // @ts-ignore
   const actionResult = await responseAdminClient.action(
+    // @ts-ignore
     api.index.calleeAction,
     { x: 5, y: 3 },
   );
   expect(actionResult).toBe(15);
 
   // Test argument validation
-  let error: any = undefined;
-  try {
-    await responseAdminClient.query(api.index.calleeQuery, {
+  await expect(
+    // @ts-ignore
+    responseAdminClient.query(api.index.calleeQuery, {
       x: "not a number",
       y: 3,
-    });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
+    })
+  ).rejects.toThrow(/ArgumentValidationError/);
 });
 
 test("functions are not accessible from wrong client type", async () => {
@@ -97,6 +75,7 @@ test("functions are not accessible from wrong client type", async () => {
 
   // Query should not be callable as mutation
   try {
+    // @ts-ignore
     await responseAdminClient.mutation(api.index.calleeQuery, {
       x: 1,
       y: 2,
@@ -109,6 +88,7 @@ test("functions are not accessible from wrong client type", async () => {
   // Mutation should not be callable as action
   error = undefined;
   try {
+    // @ts-ignore
     await responseAdminClient.action(api.index.calleeMutation, {
       x: 1,
       y: 2,
@@ -121,6 +101,7 @@ test("functions are not accessible from wrong client type", async () => {
   // Action should not be callable as query
   error = undefined;
   try {
+    // @ts-ignore
     await responseAdminClient.query(api.index.calleeAction, { x: 1, y: 2 });
   } catch (e) {
     error = e;
diff --git a/evals/000-fundamentals/006-database_crud/TASK.txt b/evals/000-fundamentals/006-database_crud/TASK.txt
index 6f72ec2..a61f528 100644
--- a/evals/000-fundamentals/006-database_crud/TASK.txt
+++ b/evals/000-fundamentals/006-database_crud/TASK.txt
@@ -17,27 +17,27 @@ export default defineSchema({
 Implement the following functions in `convex/public.ts`:
 
 1. Create a mutation `createLocation` that:
-   - Takes name (string), latitude (number), and longitude (number) as arguments
+   - Takes arguments named `name` (string), `latitude` (number), and `longitude` (number)
    - Inserts a new location into the "locations" table
    - Returns the new location's ID
 
 2. Create a query `readLocation` that:
-   - Takes a location ID as an argument
+   - Takes a location ID argument named `id`
    - Returns either null or the object containing the location's name, latitude, longitude, and its system fields
    - Use proper union typing for the return value
 
 3. Create a mutation `updateLocation` that:
-   - Takes an ID and full location data (name, latitude, longitude)
+   - Takes arguments named `id`, `name`, `latitude`, and `longitude`
    - Replaces the existing location with new data
    - Throws an error if the location doesn't exist
    - Returns null
 
 4. Create a mutation `patchLocation` that:
-   - Takes an ID and a new name
+   - Takes arguments named `id` and `name`
    - Updates only the name field
    - Returns null
 
 5. Create a mutation `deleteLocation` that:
-   - Takes a location ID
+   - Takes a location ID argument named `id`
    - Deletes the location from the database, throwing an error if it doesn't exist
    - Returns null
\ No newline at end of file
diff --git a/evals/000-fundamentals/006-database_crud/grader.test.ts b/evals/000-fundamentals/006-database_crud/grader.test.ts
index fbc6a69..4d8b5a1 100644
--- a/evals/000-fundamentals/006-database_crud/grader.test.ts
+++ b/evals/000-fundamentals/006-database_crud/grader.test.ts
@@ -1,20 +1,7 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseClient } from "../../../grader";
 import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("create and read location", async () => {
   // Test successful creation
   const locationId = await responseClient.mutation(
@@ -40,18 +27,13 @@ test("create and read location", async () => {
   });
 
   // Test invalid arguments
-  let error: any = undefined;
-  try {
-    await responseClient.mutation(anyApi.public.createLocation, {
+  await expect(
+    responseClient.mutation(anyApi.public.createLocation, {
       name: "Invalid",
-      latitude: "not a number",
+      latitude: "not a number" as unknown as number,
       longitude: -122.4194,
-    });
-  } catch (e) {
-    error = e;
-  }
-  expect(error).toBeDefined();
-  expect(error.toString()).toContain("ArgumentValidationError");
+    }),
+  ).rejects.toThrow(/ArgumentValidationError/);
 });
 
 test("update location", async () => {
diff --git a/evals/000-fundamentals/007-basic_file_storage/TASK.txt b/evals/000-fundamentals/007-basic_file_storage/TASK.txt
index f2f8d2d..d2df7a3 100644
--- a/evals/000-fundamentals/007-basic_file_storage/TASK.txt
+++ b/evals/000-fundamentals/007-basic_file_storage/TASK.txt
@@ -17,24 +17,24 @@ export default defineSchema({
    - Returns a string URL for file upload
 
 2. Create a mutation `finishUpload`:
-   - Takes a storage ID as an argument
+   - Takes a storage ID argument named `storageId`
    - Inserts a new record in the "files" table with the storage ID
    - Returns null
 
 3. Create a query `getFileUrl`:
-   - Takes a file ID as an argument
+   - Takes a file ID argument named `fileId`
    - Retrieves the file record from the database, throwing an error if not found
    - Gets the download URL for the storage ID associated with the file.
    - Throws an error if the storage entry is not found
    - Returns the URL as a string
 
 4. Create a query `getFileMetadata`:
-   - Takes a file ID as an argument
+   - Takes a file ID argument named `fileId`
    - Retrieves the file record and returns all of its system metadata
    - Throws an error if the file is not found
 
 5. Create a mutation `deleteFile`:
-   - Takes a file ID as an argument
+   - Takes a file ID argument named `fileId`
    - Deletes both the storage object and database record
    - Throws an error if the file is not found
 
diff --git a/evals/000-fundamentals/007-basic_file_storage/grader.test.ts b/evals/000-fundamentals/007-basic_file_storage/grader.test.ts
index 7960d18..a5ab8ca 100644
--- a/evals/000-fundamentals/007-basic_file_storage/grader.test.ts
+++ b/evals/000-fundamentals/007-basic_file_storage/grader.test.ts
@@ -1,17 +1,54 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
-import { api } from "./answer/convex/_generated/api";
+import { responseClient } from "../../../grader";
+import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+type Brand<T, B extends string> = T & { __brand: B };
+type FilesId = Brand<string, "files">;
+type StorageId = Brand<string, "_storage">;
+
+test("generate upload URL returns a string", async () => {
+  const url: unknown = await responseClient.mutation(
+    anyApi.index.generateUploadUrl,
+    {},
+  );
+  expect(typeof url).toBe("string");
+  if (typeof url === "string") expect(url.length).toBeGreaterThan(0);
+});
+
+test("finishUpload stores file record", async () => {
+  const url: unknown = await responseClient.mutation(
+    anyApi.index.generateUploadUrl,
+    {},
+  );
+  expect(url).toBeTypeOf("string");
+  // Simulate storage by creating a dummy storage id through upload flow is out of scope; rely on API shape
+  await expect(
+    responseClient.mutation(anyApi.index.finishUpload, {
+      storageId: "storage:fake" as unknown as StorageId,
+    }),
+  ).rejects.toBeDefined();
+});
+
+test("getFileUrl throws for missing file", async () => {
+  await expect(
+    responseClient.query(anyApi.index.getFileUrl, {
+      fileId: "files:missing" as unknown as FilesId,
+    }),
+  ).rejects.toBeDefined();
+});
+
+test("getFileMetadata throws for missing file", async () => {
+  await expect(
+    responseClient.query(anyApi.index.getFileMetadata, {
+      fileId: "files:missing" as unknown as FilesId,
+    }),
+  ).rejects.toBeDefined();
 });
 
-test("compare function spec", async ({ skip }) => {
-  // TODO: Claude Sonnet 3.5 *really* wants to output the files at `convex/files.ts`.
-  await compareFunctionSpec(skip);
+test("deleteFile throws for missing file", async () => {
+  await expect(
+    responseClient.mutation(anyApi.index.deleteFile, {
+      fileId: "files:missing" as unknown as FilesId,
+    }),
+  ).rejects.toBeDefined();
 });
diff --git a/evals/000-fundamentals/008-helper_fns/TASK.txt b/evals/000-fundamentals/008-helper_fns/TASK.txt
index faaf22c..0f72cc5 100644
--- a/evals/000-fundamentals/008-helper_fns/TASK.txt
+++ b/evals/000-fundamentals/008-helper_fns/TASK.txt
@@ -16,7 +16,7 @@ export default defineSchema({
 });
 ```
 
-2. Create a helper function `getItemData` in `convex/index.ts` that takes in an item ID, fetches it from the database, and returns a document like:
+2. Create a helper function `getItemData` in `convex/index.ts` that takes an item ID and fetches it from the database, returning a document like:
 
 ```ts
 {
@@ -30,12 +30,12 @@ Return null if item not found, otherwise returns the formatted data
 3. Create more functions in `convex/index.ts`:
 
 a. Create a query `getItem` that:
-   - Takes an item ID as an argument
+   - Takes an item ID argument with the name "itemId"
    - Uses the shared helper function to retrieve and transform the item from the database
    - Throws an error if item not found
 
 b. Create a mutation `updateItem` that:
-   - Takes an item ID and new quantity as arguments
+   - Takes an item ID argument with the name "itemId" and a new quantity argument with the name "quantity"
    - Updates the item's quantity and lastModified timestamp
    - Retrieves the item via the shared helper function
    - Throws an error if item not found
diff --git a/evals/000-fundamentals/008-helper_fns/answer/convex/index.ts b/evals/000-fundamentals/008-helper_fns/answer/convex/index.ts
index f278e1d..86e15ad 100644
--- a/evals/000-fundamentals/008-helper_fns/answer/convex/index.ts
+++ b/evals/000-fundamentals/008-helper_fns/answer/convex/index.ts
@@ -10,7 +10,10 @@ type FormattedItemData = {
 };
 
 // Shared helper function to get and format item data
-async function getItemData(ctx: QueryCtx, itemId: Id<"items">): Promise<FormattedItemData | null> {
+async function getItemData(
+  ctx: QueryCtx,
+  itemId: Id<"items">,
+): Promise<FormattedItemData | null> {
   const item = await ctx.db.get(itemId);
   if (!item) {
     return null;
@@ -25,17 +28,17 @@ async function getItemData(ctx: QueryCtx, itemId: Id<"items">): Promise<Formatte
 
 // Query to get an item by ID
 export const getItem = query({
-  args: { id: v.id("items") },
+  args: { itemId: v.id("items") },
   returns: v.object({
     name: v.string(),
     quantity: v.number(),
     lastModified: v.string(),
   }),
   handler: async (ctx, args) => {
-    const formattedItem = await getItemData(ctx, args.id);
+    const formattedItem = await getItemData(ctx, args.itemId);
 
     if (!formattedItem) {
-      throw new Error(`Item with ID ${args.id} not found`);
+      throw new Error(`Item with ID ${args.itemId} not found`);
     }
 
     return formattedItem;
@@ -45,7 +48,7 @@ export const getItem = query({
 // Mutation to update an item's quantity
 export const updateItem = mutation({
   args: {
-    id: v.id("items"),
+    itemId: v.id("items"),
     quantity: v.number(),
   },
   returns: v.object({
@@ -54,17 +57,17 @@ export const updateItem = mutation({
     lastModified: v.string(),
   }),
   handler: async (ctx, args) => {
-    await ctx.db.patch(args.id, {
+    await ctx.db.patch(args.itemId, {
       quantity: args.quantity,
       lastModified: Date.now(),
     });
 
-    const formattedItem = await getItemData(ctx, args.id);
+    const formattedItem = await getItemData(ctx, args.itemId);
 
     if (!formattedItem) {
-      throw new Error(`Item with ID ${args.id} not found`);
+      throw new Error(`Item with ID ${args.itemId} not found`);
     }
 
     return formattedItem;
   },
-});
\ No newline at end of file
+});
diff --git a/evals/000-fundamentals/008-helper_fns/grader.test.ts b/evals/000-fundamentals/008-helper_fns/grader.test.ts
index 0014461..0c4df6d 100644
--- a/evals/000-fundamentals/008-helper_fns/grader.test.ts
+++ b/evals/000-fundamentals/008-helper_fns/grader.test.ts
@@ -2,28 +2,18 @@ import { expect, test } from "vitest";
 import {
   responseAdminClient,
   responseClient,
-  compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
 } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 import { Doc, Id } from "./answer/convex/_generated/dataModel";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getItem and updateItem handle non-existent items", async () => {
   // Try to get a non-existent item
   let error = null;
   try {
     await responseClient.query(api.index.getItem, {
-      id: "items:nonexistent" as Id<"items">,
+      itemId: "items:nonexistent" as Id<"items">,
     });
   } catch (e) {
     error = e;
@@ -34,7 +24,7 @@ test("getItem and updateItem handle non-existent items", async () => {
   error = null;
   try {
     await responseClient.mutation(api.index.updateItem, {
-      id: "items:nonexistent" as Id<"items">,
+      itemId: "items:nonexistent" as Id<"items">,
       quantity: 10,
     });
   } catch (e) {
@@ -57,7 +47,7 @@ test("getItem and updateItem work correctly with existing items", async () => {
 
   // Get the item
   const item = await responseClient.query(api.index.getItem, {
-    id: itemId,
+    itemId,
   });
 
   // Verify item format
@@ -68,13 +58,13 @@ test("getItem and updateItem work correctly with existing items", async () => {
 
   // Update the item
   await responseClient.mutation(api.index.updateItem, {
-    id: itemId,
+    itemId,
     quantity: 10,
   });
 
   // Get the updated item
   const updatedItem = await responseClient.query(api.index.getItem, {
-    id: itemId,
+    itemId,
   });
 
   // Verify the update
@@ -98,13 +88,13 @@ test("getItem and updateItem return the same format", async () => {
 
   // Update the item
   const updatedItem = await responseClient.mutation(api.index.updateItem, {
-    id: itemId,
+    itemId,
     quantity: 10,
   });
 
   // Get the updated item
   const item = await responseClient.query(api.index.getItem, {
-    id: itemId,
+    itemId,
   });
 
   // Verify the update
diff --git a/evals/000-fundamentals/009-returns_validator/TASK.txt b/evals/000-fundamentals/009-returns_validator/TASK.txt
index f9bb876..e91b976 100644
--- a/evals/000-fundamentals/009-returns_validator/TASK.txt
+++ b/evals/000-fundamentals/009-returns_validator/TASK.txt
@@ -23,20 +23,23 @@ export default defineSchema({
 2. Create three query functions in `convex/index.ts`:
 
 a. Create a query `getPost` that:
-   - Takes a post ID as an argument
+   - Takes a post ID argument named `postId`
    - Returns the raw document from the "posts" table
+   - If the post does not exist, throw an error with the message: "Post not found"
 
 b. Create a query `getPostWithStatus` that:
-   - Takes a post ID as an argument
+   - Takes a post ID argument named `postId`
    - Returns a discriminated union type:
      ```ts
      { success: true, post: Doc<"posts"> } |
      { success: false, error: string }
      ```
-   - Return an error if the title is ""
+   - Return `{ success: false, error: "Post not found" }` if the post does not exist
+   - Return `{ success: false, error: "Post title cannot be empty" }` if the title is an empty string
 
 c. Create a query `getPostWithAuthor` that:
-   - Takes a post ID as an argument
-   - Returns an array that contains Doc<"users"> and Doc<"posts">
+   - Takes a post ID argument named `postId`
+   - Returns an array that contains Doc<"users"> and Doc<"posts">, in this order: `[user, post]`
+   - Throw an error with the message: "Post not found" if the post does not exist
 
 Define a return validator for each of them.
\ No newline at end of file
diff --git a/evals/000-fundamentals/009-returns_validator/answer/convex/index.ts b/evals/000-fundamentals/009-returns_validator/answer/convex/index.ts
index 1837b46..f5443e5 100644
--- a/evals/000-fundamentals/009-returns_validator/answer/convex/index.ts
+++ b/evals/000-fundamentals/009-returns_validator/answer/convex/index.ts
@@ -5,7 +5,7 @@ import { v } from "convex/values";
  * Get a post by ID, returning the raw document.
  */
 export const getPost = query({
-  args: { id: v.id("posts") },
+  args: { postId: v.id("posts") },
   // Return type validator matches the document type exactly
   returns: v.object({
     _id: v.id("posts"),
@@ -15,7 +15,7 @@ export const getPost = query({
     authorId: v.id("users"),
   }),
   handler: async (ctx, args) => {
-    const post = await ctx.db.get(args.id);
+    const post = await ctx.db.get(args.postId);
     if (!post) {
       throw new Error("Post not found");
     }
@@ -27,7 +27,7 @@ export const getPost = query({
  * Get a post with a status indicator, demonstrating discriminated union returns.
  */
 export const getPostWithStatus = query({
-  args: { id: v.id("posts") },
+  args: { postId: v.id("posts") },
   // Union type validator for success/error states
   returns: v.union(
     v.object({
@@ -43,10 +43,10 @@ export const getPostWithStatus = query({
     v.object({
       success: v.literal(false),
       error: v.string(),
-    })
+    }),
   ),
   handler: async (ctx, args) => {
-    const post = await ctx.db.get(args.id);
+    const post = await ctx.db.get(args.postId);
 
     if (!post) {
       return {
@@ -73,7 +73,7 @@ export const getPostWithStatus = query({
  * Get a post with its author, demonstrating tuple returns.
  */
 export const getPostWithAuthor = query({
-  args: { id: v.id("posts") },
+  args: { postId: v.id("posts") },
   // Tuple type validator for post and author
   returns: v.array(
     v.union(
@@ -89,11 +89,11 @@ export const getPostWithAuthor = query({
         title: v.string(),
         content: v.string(),
         authorId: v.id("users"),
-      })
+      }),
     ),
   ),
   handler: async (ctx, args) => {
-    const post = await ctx.db.get(args.id);
+    const post = await ctx.db.get(args.postId);
     if (!post) {
       throw new Error("Post not found");
     }
@@ -105,4 +105,4 @@ export const getPostWithAuthor = query({
 
     return [author, post];
   },
-});
\ No newline at end of file
+});
diff --git a/evals/000-fundamentals/009-returns_validator/grader.test.ts b/evals/000-fundamentals/009-returns_validator/grader.test.ts
index 50192dd..e90f237 100644
--- a/evals/000-fundamentals/009-returns_validator/grader.test.ts
+++ b/evals/000-fundamentals/009-returns_validator/grader.test.ts
@@ -2,8 +2,6 @@ import { expect, test } from "vitest";
 import {
   responseAdminClient,
   responseClient,
-  compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
   deleteAllDocuments,
@@ -17,26 +15,29 @@ beforeEach(async () => {
   await deleteAllDocuments(responseAdminClient, ["users", "posts"]);
 });
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 async function createTestUser(): Promise<Id<"users">> {
-  await addDocuments(responseAdminClient, "users", [{
-    name: "Test User",
-    email: "test@example.com",
-  }]);
-  const users = await listTable(responseAdminClient, "users") as Doc<"users">[];
+  await addDocuments(responseAdminClient, "users", [
+    {
+      name: "Test User",
+      email: "test@example.com",
+    },
+  ]);
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   return users.at(-1)!._id;
 }
 
-async function createTestPosts(userId: Id<"users">, toAdd: WithoutSystemFields<Doc<"posts">>[]): Promise<Id<"posts">[]> {
+async function createTestPosts(
+  userId: Id<"users">,
+  toAdd: WithoutSystemFields<Doc<"posts">>[],
+): Promise<Id<"posts">[]> {
   await addDocuments(responseAdminClient, "posts", toAdd);
-  const posts = await listTable(responseAdminClient, "posts") as Doc<"posts">[];
+  const posts = (await listTable(
+    responseAdminClient,
+    "posts",
+  )) as Doc<"posts">[];
   return posts.slice(-toAdd.length).map((post) => post._id);
 }
 
@@ -45,14 +46,16 @@ test("getPost returns raw document with correct type", async () => {
   const userId = await createTestUser();
 
   // Create test post
-  const [postId] = await createTestPosts(userId, [{
-    title: "Test Post",
-    content: "Test Content",
-    authorId: userId,
-  }]);
+  const [postId] = await createTestPosts(userId, [
+    {
+      title: "Test Post",
+      content: "Test Content",
+      authorId: userId,
+    },
+  ]);
 
   const post = await responseClient.query(api.index.getPost, {
-    id: postId,
+    postId,
   });
 
   expect(post).toEqual({
@@ -68,7 +71,7 @@ test("getPost returns raw document with correct type", async () => {
   let error = null;
   try {
     await responseClient.query(api.index.getPost, {
-      id: "posts:nonexistent" as Id<"posts">,
+      postId: "posts:nonexistent" as Id<"posts">,
     });
   } catch (e) {
     error = e;
@@ -81,10 +84,11 @@ test("getPostWithStatus handles success and error cases", async () => {
   const userId = await createTestUser();
 
   // Create test posts
-  const postIds = await createTestPosts(userId, [{
-    title: "Valid Post",
-    content: "Test Content",
-    authorId: userId,
+  const postIds = await createTestPosts(userId, [
+    {
+      title: "Valid Post",
+      content: "Test Content",
+      authorId: userId,
     },
     {
       title: "",
@@ -94,9 +98,12 @@ test("getPostWithStatus handles success and error cases", async () => {
   ]);
 
   // Test successful case
-  const successResult = await responseClient.query(api.index.getPostWithStatus, {
-    id: postIds[0],
-  });
+  const successResult = await responseClient.query(
+    api.index.getPostWithStatus,
+    {
+      postId: postIds[0],
+    },
+  );
   expect(successResult).toEqual({
     success: true,
     post: {
@@ -112,7 +119,7 @@ test("getPostWithStatus handles success and error cases", async () => {
   // Test empty title case
   const emptyTitleResult = await responseClient.query(
     api.index.getPostWithStatus,
-    { id: postIds[1] },
+    { postId: postIds[1] },
   );
   expect(emptyTitleResult).toEqual({
     success: false,
@@ -124,7 +131,7 @@ test("getPostWithStatus handles success and error cases", async () => {
   // Test non-existent post
   const nonExistentResult = await responseClient.query(
     api.index.getPostWithStatus,
-    { id: postIds[0] },
+    { postId: postIds[0] },
   );
   expect(nonExistentResult).toEqual({
     success: false,
@@ -137,14 +144,16 @@ test("getPostWithAuthor returns correct tuple", async () => {
   const userId = await createTestUser();
 
   // Create test post
-  const [postId] = await createTestPosts(userId, [{
-    title: "Test Post",
-    content: "Test Content",
-    authorId: userId,
-  }]);
+  const [postId] = await createTestPosts(userId, [
+    {
+      title: "Test Post",
+      content: "Test Content",
+      authorId: userId,
+    },
+  ]);
 
   const result = await responseClient.query(api.index.getPostWithAuthor, {
-    id: postId,
+    postId,
   });
 
   expect(result).toHaveLength(2);
@@ -168,10 +177,10 @@ test("getPostWithAuthor returns correct tuple", async () => {
   let error = null;
   try {
     await responseClient.query(api.index.getPostWithAuthor, {
-      id: "posts:nonexistent" as Id<"posts">,
+      postId: "posts:nonexistent" as Id<"posts">,
     });
   } catch (e) {
     error = e;
   }
   expect(error).toBeDefined();
-});
\ No newline at end of file
+});
diff --git a/evals/001-data_modeling/000-simple_datatypes/grader.test.ts b/evals/001-data_modeling/000-simple_datatypes/grader.test.ts
index 88106fd..6e577d1 100644
--- a/evals/001-data_modeling/000-simple_datatypes/grader.test.ts
+++ b/evals/001-data_modeling/000-simple_datatypes/grader.test.ts
@@ -1,10 +1,34 @@
 import { expect, test } from "vitest";
-import { compareFunctionSpec, compareSchema } from "../../../grader";
+import { responseAdminClient, addDocuments, listTable } from "../../../grader";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+test("example table accepts correct simple datatypes", async () => {
+  const bytes = new Uint8Array([1, 2, 3]).buffer;
+  await addDocuments(responseAdminClient, "example", [
+    {
+      a: null,
+      b: 42,
+      c: 3.14,
+      d: BigInt(10),
+      e: BigInt(7),
+      f: true,
+      g: "hello",
+      h: bytes,
+      i: { any: "value" },
+    },
+  ]);
+  const rows = await listTable(responseAdminClient, "example");
+  expect(rows.length).toBeGreaterThan(0);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("example table rejects invalid types", async () => {
+  // Wrong types for a few fields should be rejected
+  await expect(
+    addDocuments(responseAdminClient, "example", [
+      {
+        // Intentionally invalid types
+        a: "not-null" as unknown as null,
+        b: "not-number" as unknown as number,
+      },
+    ]),
+  ).rejects.toBeDefined();
 });
diff --git a/evals/001-data_modeling/001-compound_datatypes/grader.test.ts b/evals/001-data_modeling/001-compound_datatypes/grader.test.ts
index a0663c1..f2e0a21 100644
--- a/evals/001-data_modeling/001-compound_datatypes/grader.test.ts
+++ b/evals/001-data_modeling/001-compound_datatypes/grader.test.ts
@@ -1,15 +1,39 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseAdminClient, addDocuments, listTable } from "../../../grader";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+test("example table accepts required compound datatypes", async () => {
+  const idPlaceholder = "example:placeholder";
+  await addDocuments(responseAdminClient, "example", [
+    {
+      a: { artist: 1, tags: ["rock", "pop"] },
+      b: [
+        { x: 1, y: 2 },
+        { x: 3, y: 4 },
+      ],
+      c: {},
+      d: { k: "v" },
+      e: { type: "a", value: 1 },
+      f: "x",
+    },
+  ]);
+  const rows = await listTable(responseAdminClient, "example");
+  expect(rows.length).toBeGreaterThan(0);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("example table rejects invalid union variants", async () => {
+  await expect(
+    addDocuments(responseAdminClient, "example", [
+      {
+        a: { artist: 1, tags: [] },
+        b: [],
+        c: {},
+        d: {},
+        e: { type: "c", value: 1 } as unknown as {
+          type: "a" | "b";
+          value: number | string;
+        },
+        f: [true],
+      },
+    ]),
+  ).rejects.toBeDefined();
 });
diff --git a/evals/001-data_modeling/002-foreign_key/grader.test.ts b/evals/001-data_modeling/002-foreign_key/grader.test.ts
index f3459b9..1d85c24 100644
--- a/evals/001-data_modeling/002-foreign_key/grader.test.ts
+++ b/evals/001-data_modeling/002-foreign_key/grader.test.ts
@@ -1,16 +1,16 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareFunctionSpec,
-  compareSchema,
-} from "../../../grader";
-import { anyApi } from "convex/server";
+import { responseAdminClient, addDocuments, listTable } from "../../../grader";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
+test("users and posts tables accept foreign key", async () => {
+  await addDocuments(responseAdminClient, "users", [
+    { name: "Alice", email_addresses: ["a@example.com"] },
+  ]);
+  const users = await listTable(responseAdminClient, "users");
+  const userId = (users.at(-1) as { _id: string })._id;
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+  await addDocuments(responseAdminClient, "posts", [
+    { title: "T", author: userId, content: "C" },
+  ]);
+  const posts = await listTable(responseAdminClient, "posts");
+  expect(posts.length).toBeGreaterThan(0);
 });
diff --git a/evals/001-data_modeling/003-single_column_index/grader.test.ts b/evals/001-data_modeling/003-single_column_index/grader.test.ts
index f3459b9..f2e84d5 100644
--- a/evals/001-data_modeling/003-single_column_index/grader.test.ts
+++ b/evals/001-data_modeling/003-single_column_index/grader.test.ts
@@ -1,16 +1,22 @@
 import { expect, test } from "vitest";
 import {
   responseAdminClient,
-  responseClient,
-  compareFunctionSpec,
-  compareSchema,
+  addDocuments,
+  listTable,
+  hasIndexWithPrefix,
 } from "../../../grader";
-import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+test("messages table exists and can insert with author_email", async () => {
+  await addDocuments(responseAdminClient, "messages", [
+    { content: "Hi", author_email: "a@example.com" },
+  ]);
+  const rows = await listTable(responseAdminClient, "messages");
+  expect(rows.length).toBeGreaterThan(0);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("schema has an index on author_email", async () => {
+  const ok = await hasIndexWithPrefix(responseAdminClient, "messages", [
+    "author_email",
+  ]);
+  expect(ok).toBe(true);
 });
diff --git a/evals/001-data_modeling/004-multi_column_index/grader.test.ts b/evals/001-data_modeling/004-multi_column_index/grader.test.ts
index f3459b9..00534b8 100644
--- a/evals/001-data_modeling/004-multi_column_index/grader.test.ts
+++ b/evals/001-data_modeling/004-multi_column_index/grader.test.ts
@@ -1,16 +1,24 @@
 import { expect, test } from "vitest";
 import {
   responseAdminClient,
-  responseClient,
-  compareFunctionSpec,
-  compareSchema,
+  addDocuments,
+  listTable,
+  hasIndexOn,
+  hasIndexWithPrefix,
 } from "../../../grader";
-import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+test("messages table with author_email and sent_at inserts", async () => {
+  await addDocuments(responseAdminClient, "messages", [
+    { content: "Hi", author_email: "a@example.com", sent_at: Date.now() },
+  ]);
+  const rows = await listTable(responseAdminClient, "messages");
+  expect(rows.length).toBeGreaterThan(0);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("schema has a composite index on (author_email, sent_at)", async () => {
+  const ok = await hasIndexWithPrefix(responseAdminClient, "messages", [
+    "author_email",
+    "sent_at",
+  ]);
+  expect(ok).toBe(true);
 });
diff --git a/evals/001-data_modeling/005-many_to_many/grader.test.ts b/evals/001-data_modeling/005-many_to_many/grader.test.ts
index 32aa6d9..de05399 100644
--- a/evals/001-data_modeling/005-many_to_many/grader.test.ts
+++ b/evals/001-data_modeling/005-many_to_many/grader.test.ts
@@ -1,12 +1,44 @@
 import { expect, test } from "vitest";
 import {
   responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
+  addDocuments,
+  listTable,
+  hasIndexWithPrefix,
 } from "../../../grader";
-import { anyApi } from "convex/server";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
+// Basic sanity: can insert students and courses, and an enrollment row that references both with metadata
+
+test("students, courses, and enrollments accept required fields", async () => {
+  await addDocuments(responseAdminClient, "students", [
+    { name: "Alice", email: "a@example.com" },
+  ]);
+  const students = await listTable(responseAdminClient, "students");
+  const studentId = (students.at(-1) as { _id: string })._id;
+
+  await addDocuments(responseAdminClient, "courses", [
+    { name: "CS101", code: "CS101", description: "Intro" },
+  ]);
+  const courses = await listTable(responseAdminClient, "courses");
+  const courseId = (courses.at(-1) as { _id: string })._id;
+
+  await addDocuments(responseAdminClient, "enrollments", [
+    { studentId, courseId, enrollmentDate: Date.now(), grade: "A" },
+  ]);
+  const enrollments = await listTable(responseAdminClient, "enrollments");
+  expect(enrollments.length).toBeGreaterThan(0);
+});
+
+test("schema has indexes to support enrollments by student and by course", async () => {
+  const byStudent = await hasIndexWithPrefix(
+    responseAdminClient,
+    "enrollments",
+    ["studentId"],
+  );
+  const byCourse = await hasIndexWithPrefix(
+    responseAdminClient,
+    "enrollments",
+    ["courseId"],
+  );
+  expect(byStudent).toBe(true);
+  expect(byCourse).toBe(true);
 });
diff --git a/evals/001-data_modeling/006-literals/grader.test.ts b/evals/001-data_modeling/006-literals/grader.test.ts
index cd642c7..038cab6 100644
--- a/evals/001-data_modeling/006-literals/grader.test.ts
+++ b/evals/001-data_modeling/006-literals/grader.test.ts
@@ -1,11 +1,83 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
-} from "../../../grader";
-
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
\ No newline at end of file
+import { responseAdminClient, addDocuments } from "../../../grader";
+
+test("configurations accepts valid literal and union values", async () => {
+  await expect(
+    addDocuments(responseAdminClient, "configurations", [
+      {
+        environment: "production",
+        logLevel: "info",
+        priority: 2,
+        enabled: 1,
+        status: "active",
+        feature: { type: "basic", allowed: true },
+      },
+      {
+        environment: "production",
+        logLevel: "warn",
+        priority: 3,
+        enabled: 0,
+        status: null,
+        feature: { type: "advanced", allowed: false },
+      },
+    ]),
+  ).resolves.toBeUndefined();
+});
+
+test("configurations rejects invalid literal and union values", async () => {
+  // Invalid environment literal
+  await expect(
+    addDocuments(responseAdminClient, "configurations", [
+      {
+        environment: "staging",
+        logLevel: "info",
+        priority: 1,
+        enabled: 0,
+        status: "inactive",
+        feature: { type: "basic", allowed: true },
+      },
+    ]),
+  ).rejects.toThrow();
+
+  // Invalid logLevel
+  await expect(
+    addDocuments(responseAdminClient, "configurations", [
+      {
+        environment: "production",
+        logLevel: "verbose",
+        priority: 1,
+        enabled: 0,
+        status: 1,
+        feature: { type: "basic", allowed: true },
+      },
+    ]),
+  ).rejects.toThrow();
+
+  // Invalid priority and enabled
+  await expect(
+    addDocuments(responseAdminClient, "configurations", [
+      {
+        environment: "production",
+        logLevel: "debug",
+        priority: 4,
+        enabled: true,
+        status: 0,
+        feature: { type: "basic", allowed: true },
+      },
+    ]),
+  ).rejects.toThrow();
+
+  // Invalid feature type
+  await expect(
+    addDocuments(responseAdminClient, "configurations", [
+      {
+        environment: "production",
+        logLevel: "error",
+        priority: 1,
+        enabled: 0,
+        status: "inactive",
+        feature: { type: "pro", allowed: true },
+      },
+    ]),
+  ).rejects.toThrow();
+});
diff --git a/evals/001-data_modeling/007-schema_evolution/TASK.txt b/evals/001-data_modeling/007-schema_evolution/TASK.txt
index bcbcafe..264d13f 100644
--- a/evals/001-data_modeling/007-schema_evolution/TASK.txt
+++ b/evals/001-data_modeling/007-schema_evolution/TASK.txt
@@ -46,8 +46,6 @@ Additionally, create a helper function `migrateProductHelper(product: Doc<"produ
 Use this helper function in two API functions:
 
 1. A public mutation `migrateProduct` that takes a productId and patches the product to match the new schema and has no return value
-2. A public query `getProduct` that takes a productId and returns the product with the new schema that doesn't include deprecated fields.
-
-Both should use the helper function to migrate the product.
-
-All schema changes must maintain backwards compatibility, allowing existing code to continue working during the migration process.
+  - Takes arguments: `{ productId: Id<"products"> }`
+  - Returns null
+2. A public query `getProduct` that takes arguments: `{ productId: Id<"products"> }` and returns the product with the new schema that doesn't include deprecated fields.
\ No newline at end of file
diff --git a/evals/001-data_modeling/007-schema_evolution/grader.test.ts b/evals/001-data_modeling/007-schema_evolution/grader.test.ts
index a88455c..12a58e7 100644
--- a/evals/001-data_modeling/007-schema_evolution/grader.test.ts
+++ b/evals/001-data_modeling/007-schema_evolution/grader.test.ts
@@ -2,24 +2,13 @@ import { expect, test } from "vitest";
 import {
   responseAdminClient,
   responseClient,
-  compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
 } from "../../../grader";
 import { api, internal } from "./answer/convex/_generated/api";
 import { Doc } from "./answer/convex/_generated/dataModel";
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("migration helper transforms data correctly", async () => {
-
   // Insert a product with old schema format
   await addDocuments(responseAdminClient, "products", [
     {
@@ -36,7 +25,9 @@ test("migration helper transforms data correctly", async () => {
   await responseClient.mutation(api.index.migrateProduct, { productId });
 
   // Test that the product was migrated correctly
-  const product = await responseClient.query(api.index.getProduct, { productId });
+  const product = await responseClient.query(api.index.getProduct, {
+    productId,
+  });
   expect(product).toMatchObject({
     _id: productId,
     _creationTime: expect.any(Number),
@@ -44,4 +35,4 @@ test("migration helper transforms data correctly", async () => {
     description: "No description",
     active: "active",
   });
-});
\ No newline at end of file
+});
diff --git a/evals/001-data_modeling/008-nullable_partial/grader.test.ts b/evals/001-data_modeling/008-nullable_partial/grader.test.ts
index ac55e8c..575aa50 100644
--- a/evals/001-data_modeling/008-nullable_partial/grader.test.ts
+++ b/evals/001-data_modeling/008-nullable_partial/grader.test.ts
@@ -1,30 +1,28 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  compareSchema,
-  addDocuments,
-} from "../../../grader";
-
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
+import { responseAdminClient, addDocuments } from "../../../grader";
 
 test("schema enforces optional/nullable constraints", async () => {
   // Valid cases
-  await expect(addDocuments(responseAdminClient, "optionals", [
-    { nullable: null },
-    { nullable: "string" },
-    { nullable: "string", maybe_nullable: null },
-    { nullable: "string", maybe_nullable: "string" },
-    { nullable: "string", maybe: "string" },
-  ])).resolves.toBeUndefined();
+  await expect(
+    addDocuments(responseAdminClient, "optionals", [
+      { nullable: null },
+      { nullable: "string" },
+      { nullable: "string", maybe_nullable: null },
+      { nullable: "string", maybe_nullable: "string" },
+      { nullable: "string", maybe: "string" },
+    ]),
+  ).resolves.toBeUndefined();
 
   // Invalid cases
-  await expect(addDocuments(responseAdminClient, "optionals", [
-    {} // Missing required nullable field
-  ])).rejects.toThrow();
+  await expect(
+    addDocuments(responseAdminClient, "optionals", [
+      {}, // Missing required nullable field
+    ]),
+  ).rejects.toThrow();
 
-  await expect(addDocuments(responseAdminClient, "optionals", [
-    { nullable: "string", maybe: null } // maybe cannot be null
-  ])).rejects.toThrow();
-});
\ No newline at end of file
+  await expect(
+    addDocuments(responseAdminClient, "optionals", [
+      { nullable: "string", maybe: null }, // maybe cannot be null
+    ]),
+  ).rejects.toThrow();
+});
diff --git a/evals/001-data_modeling/009-normalize_json/TASK.txt b/evals/001-data_modeling/009-normalize_json/TASK.txt
index 5b1470f..18e9777 100644
--- a/evals/001-data_modeling/009-normalize_json/TASK.txt
+++ b/evals/001-data_modeling/009-normalize_json/TASK.txt
@@ -1,6 +1,6 @@
 Create a backend that defines a normalized database schema for representing organizational data.
-Only create "convex/schema.ts" and nothing else.
-Normalizes this JSON object into an "organization", "employees", "department" tables, with v.id relationships instead of inlined data:
+Only create "convex/schema.ts" (you may also include a minimal package.json so dependencies can install).
+Normalize this JSON into three tables named exactly: "organizations", "employees", and "departments", using v.id relationships instead of inlined data:
 ```json
 {
   "organizations": [
@@ -39,8 +39,8 @@ Normalizes this JSON object into an "organization", "employees", "department" ta
 For employees, the name and email are required, but phone and address are optional.
 For departments, the name is required, but manager is optional.
 
-The departments should be searchable by organization.
-The employees should be searchable by email, department, or organization
+The "departments" table should be searchable by organization (index on organizationId).
+The "employees" table should be searchable by email, department, and organization (indexes on email, departmentId, organizationId).
 Do not make multi-column or any other additional indexes for now.
 
 Indexes should be named like `by_<field_name>`, e.g. `by_department` for `departmentId` and multiple fields should be combined with an underscore, e.g. `by_department_organization`.
\ No newline at end of file
diff --git a/evals/001-data_modeling/009-normalize_json/grader.test.ts b/evals/001-data_modeling/009-normalize_json/grader.test.ts
index 79d7004..42a9e44 100644
--- a/evals/001-data_modeling/009-normalize_json/grader.test.ts
+++ b/evals/001-data_modeling/009-normalize_json/grader.test.ts
@@ -1,47 +1,64 @@
 import { expect, test } from "vitest";
 import {
   responseAdminClient,
-  responseClient,
-  compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
+  hasIndexOn,
+  hasIndexWithPrefix,
+  getSchema,
 } from "../../../grader";
-import { api } from "./answer/convex/_generated/api";
-import { Doc } from "./answer/convex/_generated/dataModel";
-
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
 
 test("organization data model works correctly", async () => {
+  const schema = (await getSchema(
+    responseAdminClient as unknown as object,
+  )) as { tables?: { tableName: string }[] } | null;
+  const tables: string[] = (schema?.tables ?? []).map((t) => t.tableName);
+  const deptTable = tables.includes("departments")
+    ? "departments"
+    : tables.includes("department")
+      ? "department"
+      : "departments";
+  const orgTable = tables.includes("organizations")
+    ? "organizations"
+    : tables.includes("organization")
+      ? "organization"
+      : "organizations";
+  const empTable = tables.includes("employees")
+    ? "employees"
+    : tables.includes("employee")
+      ? "employee"
+      : "employees";
+
   // Create organization
-  await addDocuments(responseAdminClient, "organizations", [
+  await addDocuments(responseAdminClient, orgTable, [
     {
       name: "Acme, Inc.",
     },
   ]);
-  const organizations = await listTable(responseAdminClient, "organizations");
-  const orgId = (organizations.at(-1) as Doc<"organizations">)._id;
+  const organizations = (await listTable(responseAdminClient, orgTable)) as {
+    _id: string;
+    name: string;
+  }[];
+  const orgId = (organizations.at(-1) as { _id: string })._id;
   expect(orgId).toBeDefined();
 
   // Create department
-  await addDocuments(responseAdminClient, "departments", [
+  await addDocuments(responseAdminClient, deptTable, [
     {
       name: "Marketing",
       organizationId: orgId,
     },
   ]);
-  const departments = await listTable(responseAdminClient, "departments");
-  const deptId = (departments.at(-1) as Doc<"departments">)._id;
+  const departments = (await listTable(responseAdminClient, deptTable)) as {
+    _id: string;
+    name: string;
+    organizationId: string;
+  }[];
+  const deptId = (departments.at(-1) as { _id: string })._id;
   expect(deptId).toBeDefined();
 
   // Create employees
-  await addDocuments(responseAdminClient, "employees", [
+  await addDocuments(responseAdminClient, empTable, [
     {
       name: "Jane",
       departmentId: deptId,
@@ -51,16 +68,66 @@ test("organization data model works correctly", async () => {
       age: 25,
     },
   ]);
-  const employees = await listTable(responseAdminClient, "employees");
-  const janeId = (employees.at(-1) as Doc<"employees">)._id;
+  const employees = (await listTable(responseAdminClient, empTable)) as {
+    _id: string;
+    name: string;
+    organizationId: string;
+    departmentId: string;
+    email: string;
+  }[];
+  const janeId = (employees.at(-1) as { _id: string })._id;
   expect(janeId).toBeDefined();
 
-  // Update department with manager
-  await addDocuments(responseAdminClient, "departments", [
-    {
-      name: "Engineering",
-      organizationId: orgId,
-      managerId: janeId,
-    },
+  // Update department with manager (handle either managerId or manager string)
+  try {
+    await addDocuments(responseAdminClient, deptTable, [
+      {
+        name: "Engineering",
+        organizationId: orgId,
+        managerId: janeId as unknown as string,
+      },
+    ]);
+  } catch (_e) {
+    await addDocuments(responseAdminClient, deptTable, [
+      {
+        name: "Engineering",
+        organizationId: orgId,
+        manager: "Jane",
+      },
+    ]);
+  }
+});
+
+test("schema has indexes for departments by organization and employees by email, department, organization", async () => {
+  const schema = (await getSchema(
+    responseAdminClient as unknown as object,
+  )) as { tables?: { tableName: string }[] } | null;
+  const tables: string[] = (schema?.tables ?? []).map((t) => t.tableName);
+  const deptTable = tables.includes("departments")
+    ? "departments"
+    : tables.includes("department")
+      ? "department"
+      : "departments";
+  const empTable = tables.includes("employees")
+    ? "employees"
+    : tables.includes("employee")
+      ? "employee"
+      : "employees";
+
+  const deptByOrg = await hasIndexWithPrefix(responseAdminClient, deptTable, [
+    "organizationId",
+  ]);
+  const empByEmail = await hasIndexWithPrefix(responseAdminClient, empTable, [
+    "email",
   ]);
-});
\ No newline at end of file
+  const empByDept = await hasIndexWithPrefix(responseAdminClient, empTable, [
+    "departmentId",
+  ]);
+  const empByOrg = await hasIndexWithPrefix(responseAdminClient, empTable, [
+    "organizationId",
+  ]);
+  expect(deptByOrg).toBe(true);
+  expect(empByEmail).toBe(true);
+  expect(empByDept).toBe(true);
+  expect(empByOrg).toBe(true);
+});
diff --git a/evals/001-data_modeling/010-discriminated_union/grader.test.ts b/evals/001-data_modeling/010-discriminated_union/grader.test.ts
index ecf066b..4cdc1cb 100644
--- a/evals/001-data_modeling/010-discriminated_union/grader.test.ts
+++ b/evals/001-data_modeling/010-discriminated_union/grader.test.ts
@@ -1,62 +1,64 @@
 import { expect, test } from "vitest";
-import {
-  responseAdminClient,
-  compareSchema,
-  addDocuments,
-} from "../../../grader";
-
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
+import { responseAdminClient, addDocuments } from "../../../grader";
 
 test("schema validates different notification types correctly", async () => {
   // Valid notifications
-  await expect(addDocuments(responseAdminClient, "notifications", [
-    {
-      kind: "message",
-      senderId: "user1",
-      messageText: "Hello!",
-    },
-    {
-      kind: "friendRequest",
-      requesterId: "user2",
-    },
-    {
-      kind: "achievement",
-      achievementName: "First Post",
-      points: 100,
-    },
-  ])).resolves.toBeUndefined();
+  await expect(
+    addDocuments(responseAdminClient, "notifications", [
+      {
+        kind: "message",
+        senderId: "user1",
+        messageText: "Hello!",
+      },
+      {
+        kind: "friendRequest",
+        requesterId: "user2",
+      },
+      {
+        kind: "achievement",
+        achievementName: "First Post",
+        points: 100,
+      },
+    ]),
+  ).resolves.toBeUndefined();
 
   // Invalid notifications
-  await expect(addDocuments(responseAdminClient, "notifications", [
-    {
-      kind: "message",
-      // Missing required fields
-    },
-  ])).rejects.toThrow();
+  await expect(
+    addDocuments(responseAdminClient, "notifications", [
+      {
+        kind: "message",
+        // Missing required fields
+      },
+    ]),
+  ).rejects.toThrow();
 
-  await expect(addDocuments(responseAdminClient, "notifications", [
-    {
-      kind: "friendRequest",
-      requesterId: "user2",
-      // Extra field should fail
-      extraField: "invalid",
-    },
-  ])).rejects.toThrow();
+  await expect(
+    addDocuments(responseAdminClient, "notifications", [
+      {
+        kind: "friendRequest",
+        requesterId: "user2",
+        // Extra field should fail
+        extraField: "invalid",
+      },
+    ]),
+  ).rejects.toThrow();
 
-  await expect(addDocuments(responseAdminClient, "notifications", [
-    {
-      kind: "achievement",
-      achievementName: "Invalid",
-      points: "100", // Wrong kind for points
-    },
-  ])).rejects.toThrow();
+  await expect(
+    addDocuments(responseAdminClient, "notifications", [
+      {
+        kind: "achievement",
+        achievementName: "Invalid",
+        points: "100", // Wrong kind for points
+      },
+    ]),
+  ).rejects.toThrow();
 
-  await expect(addDocuments(responseAdminClient, "notifications", [
-    {
-      kind: "invalidType", // Invalid notification kind
-      data: "something",
-    },
-  ])).rejects.toThrow();
-});
\ No newline at end of file
+  await expect(
+    addDocuments(responseAdminClient, "notifications", [
+      {
+        kind: "invalidType", // Invalid notification kind
+        data: "something",
+      },
+    ]),
+  ).rejects.toThrow();
+});
diff --git a/evals/001-data_modeling/012-denormalize_for_index/TASK.txt b/evals/001-data_modeling/012-denormalize_for_index/TASK.txt
index 38fb6a0..335f6ad 100644
--- a/evals/001-data_modeling/012-denormalize_for_index/TASK.txt
+++ b/evals/001-data_modeling/012-denormalize_for_index/TASK.txt
@@ -23,19 +23,19 @@ export default defineSchema({
 2. Create these functions in `convex/index.ts`:
 
 a. Create a mutation `createDog` that:
-   - Takes dogName (string), breed (string), and ownerId (Id<"owners">) as arguments
+   - Takes arguments: `{ dogName: string, breed: string, ownerId: Id<"owners"> }`
    - Creates a new dog record
    - Returns the new dog's ID
    - Throws if owner not found
 
 b. Create a mutation `updateOwnerAge` that:
-   - Takes ownerId and newAge as arguments
+   - Takes arguments: `{ ownerId: Id<"owners">, newAge: number }`
    - Updates the owner's age in the owners table and any associated dog records.
    - Returns null
    - Throws if owner not found
 
 c. Create a query `getDogsByOwnerAge` that:
-   - Takes `age` (number) as an argument
+   - Takes arguments: `{ age: number }`
    - Returns an array of dog records { name, breed } that have an owner with the given age
 
 The goal is to demonstrate how denormalization can be used to create efficient lookups on fields from related tables, while maintaining data consistency through update functions.
diff --git a/evals/001-data_modeling/012-denormalize_for_index/grader.test.ts b/evals/001-data_modeling/012-denormalize_for_index/grader.test.ts
index 855ebac..8b930a4 100644
--- a/evals/001-data_modeling/012-denormalize_for_index/grader.test.ts
+++ b/evals/001-data_modeling/012-denormalize_for_index/grader.test.ts
@@ -2,48 +2,49 @@ import { expect, test } from "vitest";
 import {
   responseAdminClient,
   responseClient,
-  compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
   deleteAllDocuments,
 } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
-import { Doc } from "./answer/convex/_generated/dataModel";
 import { beforeEach } from "node:test";
 
+type IdOwners = string & { __tableName: "owners" };
+type DogRow = {
+  _id: string;
+  name: string;
+  breed: string;
+  ownerId: IdOwners;
+  ownerAge: number;
+};
+
 beforeEach(async () => {
   await deleteAllDocuments(responseAdminClient, ["dogs", "owners"]);
 });
 
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("createDog creates dog with denormalized owner data", async () => {
   // Create an owner
-  await addDocuments(responseAdminClient, "owners", [{
-    name: "John",
-    age: 30,
-  }]);
-  const owners = await listTable(responseAdminClient, "owners");
-  const ownerId = (owners.at(-1) as Doc<"owners">)._id;
+  await addDocuments(responseAdminClient, "owners", [
+    {
+      name: "John",
+      age: 30,
+    },
+  ]);
+  const owners = (await listTable(responseAdminClient, "owners")) as {
+    _id: IdOwners;
+  }[];
+  const ownerId = owners.at(-1)!._id;
 
   // Create a dog using the mutation
-  const dogId = await responseClient.mutation(api.index.createDog, {
+  const dogId = (await responseClient.mutation(api.index.createDog, {
     dogName: "Rover",
     breed: "Labrador",
-    ownerId,
-  });
+    ownerId: ownerId as any,
+  })) as unknown as string;
 
   // Verify the dog was created with correct data
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const dogs: Doc<"dogs">[] = await listTable(responseAdminClient, "dogs");
-  const dog = dogs.find(d => d._id === dogId);
+  const dogs = (await listTable(responseAdminClient, "dogs")) as DogRow[];
+  const dog = dogs.find((d) => d._id === dogId);
   expect(dog).toMatchObject({
     _id: dogId,
     name: "Rover",
@@ -55,23 +56,28 @@ test("createDog creates dog with denormalized owner data", async () => {
 
 test("updateOwnerAge updates denormalized data", async () => {
   // Create owner and dogs
-  await addDocuments(responseAdminClient, "owners", [{
-    name: "Alice",
-    age: 25,
-  }]);
-  const owner = (await listTable(responseAdminClient, "owners")).at(-1) as Doc<"owners">;
+  await addDocuments(responseAdminClient, "owners", [
+    {
+      name: "Alice",
+      age: 25,
+    },
+  ]);
+  const owner = (await listTable(responseAdminClient, "owners")).at(-1) as {
+    _id: IdOwners;
+    age: number;
+  };
   expect(owner.age).toBe(25);
   const ownerId = owner._id;
 
   await responseClient.mutation(api.index.createDog, {
     dogName: "Spot",
     breed: "Dalmatian",
-    ownerId,
+    ownerId: ownerId as any,
   });
   await responseClient.mutation(api.index.createDog, {
     dogName: "Rex",
     breed: "German Shepherd",
-    ownerId,
+    ownerId: ownerId as any,
   });
 
   // Update owner's age
@@ -81,10 +87,10 @@ test("updateOwnerAge updates denormalized data", async () => {
   });
 
   // Verify all dogs were updated
-  const dogs = (await listTable(responseAdminClient, "dogs")) as Doc<"dogs">[];
-  const ownersDogs = dogs.filter(d => d.ownerId === ownerId);
+  const dogs = (await listTable(responseAdminClient, "dogs")) as DogRow[];
+  const ownersDogs = dogs.filter((d) => d.ownerId === ownerId);
   expect(ownersDogs).toHaveLength(2);
-  ownersDogs.forEach(dog => {
+  ownersDogs.forEach((dog) => {
     expect(dog.ownerAge).toBe(26);
   });
 });
@@ -92,15 +98,20 @@ test("updateOwnerAge updates denormalized data", async () => {
 test("getDogsByOwnerAge returns dogs with the given owner age", async () => {
   await deleteAllDocuments(responseAdminClient, ["dogs", "owners"]);
   // Create owners with different ages
-  await addDocuments(responseAdminClient, "owners", [{
-    name: "Young",
-    age: 20,
-  }, {
-    name: "Older",
-    age: 90,
-  }]);
-  const owners = (await listTable(responseAdminClient, "owners")) as Doc<"owners">[];
-  const [owner1Id, owner2Id] = owners.slice(-2).map(o => o._id);
+  await addDocuments(responseAdminClient, "owners", [
+    {
+      name: "Young",
+      age: 20,
+    },
+    {
+      name: "Older",
+      age: 90,
+    },
+  ]);
+  const owners = (await listTable(responseAdminClient, "owners")) as {
+    _id: IdOwners;
+  }[];
+  const [owner1Id, owner2Id] = owners.slice(-2).map((o) => o._id);
 
   // Create dogs for each owner
   await responseClient.mutation(api.index.createDog, {
@@ -122,15 +133,15 @@ test("getDogsByOwnerAge returns dogs with the given owner age", async () => {
   });
 
   // Test query
-  const dogs = await responseClient.query(api.index.getDogsByOwnerAge, {
+  const dogs = (await responseClient.query(api.index.getDogsByOwnerAge, {
     age: 20,
-  });
+  })) as { name: string }[];
   expect(dogs).toHaveLength(2);
-  expect(dogs.map(d => d.name)).toEqual(["Young Dog 1", "Young Dog 2"]);
+  expect(dogs.map((d) => d.name)).toEqual(["Young Dog 1", "Young Dog 2"]);
 
   // Test no dogs found
-  const dogs2 = await responseClient.query(api.index.getDogsByOwnerAge, {
+  const dogs2 = (await responseClient.query(api.index.getDogsByOwnerAge, {
     age: 45,
-  });
+  })) as { name: string }[];
   expect(dogs2).toHaveLength(0);
 });
diff --git a/evals/002-queries/000-all_rows/TASK.txt b/evals/002-queries/000-all_rows/TASK.txt
index bd60263..9821c3a 100644
--- a/evals/002-queries/000-all_rows/TASK.txt
+++ b/evals/002-queries/000-all_rows/TASK.txt
@@ -12,4 +12,6 @@ export default defineSchema({
 });
 ```
 
-Write a query named `getAllProducts` in `convex/public.ts` that returns all products in the table, including their system fields.
\ No newline at end of file
+Write a query named `getAllProducts` in `convex/public.ts` that:
+- Takes no arguments
+- Returns all products in the table, including their system fields.
\ No newline at end of file
diff --git a/evals/002-queries/000-all_rows/grader.test.ts b/evals/002-queries/000-all_rows/grader.test.ts
index 8fb57ff..aa01053 100644
--- a/evals/002-queries/000-all_rows/grader.test.ts
+++ b/evals/002-queries/000-all_rows/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get all products returns empty list when no products exist", async () => {
   const products = await responseClient.query(anyApi.public.getAllProducts, {});
   expect(products).toEqual([]);
diff --git a/evals/002-queries/001-single_column_index/TASK.txt b/evals/002-queries/001-single_column_index/TASK.txt
index 1dab21b..2c783bb 100644
--- a/evals/002-queries/001-single_column_index/TASK.txt
+++ b/evals/002-queries/001-single_column_index/TASK.txt
@@ -13,7 +13,7 @@ export default defineSchema({
 ```
 
 Write a query named `getUserByEmail` in `convex/public.ts` that:
-- Takes an email address as an argument
+- Takes arguments:  `{ email: string }`
 - Efficiently looks up the user by email
 - Returns null if no user is found with that email
 - Throws an error if there are multiple users with the same email
diff --git a/evals/002-queries/001-single_column_index/grader.test.ts b/evals/002-queries/001-single_column_index/grader.test.ts
index 22444c6..4e6cc91 100644
--- a/evals/002-queries/001-single_column_index/grader.test.ts
+++ b/evals/002-queries/001-single_column_index/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get user by email returns null for non-existent user", async () => {
   const user = await responseClient.query(anyApi.public.getUserByEmail, {
     email: "nonexistent@example.com",
diff --git a/evals/002-queries/002-userspace_filter/TASK.txt b/evals/002-queries/002-userspace_filter/TASK.txt
index 541ea06..0650574 100644
--- a/evals/002-queries/002-userspace_filter/TASK.txt
+++ b/evals/002-queries/002-userspace_filter/TASK.txt
@@ -14,7 +14,7 @@ export default defineSchema({
 ```
 
 Write a query named `getPopularPinnedMessages` in `convex/public.ts` that:
-- Takes an author name and a minimum likes threshold as arguments
+- Takes arguments:  `{ author: string, minLikes: number }`
 - Loads all of the messages by the author into memory.
 - Filters IN JAVASCRIPT (not in the database) to find messages that are:
   * Pinned (isPinned === true)
diff --git a/evals/002-queries/002-userspace_filter/grader.test.ts b/evals/002-queries/002-userspace_filter/grader.test.ts
index a22de5d..6aa3954 100644
--- a/evals/002-queries/002-userspace_filter/grader.test.ts
+++ b/evals/002-queries/002-userspace_filter/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get popular pinned messages returns empty array when no messages exist", async () => {
   const messages = await responseClient.query(
     anyApi.public.getPopularPinnedMessages,
diff --git a/evals/002-queries/003-multicolumn_equality/TASK.txt b/evals/002-queries/003-multicolumn_equality/TASK.txt
index 7971ce1..d0992ab 100644
--- a/evals/002-queries/003-multicolumn_equality/TASK.txt
+++ b/evals/002-queries/003-multicolumn_equality/TASK.txt
@@ -15,7 +15,7 @@ export default defineSchema({
 ```
 
 Write a query named `getProjectTasksByStatus` in `convex/public.ts` that:
-- Takes projectId and status as arguments
+- Takes arguments:  `{ projectId: string, status: string }`
 - Efficiently finds all tasks with the given projectId and status
 - Efficiently sorts the results in ascending priority order
 - Efficiently takes at most five results
\ No newline at end of file
diff --git a/evals/002-queries/003-multicolumn_equality/grader.test.ts b/evals/002-queries/003-multicolumn_equality/grader.test.ts
index cfd3963..e559956 100644
--- a/evals/002-queries/003-multicolumn_equality/grader.test.ts
+++ b/evals/002-queries/003-multicolumn_equality/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get project tasks by status returns empty array when no tasks exist", async () => {
   const tasks = await responseClient.query(
     anyApi.public.getProjectTasksByStatus,
diff --git a/evals/002-queries/004-range_condition/TASK.txt b/evals/002-queries/004-range_condition/TASK.txt
index 5959518..16e29e9 100644
--- a/evals/002-queries/004-range_condition/TASK.txt
+++ b/evals/002-queries/004-range_condition/TASK.txt
@@ -13,7 +13,7 @@ export default defineSchema({
 ```
 
 Write a query named `getSensorReadingsInRange` in `convex/public.ts` that:
-- Takes sensorId, startTime, and endTime as arguments
+- Takes arguments:  `{ sensorId: string, startTime: number, endTime: number }`
 - Efficiently gets all readings where:
   * sensorId matches (equality)
   * timestamp is >= startTime (range start)
diff --git a/evals/002-queries/004-range_condition/grader.test.ts b/evals/002-queries/004-range_condition/grader.test.ts
index 7fc855e..f091a1e 100644
--- a/evals/002-queries/004-range_condition/grader.test.ts
+++ b/evals/002-queries/004-range_condition/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get sensor readings in range returns empty array when no readings exist", async () => {
   const now = Math.floor(Date.now() / 1000);
   const readings = await responseClient.query(
diff --git a/evals/002-queries/005-creation_time/TASK.txt b/evals/002-queries/005-creation_time/TASK.txt
index 97783d1..b051b4b 100644
--- a/evals/002-queries/005-creation_time/TASK.txt
+++ b/evals/002-queries/005-creation_time/TASK.txt
@@ -13,5 +13,5 @@ export default defineSchema({
 ```
 
 Write a query named `getPostComments` in `convex/public.ts` that:
-- Takes a postId as an argument
+- Takes arguments:  `{ postId: string }`
 - Efficiently returns all comments for that post in descending creation time order
\ No newline at end of file
diff --git a/evals/002-queries/005-creation_time/grader.test.ts b/evals/002-queries/005-creation_time/grader.test.ts
index 9954e96..65b4dff 100644
--- a/evals/002-queries/005-creation_time/grader.test.ts
+++ b/evals/002-queries/005-creation_time/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get post comments returns empty array when no comments exist", async () => {
   const comments = await responseClient.query(anyApi.public.getPostComments, {
     postId: "post1",
diff --git a/evals/002-queries/006-three_level_join/TASK.txt b/evals/002-queries/006-three_level_join/TASK.txt
index a7e5414..20687a9 100644
--- a/evals/002-queries/006-three_level_join/TASK.txt
+++ b/evals/002-queries/006-three_level_join/TASK.txt
@@ -30,7 +30,7 @@ export default defineSchema({
 ```
 
 Write a query named `getProAdminsByOrg` in `convex/public.ts` that:
-- Takes an organizationId as an argument
+- Takes arguments:  `{ organizationId: Id<"organizations"> }`
 - Returns the unique set of all admins within that organization as a record
   mapping `Id<"users">` to their profileUrl.
 - This query should be efficient, assuming that there are many organizations,
diff --git a/evals/002-queries/006-three_level_join/grader.test.ts b/evals/002-queries/006-three_level_join/grader.test.ts
index 68415f1..03b8130 100644
--- a/evals/002-queries/006-three_level_join/grader.test.ts
+++ b/evals/002-queries/006-three_level_join/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
 } from "../../../grader";
@@ -13,10 +12,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get pro admins by org returns empty object when no admins exist", async () => {
   // Create an organization first
   await addDocuments(responseAdminClient, "organizations", [
@@ -72,12 +67,9 @@ test("get pro admins by org returns correct admin mapping", async () => {
   ]);
 
   // Test getting admins for org1
-  const org1Admins = await responseClient.query(
-    api.public.getProAdminsByOrg,
-    {
-      organizationId: org1Id._id,
-    },
-  );
+  const org1Admins = await responseClient.query(api.public.getProAdminsByOrg, {
+    organizationId: org1Id._id,
+  });
 
   // Should include Alice, Bob, and Charlie (unique admins across both teams)
   expect(Object.keys(org1Admins)).toHaveLength(3);
@@ -87,12 +79,9 @@ test("get pro admins by org returns correct admin mapping", async () => {
   expect(org1Admins[user4Id._id]).toBeUndefined();
 
   // Test getting admins for org2
-  const org2Admins = await responseClient.query(
-    api.public.getProAdminsByOrg,
-    {
-      organizationId: org2Id._id,
-    },
-  );
+  const org2Admins = await responseClient.query(api.public.getProAdminsByOrg, {
+    organizationId: org2Id._id,
+  });
 
   // Should only include David
   expect(Object.keys(org2Admins)).toHaveLength(1);
diff --git a/evals/002-queries/007-aggregation/TASK.txt b/evals/002-queries/007-aggregation/TASK.txt
index 43e0e99..39c9b73 100644
--- a/evals/002-queries/007-aggregation/TASK.txt
+++ b/evals/002-queries/007-aggregation/TASK.txt
@@ -14,7 +14,7 @@ export default defineSchema({
 ```
 
 Write a query named `getCustomerStats` in `convex/public.ts` that:
-- Takes a customerId as an argument
+- Takes arguments:  `{ customerId: string }`
 - Returns an object with:
   * totalOrders: number of orders
   * totalItems: sum of all quantities
diff --git a/evals/002-queries/007-aggregation/grader.test.ts b/evals/002-queries/007-aggregation/grader.test.ts
index 5e0d446..1e17a3e 100644
--- a/evals/002-queries/007-aggregation/grader.test.ts
+++ b/evals/002-queries/007-aggregation/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get customer stats returns zeros when no orders exist", async () => {
   const stats = await responseClient.query(anyApi.public.getCustomerStats, {
     customerId: "customer1",
diff --git a/evals/002-queries/008-group_by/TASK.txt b/evals/002-queries/008-group_by/TASK.txt
index a3ee9f5..5264646 100644
--- a/evals/002-queries/008-group_by/TASK.txt
+++ b/evals/002-queries/008-group_by/TASK.txt
@@ -15,7 +15,7 @@ export default defineSchema({
 ```
 
 Write a query named `getMonthlySalesByCategory` in `convex/public.ts` that:
-- Takes a region and date (YYYY-MM) as arguments
+- Takes arguments:  `{ region: string, date: string }` where date is `YYYY-MM`
 - Returns an array of objects, each containing:
   * category: string
   * totalSales: number (sum of amounts)
diff --git a/evals/002-queries/008-group_by/grader.test.ts b/evals/002-queries/008-group_by/grader.test.ts
index f6cc600..6a78125 100644
--- a/evals/002-queries/008-group_by/grader.test.ts
+++ b/evals/002-queries/008-group_by/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get monthly sales by category returns empty array when no sales exist", async () => {
   const stats = await responseClient.query(
     anyApi.public.getMonthlySalesByCategory,
diff --git a/evals/002-queries/009-text_search/TASK.txt b/evals/002-queries/009-text_search/TASK.txt
index 74beece..fa6ff14 100644
--- a/evals/002-queries/009-text_search/TASK.txt
+++ b/evals/002-queries/009-text_search/TASK.txt
@@ -18,7 +18,7 @@ export default defineSchema({
 ```
 
 Write a query named `searchArticles` in `convex/public.ts` that:
-- Takes a searchTerm (string) and author (string) as arguments
+- Takes arguments:  `{ searchTerm: string, author: string }`
 - Searches for all published articles that match the search term
 - Returns the top 10 matching articles with:
   * title
diff --git a/evals/002-queries/009-text_search/grader.test.ts b/evals/002-queries/009-text_search/grader.test.ts
index 9b973e1..ab10645 100644
--- a/evals/002-queries/009-text_search/grader.test.ts
+++ b/evals/002-queries/009-text_search/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
 } from "../../../grader";
 import { anyApi } from "convex/server";
@@ -12,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("search articles returns empty array when no matches exist", async () => {
   const articles = await responseClient.query(anyApi.public.searchArticles, {
     searchTerm: "nonexistent",
@@ -115,3 +110,22 @@ test("search articles handles long content correctly", async () => {
   expect(articles[0].preview.length).toBe(100);
   expect(articles[0].preview).toBe(longContent.substring(0, 100));
 });
+
+test("search articles returns at most 10 results", async () => {
+  // Seed 15 matching published articles for the same author
+  const manyArticles = Array.from({ length: 15 }, (_, i) => ({
+    title: `Post ${i + 1}`,
+    content: `match me content ${i + 1}`,
+    author: "alice",
+    tags: ["bulk"],
+    isPublished: true,
+  }));
+  await addDocuments(responseAdminClient, "articles", manyArticles);
+
+  const results = await responseClient.query(anyApi.public.searchArticles, {
+    searchTerm: "match me",
+    author: "alice",
+  });
+
+  expect(results.length).toBeLessThanOrEqual(10);
+});
diff --git a/evals/002-queries/010-parallel_fetch/TASK.txt b/evals/002-queries/010-parallel_fetch/TASK.txt
index 827152a..5c0a1e6 100644
--- a/evals/002-queries/010-parallel_fetch/TASK.txt
+++ b/evals/002-queries/010-parallel_fetch/TASK.txt
@@ -32,7 +32,7 @@ export default defineSchema({
 Dont forget to write out the above schema.
 
 Write a query named `getAuthorDashboard` in `convex/public.ts` that:
-- Takes a user's email as an argument, returning null if the user doesn't exist
+- Takes arguments:  `{ email: string }`, returning null if the user doesn't exist
 - Throws an error if the user exists but its preferences are missing
 - Returns an object containing:
   * user: the user's name, email, theme, and notifications
diff --git a/evals/002-queries/010-parallel_fetch/grader.test.ts b/evals/002-queries/010-parallel_fetch/grader.test.ts
index b9ef229..7288f12 100644
--- a/evals/002-queries/010-parallel_fetch/grader.test.ts
+++ b/evals/002-queries/010-parallel_fetch/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
 } from "../../../grader";
@@ -13,10 +12,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("get author dashboard returns null when user not found", async () => {
   const dashboard = await responseClient.query(
     anyApi.public.getAuthorDashboard,
@@ -113,3 +108,16 @@ test("get author dashboard returns complete data", async () => {
     expect(post.reactionCounts).toHaveProperty("celebrate");
   }
 });
+
+test("get author dashboard throws if preferences missing", async () => {
+  // Create user without preferences
+  await addDocuments(responseAdminClient, "users", [
+    { name: "NoPref", email: "nopref@example.com" },
+  ]);
+
+  await expect(
+    responseClient.query(anyApi.public.getAuthorDashboard, {
+      email: "nopref@example.com",
+    }),
+  ).rejects.toThrow();
+});
diff --git a/evals/002-queries/011-denormalize_pagination/TASK.txt b/evals/002-queries/011-denormalize_pagination/TASK.txt
index 19d99a1..5bad6a3 100644
--- a/evals/002-queries/011-denormalize_pagination/TASK.txt
+++ b/evals/002-queries/011-denormalize_pagination/TASK.txt
@@ -25,7 +25,7 @@ export default defineSchema({
 ```
 
 Create a query `paginateDogsByOwnerAge` in `convex/index.ts` that:
-- Takes `cursor` (string | null) and `numItems` (number) arguments
+- Takes arguments:  `{ cursor: string | null, numItems: number }`
 - Paginates over the dogs table by the owner's age
 - Returns `{ continueCursor, dogs }` where `continueCursor` is a string and `dogs` is an array of dog records { name, breed }
 
diff --git a/evals/002-queries/011-denormalize_pagination/grader.test.ts b/evals/002-queries/011-denormalize_pagination/grader.test.ts
index 587c267..a75d600 100644
--- a/evals/002-queries/011-denormalize_pagination/grader.test.ts
+++ b/evals/002-queries/011-denormalize_pagination/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
   deleteAllDocuments,
@@ -20,61 +19,73 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
-
 test("paginateDogsByOwnerAge returns correct pagination", async () => {
   await deleteAllDocuments(responseAdminClient, ["dogs", "owners"]);
   // Create owners with different ages
-  await addDocuments(responseAdminClient, "owners", [{
-    name: "Young",
-    age: 20,
-  }, {
-    name: "Older",
-    age: 90,
-  }]);
-  const owners = (await listTable(responseAdminClient, "owners")) as Doc<"owners">[];
-  const [owner1Id, owner2Id] = owners.slice(-2).map(o => o._id);
-
-  await addDocuments(responseAdminClient, "dogs", [{
-    name: "Young Dog 1",
-    breed: "Breed1",
-    ownerId: owner1Id,
-    ownerAge: 20,
-  }, {
-    name: "Old Dog",
-    breed: "Breed3",
-    ownerId: owner2Id,
-    ownerAge: 90,
-  },
-  {
-    name: "Young Dog 2",
-    breed: "Breed2",
-    ownerId: owner1Id,
-    ownerAge: 20,
-  },
-]);
+  await addDocuments(responseAdminClient, "owners", [
+    {
+      name: "Young",
+      age: 20,
+    },
+    {
+      name: "Older",
+      age: 90,
+    },
+  ]);
+  const owners = (await listTable(
+    responseAdminClient,
+    "owners",
+  )) as Doc<"owners">[];
+  const [owner1Id, owner2Id] = owners.slice(-2).map((o) => o._id);
+
+  await addDocuments(responseAdminClient, "dogs", [
+    {
+      name: "Young Dog 1",
+      breed: "Breed1",
+      ownerId: owner1Id,
+      ownerAge: 20,
+    },
+    {
+      name: "Old Dog",
+      breed: "Breed3",
+      ownerId: owner2Id,
+      ownerAge: 90,
+    },
+    {
+      name: "Young Dog 2",
+      breed: "Breed2",
+      ownerId: owner1Id,
+      ownerAge: 20,
+    },
+  ]);
 
   // Test pagination
-  const firstPage = await responseClient.query(api.index.paginateDogsByOwnerAge, {
-    cursor: null,
-    numItems: 2,
-  });
+  const firstPage = await responseClient.query(
+    api.index.paginateDogsByOwnerAge,
+    {
+      cursor: null,
+      numItems: 2,
+    },
+  );
 
   expect(firstPage.dogs).toHaveLength(2);
   expect(firstPage.continueCursor).toBeDefined();
-  expect(firstPage.dogs.map(d => d.name)).toEqual(["Young Dog 1", "Young Dog 2"]);
+  expect(firstPage.dogs.map((d) => d.name)).toEqual([
+    "Young Dog 1",
+    "Young Dog 2",
+  ]);
 
-  const secondPage = await responseClient.query(api.index.paginateDogsByOwnerAge, {
-    cursor: firstPage.continueCursor,
-    numItems: 2,
-  });
+  const secondPage = await responseClient.query(
+    api.index.paginateDogsByOwnerAge,
+    {
+      cursor: firstPage.continueCursor,
+      numItems: 2,
+    },
+  );
 
   expect(secondPage.dogs).toHaveLength(1);
   expect(secondPage.continueCursor).toBeDefined();
-  expect(secondPage.dogs.map(d => d.name)).toEqual(["Old Dog"]);
+  expect(secondPage.dogs.map((d) => d.name)).toEqual(["Old Dog"]);
 });
 
 test("paginateDogsByOwnerAge returns correct page sizes", async () => {
@@ -84,8 +95,11 @@ test("paginateDogsByOwnerAge returns correct page sizes", async () => {
     { name: "Middle", age: 35 },
     { name: "Old", age: 45 },
   ]);
-  const owners = await listTable(responseAdminClient, "owners") as Doc<"owners">[];
-  const [young, middle, old] = owners.slice(-3).map(o => o._id);
+  const owners = (await listTable(
+    responseAdminClient,
+    "owners",
+  )) as Doc<"owners">[];
+  const [young, middle, old] = owners.slice(-3).map((o) => o._id);
 
   // Create dogs for each owner
   await addDocuments(responseAdminClient, "dogs", [
@@ -126,8 +140,11 @@ test("paginateDogsByOwnerAge returns dogs ordered by owner age", async () => {
     { name: "Young", age: 20 },
     { name: "Middle", age: 40 },
   ]);
-  const owners = await listTable(responseAdminClient, "owners") as Doc<"owners">[];
-  const [old, young, middle] = owners.slice(-3).map(o => o._id);
+  const owners = (await listTable(
+    responseAdminClient,
+    "owners",
+  )) as Doc<"owners">[];
+  const [old, young, middle] = owners.slice(-3).map((o) => o._id);
 
   // Create dogs for each owner (in mixed order)
   await addDocuments(responseAdminClient, "dogs", [
@@ -143,7 +160,7 @@ test("paginateDogsByOwnerAge returns dogs ordered by owner age", async () => {
   });
 
   // Verify dogs are ordered by owner age
-  const dogNames = result.dogs.map(d => d.name);
+  const dogNames = result.dogs.map((d) => d.name);
   expect(dogNames).toEqual(["YoungDog", "MiddleDog", "OldDog"]);
 });
 
@@ -162,7 +179,9 @@ test("paginateDogsByOwnerAge returns correct dog fields", async () => {
   await addDocuments(responseAdminClient, "owners", [
     { name: "Owner", age: 30 },
   ]);
-  const owner = (await listTable(responseAdminClient, "owners")).at(-1) as Doc<"owners">;
+  const owner = (await listTable(responseAdminClient, "owners")).at(
+    -1,
+  ) as Doc<"owners">;
 
   await addDocuments(responseAdminClient, "dogs", [
     {
@@ -182,4 +201,4 @@ test("paginateDogsByOwnerAge returns correct dog fields", async () => {
     name: "TestDog",
     breed: "TestBreed",
   });
-});
\ No newline at end of file
+});
diff --git a/evals/002-queries/012-index_and_filter/TASK.txt b/evals/002-queries/012-index_and_filter/TASK.txt
index 34870c7..0399fe5 100644
--- a/evals/002-queries/012-index_and_filter/TASK.txt
+++ b/evals/002-queries/012-index_and_filter/TASK.txt
@@ -17,7 +17,7 @@ export default defineSchema({
 Implement the following function in `convex/index.ts`:
 
 1. Create a query `getActiveAdults` that:
-   - Takes an age (number) as an argument
+   - Takes arguments:  `{ minAge: number }`
    - Uses the "by_age" index to efficiently query all users >= the given age
    - Filters out users where isDeleted is true
    - Returns an array of user names
diff --git a/evals/002-queries/012-index_and_filter/grader.test.ts b/evals/002-queries/012-index_and_filter/grader.test.ts
index eb26f8b..3766028 100644
--- a/evals/002-queries/012-index_and_filter/grader.test.ts
+++ b/evals/002-queries/012-index_and_filter/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
 } from "../../../grader";
@@ -17,10 +16,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getActiveAdults returns empty array when no matching users exist", async () => {
   const users = await responseClient.query(api.index.getActiveAdults, {
     minAge: 18,
@@ -82,12 +77,9 @@ test("getActiveAdults handles edge cases", async () => {
   expect(veryOld).toEqual(["VeryOld"]);
 
   // Test age with no possible matches
-  const impossibleAge = await responseClient.query(
-    api.index.getActiveAdults,
-    {
-      minAge: 200,
-    },
-  );
+  const impossibleAge = await responseClient.query(api.index.getActiveAdults, {
+    minAge: 200,
+  });
   expect(impossibleAge).toEqual([]);
 });
 
@@ -123,4 +115,4 @@ test("getActiveAdults handles negative ages", async () => {
 
   expect(results).toContain("Invalid");
   expect(results).toContain("Valid");
-});
\ No newline at end of file
+});
diff --git a/evals/002-queries/013-async_iterator_filter/grader.test.ts b/evals/002-queries/013-async_iterator_filter/grader.test.ts
index b92736d..157a4ff 100644
--- a/evals/002-queries/013-async_iterator_filter/grader.test.ts
+++ b/evals/002-queries/013-async_iterator_filter/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
   deleteAllDocuments,
@@ -20,12 +19,11 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getTeamsWithDeletedAdmins returns empty array when no teams exist", async () => {
-  const teams = await responseClient.query(api.index.getTeamsWithDeletedAdmins, {});
+  const teams = await responseClient.query(
+    api.index.getTeamsWithDeletedAdmins,
+    {},
+  );
   expect(teams).toEqual([]);
 });
 
@@ -35,8 +33,11 @@ test("getTeamsWithDeletedAdmins returns empty array when no admins are deleted",
     { name: "Active User 1", deleted: false },
     { name: "Active User 2", deleted: false },
   ]);
-  const users = await listTable(responseAdminClient, "users") as Doc<"users">[];
-  const [user1Id, user2Id] = users.slice(-2).map(u => u._id);
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const [user1Id, user2Id] = users.slice(-2).map((u) => u._id);
 
   // Create teams with active admins
   await addDocuments(responseAdminClient, "teams", [
@@ -44,7 +45,10 @@ test("getTeamsWithDeletedAdmins returns empty array when no admins are deleted",
     { name: "Team 2", adminId: user2Id },
   ]);
 
-  const teams = await responseClient.query(api.index.getTeamsWithDeletedAdmins, {});
+  const teams = await responseClient.query(
+    api.index.getTeamsWithDeletedAdmins,
+    {},
+  );
   expect(teams).toEqual([]);
 });
 
@@ -56,8 +60,13 @@ test("getTeamsWithDeletedAdmins correctly identifies teams with deleted admins",
     { name: "Another Active User", deleted: false },
     { name: "Another Deleted User", deleted: true },
   ]);
-  const users = await listTable(responseAdminClient, "users") as Doc<"users">[];
-  const [activeUser1, deletedUser1, activeUser2, deletedUser2] = users.slice(-4).map(u => u._id);
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const [activeUser1, deletedUser1, activeUser2, deletedUser2] = users
+    .slice(-4)
+    .map((u) => u._id);
 
   // Create teams with mix of admin states
   await addDocuments(responseAdminClient, "teams", [
@@ -66,7 +75,10 @@ test("getTeamsWithDeletedAdmins correctly identifies teams with deleted admins",
     { name: "Team 3", adminId: activeUser2 },
     { name: "Team 4", adminId: deletedUser2 },
   ]);
-  const teams = await listTable(responseAdminClient, "teams") as Doc<"teams">[];
+  const teams = (await listTable(
+    responseAdminClient,
+    "teams",
+  )) as Doc<"teams">[];
 
   const teamsWithDeletedAdmins = await responseClient.query(
     api.index.getTeamsWithDeletedAdmins,
@@ -84,7 +96,9 @@ test("getTeamsWithDeletedAdmins handles missing admin users", async () => {
   await addDocuments(responseAdminClient, "users", [
     { name: "Existing User", deleted: true },
   ]);
-  const user = (await listTable(responseAdminClient, "users"))[0] as Doc<"users">;
+  const user = (
+    await listTable(responseAdminClient, "users")
+  )[0] as Doc<"users">;
 
   await deleteAllDocuments(responseAdminClient, ["users"]);
 
@@ -100,4 +114,4 @@ test("getTeamsWithDeletedAdmins handles missing admin users", async () => {
 
   // Should not include teams with non-existent admins
   expect(teamsWithDeletedAdmins).toHaveLength(0);
-});
\ No newline at end of file
+});
diff --git a/evals/002-queries/014-select_distinct/grader.test.ts b/evals/002-queries/014-select_distinct/grader.test.ts
index e4ee99f..5a36a98 100644
--- a/evals/002-queries/014-select_distinct/grader.test.ts
+++ b/evals/002-queries/014-select_distinct/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
 } from "../../../grader";
@@ -18,10 +17,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getDistinctAges returns empty array when no users exist", async () => {
   const ages = await responseClient.query(api.index.getDistinctAges, {});
   expect(ages).toEqual([]);
diff --git a/evals/002-queries/015-pagination/TASK.txt b/evals/002-queries/015-pagination/TASK.txt
index 0da221c..58b8915 100644
--- a/evals/002-queries/015-pagination/TASK.txt
+++ b/evals/002-queries/015-pagination/TASK.txt
@@ -15,6 +15,7 @@ export default defineSchema({
 ```
 
 Create a query function `paginateDocuments` in `convex/index.ts` that:
+- Takes arguments:  `{ paginationOpts: { numItems: number, cursor: string | null } }`
 - Returns paginated documents by creation time in descending order (newest first)
 - Don't specify a `returns` validator for this example.
 
diff --git a/evals/002-queries/015-pagination/grader.test.ts b/evals/002-queries/015-pagination/grader.test.ts
index 9faca19..68db9e1 100644
--- a/evals/002-queries/015-pagination/grader.test.ts
+++ b/evals/002-queries/015-pagination/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
 } from "../../../grader";
@@ -20,10 +19,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("paginateDocuments returns empty page when no documents exist", async () => {
   const result = await responseClient.query(api.index.paginateDocuments, {
     paginationOpts: { numItems: 10, cursor: null },
@@ -46,7 +41,11 @@ test("paginateDocuments returns documents in correct order", async () => {
   });
 
   expect(result.page).toHaveLength(3);
-  expect(result.page.map(doc => doc.title)).toEqual(["Third", "Second", "First"]);
+  expect(result.page.map((doc) => doc.title)).toEqual([
+    "Third",
+    "Second",
+    "First",
+  ]);
   expect(result.isDone).toBe(true);
 });
 
@@ -105,14 +104,15 @@ test("paginateDocuments maintains consistent ordering across pages", async () =>
 
   // Collect all documents through pagination
   while (!isDone) {
-    const result: PaginationResult<Doc<"documents">> = await responseClient.query(api.index.paginateDocuments, {
-      paginationOpts: {
-        numItems: 3,
-        cursor,
-      },
-    });
-
-    allTitles.push(...result.page.map(doc => doc.title));
+    const result: PaginationResult<Doc<"documents">> =
+      await responseClient.query(api.index.paginateDocuments, {
+        paginationOpts: {
+          numItems: 3,
+          cursor,
+        },
+      });
+
+    allTitles.push(...result.page.map((doc) => doc.title));
     cursor = result.continueCursor;
     isDone = result.isDone;
   }
@@ -120,7 +120,7 @@ test("paginateDocuments maintains consistent ordering across pages", async () =>
   // Verify ordering
   const expectedTitles = [...documents]
     .sort((a, b) => b.createdAt - a.createdAt)
-    .map(doc => doc.title);
+    .map((doc) => doc.title);
 
   expect(allTitles).toEqual(expectedTitles);
 });
diff --git a/evals/002-queries/016-pagination_index/TASK.txt b/evals/002-queries/016-pagination_index/TASK.txt
index 5e31ee4..200e919 100644
--- a/evals/002-queries/016-pagination_index/TASK.txt
+++ b/evals/002-queries/016-pagination_index/TASK.txt
@@ -18,7 +18,7 @@ export default defineSchema({
 ```
 
 Create a query function `paginateChannelMessages` in `convex/index.ts` that:
-- Takes a channelId argument along with regular pagination options
+- Takes arguments:  `{ channelId: Id<"channels">, paginationOpts: { numItems: number, cursor: string | null } }`
 - Uses the "by_channel" index to efficiently paginate messages in the given channel
 - Orders messages in descending order (newest first)
 - Returns the pagination result to be used with usePaginatedQuery, but don't provide a returns validator for it.
diff --git a/evals/002-queries/016-pagination_index/grader.test.ts b/evals/002-queries/016-pagination_index/grader.test.ts
index 00f7f29..463b217 100644
--- a/evals/002-queries/016-pagination_index/grader.test.ts
+++ b/evals/002-queries/016-pagination_index/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   listTable,
   deleteAllDocuments,
@@ -21,14 +20,14 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("paginateChannelMessages returns empty result for non-existent channel", async () => {
   // Create a channel first
-  await addDocuments(responseAdminClient, "channels", [{ name: "Test Channel" }]);
-  const channel = (await listTable(responseAdminClient, "channels"))[0] as Doc<"channels">;
+  await addDocuments(responseAdminClient, "channels", [
+    { name: "Test Channel" },
+  ]);
+  const channel = (
+    await listTable(responseAdminClient, "channels")
+  )[0] as Doc<"channels">;
 
   const result = await responseClient.query(api.index.paginateChannelMessages, {
     channelId: channel._id,
@@ -41,8 +40,12 @@ test("paginateChannelMessages returns empty result for non-existent channel", as
 
 test("paginateChannelMessages returns messages in correct order", async () => {
   // Create a channel
-  await addDocuments(responseAdminClient, "channels", [{ name: "Test Channel" }]);
-  const channel = (await listTable(responseAdminClient, "channels"))[0] as Doc<"channels">;
+  await addDocuments(responseAdminClient, "channels", [
+    { name: "Test Channel" },
+  ]);
+  const channel = (
+    await listTable(responseAdminClient, "channels")
+  )[0] as Doc<"channels">;
 
   // Add messages
   const messages = [
@@ -58,7 +61,7 @@ test("paginateChannelMessages returns messages in correct order", async () => {
   });
 
   // Messages should be in reverse chronological order
-  expect(result.page.map(m => m.content)).toEqual([
+  expect(result.page.map((m) => m.content)).toEqual([
     "Third Message",
     "Second Message",
     "First Message",
@@ -67,8 +70,12 @@ test("paginateChannelMessages returns messages in correct order", async () => {
 
 test("paginateChannelMessages respects pagination size", async () => {
   // Create a channel
-  await addDocuments(responseAdminClient, "channels", [{ name: "Test Channel" }]);
-  const channel = (await listTable(responseAdminClient, "channels"))[0] as Doc<"channels">;
+  await addDocuments(responseAdminClient, "channels", [
+    { name: "Test Channel" },
+  ]);
+  const channel = (
+    await listTable(responseAdminClient, "channels")
+  )[0] as Doc<"channels">;
 
   // Add several messages
   const messages = Array.from({ length: 5 }, (_, i) => ({
@@ -79,28 +86,37 @@ test("paginateChannelMessages respects pagination size", async () => {
   await addDocuments(responseAdminClient, "messages", messages);
 
   // Request first page
-  const firstPage = await responseClient.query(api.index.paginateChannelMessages, {
-    channelId: channel._id,
-    paginationOpts: { numItems: 2, cursor: null },
-  });
+  const firstPage = await responseClient.query(
+    api.index.paginateChannelMessages,
+    {
+      channelId: channel._id,
+      paginationOpts: { numItems: 2, cursor: null },
+    },
+  );
 
   expect(firstPage.page).toHaveLength(2);
   expect(firstPage.isDone).toBe(false);
 
   // Request second page
-  const secondPage = await responseClient.query(api.index.paginateChannelMessages, {
-    channelId: channel._id,
-    paginationOpts: { numItems: 2, cursor: firstPage.continueCursor },
-  });
+  const secondPage = await responseClient.query(
+    api.index.paginateChannelMessages,
+    {
+      channelId: channel._id,
+      paginationOpts: { numItems: 2, cursor: firstPage.continueCursor },
+    },
+  );
 
   expect(secondPage.page).toHaveLength(2);
   expect(secondPage.isDone).toBe(false);
 
   // Request final page
-  const finalPage = await responseClient.query(api.index.paginateChannelMessages, {
-    channelId: channel._id,
-    paginationOpts: { numItems: 2, cursor: secondPage.continueCursor },
-  });
+  const finalPage = await responseClient.query(
+    api.index.paginateChannelMessages,
+    {
+      channelId: channel._id,
+      paginationOpts: { numItems: 2, cursor: secondPage.continueCursor },
+    },
+  );
 
   expect(finalPage.page).toHaveLength(1);
   expect(finalPage.isDone).toBe(true);
@@ -112,7 +128,10 @@ test("paginateChannelMessages only returns messages from specified channel", asy
     { name: "Channel 1" },
     { name: "Channel 2" },
   ]);
-  const channels = await listTable(responseAdminClient, "channels") as Doc<"channels">[];
+  const channels = (await listTable(
+    responseAdminClient,
+    "channels",
+  )) as Doc<"channels">[];
   const [channel1, channel2] = channels.slice(-2);
 
   // Add messages to both channels
@@ -122,19 +141,25 @@ test("paginateChannelMessages only returns messages from specified channel", asy
   ]);
 
   // Query messages from channel 1
-  const channel1Messages = await responseClient.query(api.index.paginateChannelMessages, {
-    channelId: channel1._id,
-    paginationOpts: { numItems: 10, cursor: null },
-  });
+  const channel1Messages = await responseClient.query(
+    api.index.paginateChannelMessages,
+    {
+      channelId: channel1._id,
+      paginationOpts: { numItems: 10, cursor: null },
+    },
+  );
 
   expect(channel1Messages.page).toHaveLength(1);
   expect(channel1Messages.page[0].content).toBe("Channel 1 Message");
 
   // Query messages from channel 2
-  const channel2Messages = await responseClient.query(api.index.paginateChannelMessages, {
-    channelId: channel2._id,
-    paginationOpts: { numItems: 10, cursor: null },
-  });
+  const channel2Messages = await responseClient.query(
+    api.index.paginateChannelMessages,
+    {
+      channelId: channel2._id,
+      paginationOpts: { numItems: 10, cursor: null },
+    },
+  );
 
   expect(channel2Messages.page).toHaveLength(1);
   expect(channel2Messages.page[0].content).toBe("Channel 2 Message");
@@ -142,8 +167,12 @@ test("paginateChannelMessages only returns messages from specified channel", asy
 
 test("paginateChannelMessages returns all message fields", async () => {
   // Create a channel
-  await addDocuments(responseAdminClient, "channels", [{ name: "Test Channel" }]);
-  const channel = (await listTable(responseAdminClient, "channels"))[0] as Doc<"channels">;
+  await addDocuments(responseAdminClient, "channels", [
+    { name: "Test Channel" },
+  ]);
+  const channel = (
+    await listTable(responseAdminClient, "channels")
+  )[0] as Doc<"channels">;
 
   // Add a message with all fields
   const message = {
@@ -163,8 +192,12 @@ test("paginateChannelMessages returns all message fields", async () => {
 
 test("paginateChannelMessages maintains consistent ordering across pages", async () => {
   // Create a channel
-  await addDocuments(responseAdminClient, "channels", [{ name: "Test Channel" }]);
-  const channel = (await listTable(responseAdminClient, "channels"))[0] as Doc<"channels">;
+  await addDocuments(responseAdminClient, "channels", [
+    { name: "Test Channel" },
+  ]);
+  const channel = (
+    await listTable(responseAdminClient, "channels")
+  )[0] as Doc<"channels">;
 
   // Add messages with known order
   const messages = Array.from({ length: 10 }, (_, i) => ({
@@ -180,10 +213,11 @@ test("paginateChannelMessages maintains consistent ordering across pages", async
   let isDone = false;
 
   while (!isDone) {
-    const result: PaginationResult<Doc<"messages">> = await responseClient.query(api.index.paginateChannelMessages, {
-      channelId: channel._id,
-      paginationOpts: { numItems: 3, cursor },
-    });
+    const result: PaginationResult<Doc<"messages">> =
+      await responseClient.query(api.index.paginateChannelMessages, {
+        channelId: channel._id,
+        paginationOpts: { numItems: 3, cursor },
+      });
 
     allMessages.push(...result.page);
     cursor = result.continueCursor;
@@ -191,6 +225,6 @@ test("paginateChannelMessages maintains consistent ordering across pages", async
   }
 
   // Verify ordering
-  const expectedMessages = [...messages].reverse().map(m => m.content);
-  expect(allMessages.map(m => m.content)).toEqual(expectedMessages);
+  const expectedMessages = [...messages].reverse().map((m) => m.content);
+  expect(allMessages.map((m) => m.content)).toEqual(expectedMessages);
 });
diff --git a/evals/002-queries/017-pagination_join/TASK.txt b/evals/002-queries/017-pagination_join/TASK.txt
index a6a1248..9e4a5af 100644
--- a/evals/002-queries/017-pagination_join/TASK.txt
+++ b/evals/002-queries/017-pagination_join/TASK.txt
@@ -20,7 +20,7 @@ export default defineSchema({
 ```
 
 2. Create a query function `paginateMessagesWithAuthors` in `convex/index.ts` that:
-   - Takes standard pagination parameters
+   - Takes arguments:  `{ paginationOpts: { numItems: number, cursor: string | null } }`
    - Paginates messages in descending order (newest first)
    - Adds the author's name for each message
    - Returns the pagination result to be used with usePaginatedQuery.
diff --git a/evals/002-queries/017-pagination_join/grader.test.ts b/evals/002-queries/017-pagination_join/grader.test.ts
index 5739282..8f0701d 100644
--- a/evals/002-queries/017-pagination_join/grader.test.ts
+++ b/evals/002-queries/017-pagination_join/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
   listTable,
@@ -20,14 +19,13 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("paginateMessagesWithAuthors returns empty page when no messages exist", async () => {
-  const result = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 10, cursor: null },
-  });
+  const result = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 10, cursor: null },
+    },
+  );
 
   expect(result.page).toEqual([]);
   expect(result.isDone).toBe(true);
@@ -35,12 +33,12 @@ test("paginateMessagesWithAuthors returns empty page when no messages exist", as
 
 test("paginateMessagesWithAuthors includes author names with messages", async () => {
   // Create test users
-  const users = [
-    { name: "Alice" },
-    { name: "Bob" },
-  ];
+  const users = [{ name: "Alice" }, { name: "Bob" }];
   await addDocuments(responseAdminClient, "users", users);
-  const userDocs = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  const userDocs = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const [alice, bob] = userDocs.slice(-2);
 
   // Create messages
@@ -50,19 +48,25 @@ test("paginateMessagesWithAuthors includes author names with messages", async ()
   ];
   await addDocuments(responseAdminClient, "messages", messages);
 
-  const result = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 10, cursor: null },
-  });
+  const result = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 10, cursor: null },
+    },
+  );
 
   expect(result.page).toHaveLength(2);
-  expect(result.page.map(m => m.author)).toEqual(["Bob", "Alice"]);
-  expect(result.page.map(m => m.content)).toEqual(["Hi there", "Hello"]);
+  expect(result.page.map((m) => m.author)).toEqual(["Bob", "Alice"]);
+  expect(result.page.map((m) => m.content)).toEqual(["Hi there", "Hello"]);
 });
 
 test("paginateMessagesWithAuthors respects pagination size", async () => {
   // Create a user
   await addDocuments(responseAdminClient, "users", [{ name: "Test User" }]);
-  const user = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  const user = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = user[0]._id;
 
   // Create multiple messages
@@ -73,23 +77,32 @@ test("paginateMessagesWithAuthors respects pagination size", async () => {
   await addDocuments(responseAdminClient, "messages", messages);
 
   // Test pagination
-  const firstPage = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 2, cursor: null },
-  });
+  const firstPage = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 2, cursor: null },
+    },
+  );
 
   expect(firstPage.page).toHaveLength(2);
   expect(firstPage.isDone).toBe(false);
 
-  const secondPage = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 2, cursor: firstPage.continueCursor },
-  });
+  const secondPage = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 2, cursor: firstPage.continueCursor },
+    },
+  );
 
   expect(secondPage.page).toHaveLength(2);
   expect(secondPage.isDone).toBe(false);
 
-  const thirdPage = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 2, cursor: secondPage.continueCursor },
-  });
+  const thirdPage = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 2, cursor: secondPage.continueCursor },
+    },
+  );
 
   expect(thirdPage.page).toHaveLength(1);
   expect(thirdPage.isDone).toBe(true);
@@ -98,7 +111,10 @@ test("paginateMessagesWithAuthors respects pagination size", async () => {
 test("paginateMessagesWithAuthors maintains correct ordering", async () => {
   // Create a user
   await addDocuments(responseAdminClient, "users", [{ name: "User" }]);
-  const user = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  const user = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = user[0]._id;
 
   // Create messages in specific order
@@ -109,22 +125,28 @@ test("paginateMessagesWithAuthors maintains correct ordering", async () => {
   ];
   await addDocuments(responseAdminClient, "messages", messages);
 
-  const result = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 10, cursor: null },
-  });
-
-  expect(result.page.map(m => m.content)).toEqual(["Third", "Second", "First"]);
+  const result = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 10, cursor: null },
+    },
+  );
+
+  expect(result.page.map((m) => m.content)).toEqual([
+    "Third",
+    "Second",
+    "First",
+  ]);
 });
 
 test("paginateMessagesWithAuthors handles multiple authors correctly", async () => {
   // Create multiple users
-  const users = [
-    { name: "Alice" },
-    { name: "Bob" },
-    { name: "Charlie" },
-  ];
+  const users = [{ name: "Alice" }, { name: "Bob" }, { name: "Charlie" }];
   await addDocuments(responseAdminClient, "users", users);
-  const userDocs = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  const userDocs = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const [alice, bob, charlie] = userDocs.slice(-3);
 
   // Create interleaved messages
@@ -136,12 +158,17 @@ test("paginateMessagesWithAuthors handles multiple authors correctly", async ()
   ];
   await addDocuments(responseAdminClient, "messages", messages);
 
-  const result = await responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 10, cursor: null },
-  });
+  const result = await responseClient.query(
+    api.index.paginateMessagesWithAuthors,
+    {
+      paginationOpts: { numItems: 10, cursor: null },
+    },
+  );
 
   expect(result.page).toHaveLength(4);
-  expect(result.page.map(m => ({ author: m.author, content: m.content }))).toEqual([
+  expect(
+    result.page.map((m) => ({ author: m.author, content: m.content })),
+  ).toEqual([
     { author: "Alice", content: "Alice 2" },
     { author: "Charlie", content: "Charlie 1" },
     { author: "Bob", content: "Bob 1" },
@@ -151,8 +178,13 @@ test("paginateMessagesWithAuthors handles multiple authors correctly", async ()
 
 test("paginateMessagesWithAuthors throws error for missing author", async () => {
   // Create a user and then delete it
-  await addDocuments(responseAdminClient, "users", [{ name: "Temporary User" }]);
-  const user = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  await addDocuments(responseAdminClient, "users", [
+    { name: "Temporary User" },
+  ]);
+  const user = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = user[0]._id;
 
   // Create a message
@@ -164,7 +196,9 @@ test("paginateMessagesWithAuthors throws error for missing author", async () =>
   await deleteAllDocuments(responseAdminClient, ["users"]);
 
   // Attempt to paginate messages
-  await expect(responseClient.query(api.index.paginateMessagesWithAuthors, {
-    paginationOpts: { numItems: 10, cursor: null },
-  })).rejects.toThrow();
-});
\ No newline at end of file
+  await expect(
+    responseClient.query(api.index.paginateMessagesWithAuthors, {
+      paginationOpts: { numItems: 10, cursor: null },
+    }),
+  ).rejects.toThrow();
+});
diff --git a/evals/002-queries/018-pagination_returns_validator/TASK.txt b/evals/002-queries/018-pagination_returns_validator/TASK.txt
index bed5646..655f6ff 100644
--- a/evals/002-queries/018-pagination_returns_validator/TASK.txt
+++ b/evals/002-queries/018-pagination_returns_validator/TASK.txt
@@ -16,7 +16,7 @@ export default defineSchema({
 ```
 
 Create a query function `paginatePosts` in `convex/index.ts` that:
-- Takes standard pagination parameters
+- Takes arguments:  `{ paginationOpts: { numItems: number, cursor: string | null } }`
 - Paginates posts in the default order
 - Must include a proper returns validator that accurately types the pagination result
 - Should be compatible with the usePaginatedQuery hook
diff --git a/evals/002-queries/018-pagination_returns_validator/grader.test.ts b/evals/002-queries/018-pagination_returns_validator/grader.test.ts
index ea174f5..1963f88 100644
--- a/evals/002-queries/018-pagination_returns_validator/grader.test.ts
+++ b/evals/002-queries/018-pagination_returns_validator/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
 } from "../../../grader";
@@ -20,10 +19,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("paginatePosts returns empty page with correct structure when no posts exist", async () => {
   const result = await responseClient.query(api.index.paginatePosts, {
     paginationOpts: { numItems: 10, cursor: null },
@@ -101,22 +96,23 @@ test("paginatePosts maintains consistent ordering across pages", async () => {
   let isDone = false;
 
   while (!isDone) {
-    const result: PaginationResult<Doc<"posts">> = await responseClient.query(api.index.paginatePosts, {
-      paginationOpts: { numItems: 2, cursor },
-    });
+    const result: PaginationResult<Doc<"posts">> = await responseClient.query(
+      api.index.paginatePosts,
+      {
+        paginationOpts: { numItems: 2, cursor },
+      },
+    );
 
     allTitles.push(...result.page.map((post: { title: string }) => post.title));
     cursor = result.continueCursor;
     isDone = result.isDone;
   }
 
-  expect(allTitles).toEqual(posts.map(p => p.title));
+  expect(allTitles).toEqual(posts.map((p) => p.title));
 });
 
 test("paginatePosts handles single item pages", async () => {
-  const posts = [
-    { title: "Single Post", content: "Test Content" },
-  ];
+  const posts = [{ title: "Single Post", content: "Test Content" }];
   await addDocuments(responseAdminClient, "posts", posts);
 
   const result = await responseClient.query(api.index.paginatePosts, {
@@ -152,13 +148,17 @@ test("paginatePosts returns all required pagination fields", async () => {
 });
 
 test("paginatePosts throws on empty pages", async () => {
-  await expect(responseClient.query(api.index.paginatePosts, {
-    paginationOpts: { numItems: 0, cursor: null },
-  })).rejects.toThrow();
+  await expect(
+    responseClient.query(api.index.paginatePosts, {
+      paginationOpts: { numItems: 0, cursor: null },
+    }),
+  ).rejects.toThrow();
 });
 
 test("paginatePosts handles invalid cursor gracefully", async () => {
-  await expect(responseClient.query(api.index.paginatePosts, {
-    paginationOpts: { numItems: 10, cursor: "invalid_cursor" },
-  })).rejects.toThrow();
-});
\ No newline at end of file
+  await expect(
+    responseClient.query(api.index.paginatePosts, {
+      paginationOpts: { numItems: 10, cursor: "invalid_cursor" },
+    }),
+  ).rejects.toThrow();
+});
diff --git a/evals/002-queries/019-no_scheduler/TASK.txt b/evals/002-queries/019-no_scheduler/TASK.txt
index f595f98..02d411e 100644
--- a/evals/002-queries/019-no_scheduler/TASK.txt
+++ b/evals/002-queries/019-no_scheduler/TASK.txt
@@ -21,7 +21,11 @@ export default defineSchema({
 ```
 
 Create an internal function that logs access to a document by writing to the `accessLogs` table.
-Create a function that queries the `documents` table for some document by ID and logs access to the document asynchronously.
+Create a mutation named `getDocument` in `convex/index.ts` that:
+- Takes arguments:  `{ documentId: Id<"documents"> }`
+- Throws an error with the message "Document not found" if there is no document with that ID
+- Logs access asynchronously by writing a record to `accessLogs` with `{ documentId, action: "read" }`
+- Returns the full document including its system fields
 
 Files to create:
 - `convex/schema.ts` with the schema above
diff --git a/evals/002-queries/019-no_scheduler/grader.test.ts b/evals/002-queries/019-no_scheduler/grader.test.ts
index 3cac777..f2f89de 100644
--- a/evals/002-queries/019-no_scheduler/grader.test.ts
+++ b/evals/002-queries/019-no_scheduler/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
   listTable,
@@ -20,16 +19,15 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getDocument throws error for non-existent document", async () => {
   // Create a document first to get valid ID format
   await addDocuments(responseAdminClient, "documents", [
     { title: "Test", content: "Content" },
   ]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   const invalidId = docs[0]._id;
 
   // Delete the document
@@ -38,7 +36,7 @@ test("getDocument throws error for non-existent document", async () => {
   await expect(
     responseClient.mutation(api.index.getDocument, {
       documentId: invalidId,
-    })
+    }),
   ).rejects.toThrow("Document not found");
 });
 
@@ -49,7 +47,10 @@ test("getDocument returns correct document data", async () => {
   };
 
   await addDocuments(responseAdminClient, "documents", [testDoc]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   const docId = docs[0]._id;
 
   const result = await responseClient.mutation(api.index.getDocument, {
@@ -67,7 +68,10 @@ test("getDocument creates access log entry", async () => {
   await addDocuments(responseAdminClient, "documents", [
     { title: "Test", content: "Content" },
   ]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   const docId = docs[0]._id;
 
   // Access document
@@ -79,7 +83,10 @@ test("getDocument creates access log entry", async () => {
   await new Promise((resolve) => setTimeout(resolve, 100));
 
   // Check access logs
-  const logs = await listTable(responseAdminClient, "accessLogs") as Doc<"accessLogs">[];
+  const logs = (await listTable(
+    responseAdminClient,
+    "accessLogs",
+  )) as Doc<"accessLogs">[];
 
   expect(logs).toHaveLength(1);
   expect(logs[0]).toMatchObject({
@@ -93,7 +100,10 @@ test("getDocument creates multiple access logs for multiple accesses", async ()
   await addDocuments(responseAdminClient, "documents", [
     { title: "Test", content: "Content" },
   ]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   const docId = docs[0]._id;
 
   // Access document multiple times
@@ -107,10 +117,13 @@ test("getDocument creates multiple access logs for multiple accesses", async ()
   await new Promise((resolve) => setTimeout(resolve, 100));
 
   // Check access logs
-  const logs = await listTable(responseAdminClient, "accessLogs") as Doc<"accessLogs">[];
+  const logs = (await listTable(
+    responseAdminClient,
+    "accessLogs",
+  )) as Doc<"accessLogs">[];
 
   expect(logs).toHaveLength(3);
-  logs.forEach(log => {
+  logs.forEach((log) => {
     expect(log).toMatchObject({
       documentId: docId,
       action: "read",
@@ -125,7 +138,10 @@ test("getDocument returns all required document fields", async () => {
   };
 
   await addDocuments(responseAdminClient, "documents", [testDoc]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   const docId = docs[0]._id;
 
   const result = await responseClient.mutation(api.index.getDocument, {
@@ -142,7 +158,10 @@ test("access logs are created with correct structure", async () => {
   await addDocuments(responseAdminClient, "documents", [
     { title: "Test", content: "Content" },
   ]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   const docId = docs[0]._id;
 
   await responseClient.mutation(api.index.getDocument, {
@@ -152,7 +171,10 @@ test("access logs are created with correct structure", async () => {
   // Wait a short time for async operation
   await new Promise((resolve) => setTimeout(resolve, 100));
 
-  const logs = await listTable(responseAdminClient, "accessLogs") as Doc<"accessLogs">[];
+  const logs = (await listTable(
+    responseAdminClient,
+    "accessLogs",
+  )) as Doc<"accessLogs">[];
 
   expect(logs[0]).toHaveProperty("_id");
   expect(logs[0]).toHaveProperty("_creationTime");
@@ -166,7 +188,10 @@ test("getDocument handles concurrent access properly", async () => {
     { title: "Doc 1", content: "Content 1" },
     { title: "Doc 2", content: "Content 2" },
   ]);
-  const docs = await listTable(responseAdminClient, "documents") as Doc<"documents">[];
+  const docs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
 
   // Access different documents concurrently
   await Promise.all([
@@ -177,10 +202,13 @@ test("getDocument handles concurrent access properly", async () => {
   // Wait a short time for async operations
   await new Promise((resolve) => setTimeout(resolve, 100));
 
-  const logs = await listTable(responseAdminClient, "accessLogs") as Doc<"accessLogs">[];
+  const logs = (await listTable(
+    responseAdminClient,
+    "accessLogs",
+  )) as Doc<"accessLogs">[];
 
   expect(logs).toHaveLength(2);
-  expect(new Set(logs.map(log => log.documentId))).toEqual(
-    new Set([docs[0]._id, docs[1]._id])
+  expect(new Set(logs.map((log) => log.documentId))).toEqual(
+    new Set([docs[0]._id, docs[1]._id]),
   );
-});
\ No newline at end of file
+});
diff --git a/evals/002-queries/020-text_search_join/TASK.txt b/evals/002-queries/020-text_search_join/TASK.txt
index 2c499c7..e00445f 100644
--- a/evals/002-queries/020-text_search_join/TASK.txt
+++ b/evals/002-queries/020-text_search_join/TASK.txt
@@ -25,7 +25,7 @@ export default defineSchema({
 ```
 
 Create a query function `searchPostsWithAuthors` in `convex/index.ts` that:
-- Takes a search query string parameter
+- Takes arguments:  `{ query: string }`
 - Performs a text search on the posts table using the "search" index
 - Joins each result with the corresponding author information
 - Returns an array of posts with author details included
diff --git a/evals/002-queries/020-text_search_join/grader.test.ts b/evals/002-queries/020-text_search_join/grader.test.ts
index b27732f..1bff46d 100644
--- a/evals/002-queries/020-text_search_join/grader.test.ts
+++ b/evals/002-queries/020-text_search_join/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
   listTable,
@@ -20,10 +19,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("searchPostsWithAuthors returns empty array when no matches found", async () => {
   const result = await responseClient.query(api.index.searchPostsWithAuthors, {
     query: "nonexistent",
@@ -37,7 +32,10 @@ test("searchPostsWithAuthors finds posts by content", async () => {
   await addDocuments(responseAdminClient, "authors", [
     { name: "John Doe", email: "john@example.com" },
   ]);
-  const authors = await listTable(responseAdminClient, "authors") as Doc<"authors">[];
+  const authors = (await listTable(
+    responseAdminClient,
+    "authors",
+  )) as Doc<"authors">[];
   const authorId = authors[0]._id;
 
   // Create test posts
@@ -68,7 +66,10 @@ test("searchPostsWithAuthors returns 'Unknown Author' for missing authors", asyn
   await addDocuments(responseAdminClient, "authors", [
     { name: "Jane Doe", email: "jane@example.com" },
   ]);
-  const authors = await listTable(responseAdminClient, "authors") as Doc<"authors">[];
+  const authors = (await listTable(
+    responseAdminClient,
+    "authors",
+  )) as Doc<"authors">[];
   const authorId = authors[0]._id;
 
   // Create a post
@@ -97,8 +98,11 @@ test("searchPostsWithAuthors handles multiple matches", async () => {
     { name: "Author 1", email: "author1@example.com" },
     { name: "Author 2", email: "author2@example.com" },
   ]);
-  const authors = await listTable(responseAdminClient, "authors") as Doc<"authors">[];
-  const [author1Id, author2Id] = authors.map(a => a._id);
+  const authors = (await listTable(
+    responseAdminClient,
+    "authors",
+  )) as Doc<"authors">[];
+  const [author1Id, author2Id] = authors.map((a) => a._id);
 
   // Create posts with common search term
   await addDocuments(responseAdminClient, "posts", [
@@ -119,7 +123,9 @@ test("searchPostsWithAuthors handles multiple matches", async () => {
   });
 
   expect(result).toHaveLength(2);
-  expect(new Set(result.map(p => p.author))).toEqual(new Set(["Author 1", "Author 2"]));
+  expect(new Set(result.map((p) => p.author))).toEqual(
+    new Set(["Author 1", "Author 2"]),
+  );
 });
 
 test("searchPostsWithAuthors returns correct result structure", async () => {
@@ -127,7 +133,10 @@ test("searchPostsWithAuthors returns correct result structure", async () => {
   await addDocuments(responseAdminClient, "authors", [
     { name: "Test Author", email: "test@example.com" },
   ]);
-  const authors = await listTable(responseAdminClient, "authors") as Doc<"authors">[];
+  const authors = (await listTable(
+    responseAdminClient,
+    "authors",
+  )) as Doc<"authors">[];
   const authorId = authors[0]._id;
 
   // Create post
@@ -147,4 +156,4 @@ test("searchPostsWithAuthors returns correct result structure", async () => {
   expect(result[0]).toHaveProperty("content");
   expect(result[0]).toHaveProperty("author");
   expect(Object.keys(result[0])).toHaveLength(3);
-});
\ No newline at end of file
+});
diff --git a/evals/002-queries/021-intersection/TASK.txt b/evals/002-queries/021-intersection/TASK.txt
index 6eb12d3..2df5719 100644
--- a/evals/002-queries/021-intersection/TASK.txt
+++ b/evals/002-queries/021-intersection/TASK.txt
@@ -22,6 +22,7 @@ export default defineSchema({
 ```
 
 Create a query function `getActiveUsersWithPosts` in `convex/index.ts` that:
+- Takes no arguments (empty object `{}`)
 - Returns an array of users with their published posts included
 
 Files to create:
diff --git a/evals/002-queries/021-intersection/answer/convex/README.md b/evals/002-queries/021-intersection/answer/convex/README.md
new file mode 100644
index 0000000..4d82e13
--- /dev/null
+++ b/evals/002-queries/021-intersection/answer/convex/README.md
@@ -0,0 +1,90 @@
+# Welcome to your Convex functions directory!
+
+Write your Convex functions here.
+See https://docs.convex.dev/functions for more.
+
+A query function that takes two arguments looks like:
+
+```ts
+// functions.js
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+export const myQueryFunction = query({
+  // Validators for arguments.
+  args: {
+    first: v.number(),
+    second: v.string(),
+  },
+
+  // Function implementation.
+  handler: async (ctx, args) => {
+    // Read the database as many times as you need here.
+    // See https://docs.convex.dev/database/reading-data.
+    const documents = await ctx.db.query("tablename").collect();
+
+    // Arguments passed from the client are properties of the args object.
+    console.log(args.first, args.second);
+
+    // Write arbitrary JavaScript here: filter, aggregate, build derived data,
+    // remove non-public properties, or create new objects.
+    return documents;
+  },
+});
+```
+
+Using this query function in a React component looks like:
+
+```ts
+const data = useQuery(api.functions.myQueryFunction, {
+  first: 10,
+  second: "hello",
+});
+```
+
+A mutation function looks like:
+
+```ts
+// functions.js
+import { mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+export const myMutationFunction = mutation({
+  // Validators for arguments.
+  args: {
+    first: v.string(),
+    second: v.string(),
+  },
+
+  // Function implementation.
+  handler: async (ctx, args) => {
+    // Insert or modify documents in the database here.
+    // Mutations can also read from the database like queries.
+    // See https://docs.convex.dev/database/writing-data.
+    const message = { body: args.first, author: args.second };
+    const id = await ctx.db.insert("messages", message);
+
+    // Optionally, return a value from your mutation.
+    return await ctx.db.get(id);
+  },
+});
+```
+
+Using this mutation function in a React component looks like:
+
+```ts
+const mutation = useMutation(api.functions.myMutationFunction);
+function handleButtonPress() {
+  // fire and forget, the most common way to use mutations
+  mutation({ first: "Hello!", second: "me" });
+  // OR
+  // use the result once the mutation has completed
+  mutation({ first: "Hello!", second: "me" }).then((result) =>
+    console.log(result),
+  );
+}
+```
+
+Use the Convex CLI to push your functions to a deployment. See everything
+the Convex CLI can do by running `npx convex -h` in your project root
+directory. To learn more, launch the docs with `npx convex docs`.
diff --git a/evals/002-queries/021-intersection/grader.test.ts b/evals/002-queries/021-intersection/grader.test.ts
index 6d7dbdb..1c677d5 100644
--- a/evals/002-queries/021-intersection/grader.test.ts
+++ b/evals/002-queries/021-intersection/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
   listTable,
@@ -20,12 +19,11 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getActiveUsersWithPosts returns empty array when no users exist", async () => {
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
   expect(result).toEqual([]);
 });
 
@@ -37,7 +35,10 @@ test("getActiveUsersWithPosts only returns active users", async () => {
   ];
   await addDocuments(responseAdminClient, "users", users);
 
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
 
   expect(result).toHaveLength(1);
   expect(result[0].name).toBe("Active User");
@@ -48,7 +49,10 @@ test("getActiveUsersWithPosts returns only published posts", async () => {
   await addDocuments(responseAdminClient, "users", [
     { name: "Test User", status: "active" as const },
   ]);
-  const users = await listTable(responseAdminClient, "users") as Doc<"users">[];
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = users[0]._id;
 
   // Create published and unpublished posts
@@ -58,7 +62,10 @@ test("getActiveUsersWithPosts returns only published posts", async () => {
   ];
   await addDocuments(responseAdminClient, "posts", posts);
 
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
 
   expect(result[0].posts).toHaveLength(1);
   expect(result[0].posts[0].title).toBe("Published Post");
@@ -69,7 +76,10 @@ test("getActiveUsersWithPosts returns correct structure", async () => {
   await addDocuments(responseAdminClient, "users", [
     { name: "Test User", status: "active" as const },
   ]);
-  const users = await listTable(responseAdminClient, "users") as Doc<"users">[];
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = users[0]._id;
 
   // Create post
@@ -77,7 +87,10 @@ test("getActiveUsersWithPosts returns correct structure", async () => {
     { authorId: userId, title: "Test Post", published: true },
   ]);
 
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
 
   expect(result[0]).toMatchObject({
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -95,7 +108,10 @@ test("getActiveUsersWithPosts handles users with no posts", async () => {
     { name: "No Posts User", status: "active" as const },
   ]);
 
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
 
   expect(result).toHaveLength(1);
   expect(result[0].posts).toEqual([]);
@@ -108,8 +124,11 @@ test("getActiveUsersWithPosts handles multiple users with multiple posts", async
     { name: "User 2", status: "active" as const },
   ];
   await addDocuments(responseAdminClient, "users", users);
-  const userDocs = await listTable(responseAdminClient, "users") as Doc<"users">[];
-  const [user1Id, user2Id] = userDocs.map(u => u._id);
+  const userDocs = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const [user1Id, user2Id] = userDocs.map((u) => u._id);
 
   // Create posts for each user
   const posts = [
@@ -119,11 +138,14 @@ test("getActiveUsersWithPosts handles multiple users with multiple posts", async
   ];
   await addDocuments(responseAdminClient, "posts", posts);
 
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
 
   expect(result).toHaveLength(2);
-  const user1Result = result.find(u => u.name === "User 1");
-  const user2Result = result.find(u => u.name === "User 2");
+  const user1Result = result.find((u) => u.name === "User 1");
+  const user2Result = result.find((u) => u.name === "User 2");
 
   expect(user1Result?.posts).toHaveLength(2);
   expect(user2Result?.posts).toHaveLength(1);
@@ -136,22 +158,28 @@ test("getActiveUsersWithPosts maintains data integrity across users", async () =
     { name: "Active User 2", status: "active" as const },
     { name: "Inactive User", status: "inactive" as const },
   ]);
-  const users = await listTable(responseAdminClient, "users") as Doc<"users">[];
-  const activeUsers = users.filter(u => u.status === "active");
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const activeUsers = users.filter((u) => u.status === "active");
 
   // Create posts with mixed published states
-  const posts = activeUsers.flatMap(user => [
+  const posts = activeUsers.flatMap((user) => [
     { authorId: user._id, title: `${user.name} Published`, published: true },
     { authorId: user._id, title: `${user.name} Unpublished`, published: false },
   ]);
   await addDocuments(responseAdminClient, "posts", posts);
 
-  const result = await responseClient.query(api.index.getActiveUsersWithPosts, {});
+  const result = await responseClient.query(
+    api.index.getActiveUsersWithPosts,
+    {},
+  );
 
   expect(result).toHaveLength(2);
-  result.forEach(user => {
+  result.forEach((user) => {
     expect(user.posts).toHaveLength(1);
     expect(user.posts[0].title).toContain("Published");
     expect(user.posts[0].title).toContain(user.name);
   });
-});
\ No newline at end of file
+});
diff --git a/evals/003-mutations/000-delete/TASK.txt b/evals/003-mutations/000-delete/TASK.txt
index 94d15d3..7d72016 100644
--- a/evals/003-mutations/000-delete/TASK.txt
+++ b/evals/003-mutations/000-delete/TASK.txt
@@ -13,6 +13,6 @@ export default defineSchema({
 ```
 
 Write a mutation named `deleteUserById` in `convex/index.ts` that:
-- Takes an id as an argument
+- Takes arguments:  `{ id: Id<"users"> }`
 - Efficiently deletes the document
 - Returns null
\ No newline at end of file
diff --git a/evals/003-mutations/000-delete/grader.test.ts b/evals/003-mutations/000-delete/grader.test.ts
index b7c409c..2feb13a 100644
--- a/evals/003-mutations/000-delete/grader.test.ts
+++ b/evals/003-mutations/000-delete/grader.test.ts
@@ -1,10 +1,29 @@
-import { test } from "vitest";
-import { compareSchema, compareFunctionSpec } from "../../../grader";
+import { expect, test } from "vitest";
+import {
+  responseAdminClient,
+  responseClient,
+  compareSchema,
+  addDocuments,
+  listTable,
+} from "../../../grader";
+import { anyApi } from "convex/server";
 
 test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
+test("deletes existing user by id and returns null", async () => {
+  await addDocuments(responseAdminClient, "users", [
+    { email: "a@example.com", name: "A", age: 20 },
+  ]);
+  const usersBefore = await listTable(responseAdminClient, "users");
+  const id = usersBefore[0]._id;
+
+  const result = await responseClient.mutation(anyApi.index.deleteUserById, {
+    id,
+  });
+  expect(result).toBeNull();
+
+  const usersAfter = await listTable(responseAdminClient, "users");
+  expect(usersAfter.find((u: { _id: string }) => u._id === id)).toBeUndefined();
 });
diff --git a/evals/003-mutations/001-insert/TASK.txt b/evals/003-mutations/001-insert/TASK.txt
index 4346582..8446fe4 100644
--- a/evals/003-mutations/001-insert/TASK.txt
+++ b/evals/003-mutations/001-insert/TASK.txt
@@ -13,6 +13,6 @@ export default defineSchema({
 ```
 
 Write a mutation named `insertUser` in `convex/index.ts` that:
-- Takes a user object as an argument
+- Takes arguments:  `{ email: string, name: string, age: number }`
 - Inserts the user into the "users" table
 - Returns the _id field of the inserted document
\ No newline at end of file
diff --git a/evals/003-mutations/001-insert/grader.test.ts b/evals/003-mutations/001-insert/grader.test.ts
index a706228..bb5f510 100644
--- a/evals/003-mutations/001-insert/grader.test.ts
+++ b/evals/003-mutations/001-insert/grader.test.ts
@@ -1,8 +1,9 @@
 import { expect, test } from "vitest";
 import {
   responseClient,
+  responseAdminClient,
   compareSchema,
-  compareFunctionSpec,
+  listTable,
 } from "../../../grader";
 import { anyApi } from "convex/server";
 
@@ -10,10 +11,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("insert user success", async () => {
   const result = await responseClient.mutation(anyApi.index.insertUser, {
     email: "jordan@convex.dev",
@@ -36,3 +33,21 @@ test("insert user error", async () => {
   expect(error).toBeDefined();
   expect(error.toString()).toContain("ArgumentValidationError");
 });
+
+test("insert user persists fields", async () => {
+  const email = "persist@example.com";
+  const name = "Persist";
+  const age = 42;
+
+  await responseClient.mutation(anyApi.index.insertUser, {
+    email,
+    name,
+    age,
+  });
+
+  const users = await listTable(responseAdminClient, "users");
+  const found = users.find((u: any) => u.email === email);
+  expect(found).toBeDefined();
+  expect(found.name).toBe(name);
+  expect(found.age).toBe(age);
+});
diff --git a/evals/003-mutations/002-patch/TASK.txt b/evals/003-mutations/002-patch/TASK.txt
index a4af6bd..342e875 100644
--- a/evals/003-mutations/002-patch/TASK.txt
+++ b/evals/003-mutations/002-patch/TASK.txt
@@ -13,7 +13,7 @@ export default defineSchema({
 ```
 
 Write a mutation named `updateUserEmail` in `convex/index.ts` that:
-- Takes an id and an email as arguments
+- Takes arguments:  `{ id: Id<"users">, email: string }`
 - Efficiently looks up the user
 - Throws an error if there is no user with that id
 - Patches the email with the new email
diff --git a/evals/003-mutations/002-patch/grader.test.ts b/evals/003-mutations/002-patch/grader.test.ts
index a904447..9dc0ec0 100644
--- a/evals/003-mutations/002-patch/grader.test.ts
+++ b/evals/003-mutations/002-patch/grader.test.ts
@@ -1,8 +1,10 @@
 import { expect, test } from "vitest";
 import {
   responseClient,
+  responseAdminClient,
   compareSchema,
-  compareFunctionSpec,
+  addDocuments,
+  listTable,
 } from "../../../grader";
 import { anyApi } from "convex/server";
 
@@ -10,10 +12,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("update user error", async () => {
   let error: any = undefined;
   try {
@@ -27,3 +25,35 @@ test("update user error", async () => {
   expect(error).toBeDefined();
   expect(error.toString()).toContain("ArgumentValidationError");
 });
+
+test("update user email success", async () => {
+  // Seed user
+  await addDocuments(responseAdminClient, "users", [
+    { email: "old@example.com", name: "Old", age: 30 },
+  ]);
+  const before = await listTable(responseAdminClient, "users");
+  const id = before[0]._id as string;
+
+  // Update email
+  await responseClient.mutation(anyApi.index.updateUserEmail, {
+    id,
+    email: "new@example.com",
+  });
+
+  const after = await listTable(responseAdminClient, "users");
+  const updated = after.find((u: any) => u._id === id);
+  expect(updated?.email).toBe("new@example.com");
+});
+
+test("update user email for non-existent id throws", async () => {
+  let error: any;
+  try {
+    await responseClient.mutation(anyApi.index.updateUserEmail, {
+      id: "nonexistent_id" as unknown as string,
+      email: "x@example.com",
+    });
+  } catch (e) {
+    error = e;
+  }
+  expect(error).toBeDefined();
+});
diff --git a/evals/003-mutations/003-patch_nested/TASK.txt b/evals/003-mutations/003-patch_nested/TASK.txt
index f5380a7..89e13b1 100644
--- a/evals/003-mutations/003-patch_nested/TASK.txt
+++ b/evals/003-mutations/003-patch_nested/TASK.txt
@@ -26,24 +26,24 @@ export default defineSchema({
 Implement the following functions in `convex/index.ts`:
 
 1. Create a mutation `createDocument` that:
-   - Takes a complete document object matching the schema
+   - Takes a complete document object matching the schema as `{ metadata: ..., content: string }`
    - Inserts it into the database
    - Returns the new document's ID
 
 2. Create a mutation `patchDocumentMetadata` that:
-   - Takes a document ID and a complete new metadata object
+   - Takes an argument object `{ documentId: Id<"documents">, metadata: { title: string, author: { name: string, contact: { email: string, phone?: string | undefined } }, tags: string[] } }`
    - Replaces the entire metadata object while preserving content
    - Throws an error if document doesn't exist
-   - Returns nothin
+   - Returns nothing
 
 3. Create a mutation `patchAuthorInfo` that:
-   - Takes a document ID and a complete new author object
+   - Takes an argument object `{ documentId: Id<"documents">, author: { name: string, contact: { email: string, phone?: string | undefined } } }`
    - Updates only the metadata.author portion of the document
    - Throws an error if document doesn't exist
    - Returns nothing
 
 4. Create a query `getDocument` that:
-   - Takes a document ID (documentId)
+   - Takes an argument object `{ documentId: Id<"documents"> }`
    - Returns the complete document with all nested fields
    - Returns null if document not found
 
diff --git a/evals/003-mutations/003-patch_nested/grader.test.ts b/evals/003-mutations/003-patch_nested/grader.test.ts
index c76e44f..7073f27 100644
--- a/evals/003-mutations/003-patch_nested/grader.test.ts
+++ b/evals/003-mutations/003-patch_nested/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   deleteAllDocuments,
 } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
@@ -17,10 +16,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 const sampleDocument = {
   metadata: {
     title: "Test Document",
@@ -37,7 +32,10 @@ const sampleDocument = {
 };
 
 test("create and get document", async () => {
-  const docId = await responseClient.mutation(api.index.createDocument, sampleDocument);
+  const docId = await responseClient.mutation(
+    api.index.createDocument,
+    sampleDocument,
+  );
   expect(docId).toBeDefined();
 
   const fetchedDoc = await responseClient.query(api.index.getDocument, {
@@ -49,7 +47,10 @@ test("create and get document", async () => {
 });
 
 test("patch document metadata", async () => {
-  const docId = await responseClient.mutation(api.index.createDocument, sampleDocument);
+  const docId = await responseClient.mutation(
+    api.index.createDocument,
+    sampleDocument,
+  );
 
   const newMetadata = {
     title: "Updated Title",
@@ -75,7 +76,10 @@ test("patch document metadata", async () => {
 });
 
 test("patch author info", async () => {
-  const docId = await responseClient.mutation(api.index.createDocument, sampleDocument);
+  const docId = await responseClient.mutation(
+    api.index.createDocument,
+    sampleDocument,
+  );
 
   const newAuthor = {
     name: "Jane Smith",
@@ -100,7 +104,10 @@ test("patch author info", async () => {
 });
 
 test("get non-existent document returns null", async () => {
-  const docId = await responseClient.mutation(api.index.createDocument, sampleDocument);
+  const docId = await responseClient.mutation(
+    api.index.createDocument,
+    sampleDocument,
+  );
   await responseClient.mutation(api.index.patchDocumentMetadata, {
     documentId: docId,
     metadata: sampleDocument.metadata,
@@ -108,7 +115,7 @@ test("get non-existent document returns null", async () => {
   await deleteAllDocuments(responseAdminClient, ["documents"]);
 
   const result = await responseClient.query(api.index.getDocument, {
-    documentId: docId
+    documentId: docId,
   });
   expect(result).toBeNull();
 });
@@ -128,6 +135,6 @@ test("validation errors", async () => {
   };
 
   await expect(
-    responseClient.mutation(api.index.createDocument, invalidDoc as any)
+    responseClient.mutation(api.index.createDocument, invalidDoc as any),
   ).rejects.toThrow();
-});
\ No newline at end of file
+});
diff --git a/evals/003-mutations/004-cascade_delete/TASK.txt b/evals/003-mutations/004-cascade_delete/TASK.txt
index 42be26c..910386e 100644
--- a/evals/003-mutations/004-cascade_delete/TASK.txt
+++ b/evals/003-mutations/004-cascade_delete/TASK.txt
@@ -19,13 +19,14 @@ export default defineSchema({
 });
 ```
 
-Create a mutation `deleteUserAndDocuments` in `convex/index.ts` that deletes a user and all their documents, returning nothing.
+Create a mutation `deleteUserAndDocuments` in `convex/index.ts` that takes `{ userId: Id<"users"> }`, deletes that user and all their documents, and returns nothing.
 
 The implementation should demonstrate:
 - Proper use of database indexes
 - Parallel operations for better performance
 - Proper error handling
 - Transaction handling to ensure data consistency
+ - Should handle concurrent deletions correctly without leaving orphaned data
 
 Type all arguments and return values appropriately using TypeScript.
 
diff --git a/evals/003-mutations/004-cascade_delete/grader.test.ts b/evals/003-mutations/004-cascade_delete/grader.test.ts
index 282687e..afffdf7 100644
--- a/evals/003-mutations/004-cascade_delete/grader.test.ts
+++ b/evals/003-mutations/004-cascade_delete/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
   listTable,
@@ -20,16 +19,14 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("deletes user with no documents", async () => {
   // Add a test user
-  await addDocuments(responseAdminClient, "users", [{
-    name: "Test User",
-    email: "test@example.com"
-  }]);
+  await addDocuments(responseAdminClient, "users", [
+    {
+      name: "Test User",
+      email: "test@example.com",
+    },
+  ]);
   let users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
   const userId = users.at(-1)!._id;
 
@@ -44,7 +41,7 @@ test("deletes user and all associated documents", async () => {
   // Add test users
   await addDocuments(responseAdminClient, "users", [
     { name: "User 1", email: "user1@example.com" },
-    { name: "User 2", email: "user2@example.com" }
+    { name: "User 2", email: "user2@example.com" },
   ]);
   let users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
   const userId1 = users.at(-2)!._id;
@@ -54,36 +51,46 @@ test("deletes user and all associated documents", async () => {
   await addDocuments(responseAdminClient, "documents", [
     { authorId: userId1, title: "Doc 1", content: "Content 1" },
     { authorId: userId1, title: "Doc 2", content: "Content 2" },
-    { authorId: userId2, title: "Doc 3", content: "Content 3" }
+    { authorId: userId2, title: "Doc 3", content: "Content 3" },
   ]);
 
   // Delete user 2 and their documents
-  await responseClient.mutation(api.index.deleteUserAndDocuments, { userId: userId2 });
+  await responseClient.mutation(api.index.deleteUserAndDocuments, {
+    userId: userId2,
+  });
 
   // Verify only user 1 remains
   users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
   expect(users.at(-1)!._id).toBe(userId1);
 
   // Verify only user 1's documents remain
-  const remainingDocs = (await listTable(responseAdminClient, "documents")) as Doc<"documents">[];
+  const remainingDocs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   expect(remainingDocs).toHaveLength(2);
   expect(remainingDocs[0].authorId).toBe(userId1);
 });
 
 test("handles deletion of user with many documents", async () => {
   // Add a test user
-  await addDocuments(responseAdminClient, "users", [{
-    name: "Test User",
-    email: "test@example.com"
-  }]);
-  const users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  await addDocuments(responseAdminClient, "users", [
+    {
+      name: "Test User",
+      email: "test@example.com",
+    },
+  ]);
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = users.at(-1)!._id;
 
   // Add many documents
   const documents = Array.from({ length: 50 }, (_, i) => ({
     authorId: userId,
     title: `Document ${i}`,
-    content: `Content ${i}`
+    content: `Content ${i}`,
   }));
   await addDocuments(responseAdminClient, "documents", documents);
 
@@ -91,8 +98,14 @@ test("handles deletion of user with many documents", async () => {
   await responseClient.mutation(api.index.deleteUserAndDocuments, { userId });
 
   // Verify all data is deleted
-  const remainingUsers = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
-  const remainingDocs = (await listTable(responseAdminClient, "documents")) as Doc<"documents">[];
+  const remainingUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const remainingDocs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   expect(remainingUsers).toHaveLength(0);
   expect(remainingDocs).toHaveLength(0);
 });
@@ -101,27 +114,69 @@ test("maintains data consistency with concurrent operations", async () => {
   // Add test users
   await addDocuments(responseAdminClient, "users", [
     { name: "User 1", email: "user1@example.com" },
-    { name: "User 2", email: "user2@example.com" }
+    { name: "User 2", email: "user2@example.com" },
   ]);
-  const users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId1 = users.at(-2)!._id;
   const userId2 = users.at(-1)!._id;
 
   // Add documents
   await addDocuments(responseAdminClient, "documents", [
     { authorId: userId1, title: "Doc 1", content: "Content 1" },
-    { authorId: userId2, title: "Doc 2", content: "Content 2" }
+    { authorId: userId2, title: "Doc 2", content: "Content 2" },
   ]);
 
   // Delete both users concurrently
   await Promise.all([
-    responseClient.mutation(api.index.deleteUserAndDocuments, { userId: userId1 }),
-    responseClient.mutation(api.index.deleteUserAndDocuments, { userId: userId2 })
+    responseClient.mutation(api.index.deleteUserAndDocuments, {
+      userId: userId1,
+    }),
+    responseClient.mutation(api.index.deleteUserAndDocuments, {
+      userId: userId2,
+    }),
   ]);
 
   // Verify all data is deleted
-  const remainingUsers = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
-  const remainingDocs = (await listTable(responseAdminClient, "documents")) as Doc<"documents">[];
+  const remainingUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const remainingDocs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
   expect(remainingUsers).toHaveLength(0);
   expect(remainingDocs).toHaveLength(0);
-});
\ No newline at end of file
+});
+
+test("throws when deleting non-existent user id", async () => {
+  const beforeUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const beforeDocs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
+
+  await expect(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    responseClient.mutation(api.index.deleteUserAndDocuments as any, {
+      userId: "nonexistent" as unknown as string,
+    }),
+  ).rejects.toThrow(/not found/i);
+
+  const afterUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const afterDocs = (await listTable(
+    responseAdminClient,
+    "documents",
+  )) as Doc<"documents">[];
+  expect(afterUsers.length).toBe(beforeUsers.length);
+  expect(afterDocs.length).toBe(beforeDocs.length);
+});
diff --git a/evals/003-mutations/005-cascade_delete_nested/TASK.txt b/evals/003-mutations/005-cascade_delete_nested/TASK.txt
index 9405b9b..b55bf66 100644
--- a/evals/003-mutations/005-cascade_delete_nested/TASK.txt
+++ b/evals/003-mutations/005-cascade_delete_nested/TASK.txt
@@ -36,7 +36,7 @@ export default defineSchema({
 
 Implement the following functions in `convex/index.ts`:
 
-2. Create a mutation `deleteUser` that takes a user ID and deletes all dependent records.
+2. Create a mutation `deleteUser` that takes `{ userId: Id<"users"> }` and deletes all dependent records.
    Both records that directly depend on the user, records that depend on those records, etc.
    Return nothing.
 
diff --git a/evals/003-mutations/005-cascade_delete_nested/grader.test.ts b/evals/003-mutations/005-cascade_delete_nested/grader.test.ts
index 3aa56a1..511e0bb 100644
--- a/evals/003-mutations/005-cascade_delete_nested/grader.test.ts
+++ b/evals/003-mutations/005-cascade_delete_nested/grader.test.ts
@@ -3,34 +3,39 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   addDocuments,
   deleteAllDocuments,
   listTable,
 } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 import { beforeEach } from "vitest";
-import { Doc } from "./answer/convex/_generated/dataModel";
+import { Doc, Id } from "./answer/convex/_generated/dataModel";
 
 beforeEach(async () => {
-  await deleteAllDocuments(responseAdminClient, ["users", "posts", "comments", "likes"]);
+  await deleteAllDocuments(responseAdminClient, [
+    "users",
+    "posts",
+    "comments",
+    "likes",
+  ]);
 });
 
 test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("deletes user with no associated data", async () => {
   // Create a test user
-  await addDocuments(responseAdminClient, "users", [{
-    name: "Test User",
-    email: "test@example.com"
-  }]);
-  const users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  await addDocuments(responseAdminClient, "users", [
+    {
+      name: "Test User",
+      email: "test@example.com",
+    },
+  ]);
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const userId = users[0]._id;
 
   // Delete the user
@@ -45,9 +50,12 @@ test("deletes user and all associated content", async () => {
   // Create test users
   await addDocuments(responseAdminClient, "users", [
     { name: "User 1", email: "user1@example.com" },
-    { name: "User 2", email: "user2@example.com" }
+    { name: "User 2", email: "user2@example.com" },
   ]);
-  const users = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
+  const users = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
   const user1Id = users[0]._id;
   const user2Id = users[1]._id;
 
@@ -55,9 +63,12 @@ test("deletes user and all associated content", async () => {
   await addDocuments(responseAdminClient, "posts", [
     { authorId: user1Id, title: "Post 1", content: "Content 1" },
     { authorId: user1Id, title: "Post 2", content: "Content 2" },
-    { authorId: user2Id, title: "Post 3", content: "Content 3" }
+    { authorId: user2Id, title: "Post 3", content: "Content 3" },
   ]);
-  const posts = (await listTable(responseAdminClient, "posts")) as Doc<"posts">[];
+  const posts = (await listTable(
+    responseAdminClient,
+    "posts",
+  )) as Doc<"posts">[];
   const post1Id = posts[0]._id;
   const post2Id = posts[1]._id;
   const post3Id = posts[2]._id;
@@ -68,7 +79,7 @@ test("deletes user and all associated content", async () => {
     { authorId: user2Id, postId: post1Id, content: "Comment 2" },
     { authorId: user1Id, postId: post2Id, content: "Comment 3" },
     { authorId: user2Id, postId: post2Id, content: "Comment 4" },
-    { authorId: user2Id, postId: post3Id, content: "Comment 5" }
+    { authorId: user2Id, postId: post3Id, content: "Comment 5" },
   ]);
 
   // Create likes
@@ -77,17 +88,29 @@ test("deletes user and all associated content", async () => {
     { userId: user2Id, postId: post1Id },
     { userId: user1Id, postId: post2Id },
     { userId: user2Id, postId: post2Id },
-    { userId: user2Id, postId: post3Id }
+    { userId: user2Id, postId: post3Id },
   ]);
 
   // Delete user1
   await responseClient.mutation(api.index.deleteUser, { userId: user1Id });
 
   // Verify user1 and their content is deleted
-  const remainingUsers = (await listTable(responseAdminClient, "users")) as Doc<"users">[];
-  const remainingPosts = (await listTable(responseAdminClient, "posts")) as Doc<"posts">[];
-  const remainingComments = (await listTable(responseAdminClient, "comments")) as Doc<"comments">[];
-  const remainingLikes = (await listTable(responseAdminClient, "likes")) as Doc<"likes">[];
+  const remainingUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const remainingPosts = (await listTable(
+    responseAdminClient,
+    "posts",
+  )) as Doc<"posts">[];
+  const remainingComments = (await listTable(
+    responseAdminClient,
+    "comments",
+  )) as Doc<"comments">[];
+  const remainingLikes = (await listTable(
+    responseAdminClient,
+    "likes",
+  )) as Doc<"likes">[];
 
   expect(remainingUsers).toHaveLength(1);
   expect(remainingUsers.find((user) => user._id === user1Id)).toBeUndefined();
@@ -100,4 +123,51 @@ test("deletes user and all associated content", async () => {
 
   expect(remainingLikes).toHaveLength(1);
   expect(remainingLikes[0].userId).toBe(user2Id);
-});
\ No newline at end of file
+});
+
+test("deleteUser throws for non-existent id", async () => {
+  const beforeUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const beforePosts = (await listTable(
+    responseAdminClient,
+    "posts",
+  )) as Doc<"posts">[];
+  const beforeComments = (await listTable(
+    responseAdminClient,
+    "comments",
+  )) as Doc<"comments">[];
+  const beforeLikes = (await listTable(
+    responseAdminClient,
+    "likes",
+  )) as Doc<"likes">[];
+
+  await expect(
+    responseClient.mutation(api.index.deleteUser, {
+      userId: "nonexistent" as unknown as Id<"users">,
+    }),
+  ).rejects.toThrow(/User not found/i);
+
+  const afterUsers = (await listTable(
+    responseAdminClient,
+    "users",
+  )) as Doc<"users">[];
+  const afterPosts = (await listTable(
+    responseAdminClient,
+    "posts",
+  )) as Doc<"posts">[];
+  const afterComments = (await listTable(
+    responseAdminClient,
+    "comments",
+  )) as Doc<"comments">[];
+  const afterLikes = (await listTable(
+    responseAdminClient,
+    "likes",
+  )) as Doc<"likes">[];
+
+  expect(afterUsers.length).toBe(beforeUsers.length);
+  expect(afterPosts.length).toBe(beforePosts.length);
+  expect(afterComments.length).toBe(beforeComments.length);
+  expect(afterLikes.length).toBe(beforeLikes.length);
+});
diff --git a/evals/003-mutations/006-no_storage/TASK.txt b/evals/003-mutations/006-no_storage/TASK.txt
index 8a1a306..8315e2e 100644
--- a/evals/003-mutations/006-no_storage/TASK.txt
+++ b/evals/003-mutations/006-no_storage/TASK.txt
@@ -15,7 +15,8 @@ export default defineSchema({
 ```
 
 Implement function `uploadFile` and `storeFileMetadata` in `convex/index.ts` that together:
-- Takes text contents and a filename as arguments
+- `uploadFile` takes `{ contents: string, fileName: string }`
+- `storeFileMetadata` takes `{ storageId: Id<"_storage">, fileName: string, size: number }`
 - Stores the file in Convex Storage
 - Creates a database record with the file metadata including:
   - The storage ID from the upload
diff --git a/evals/003-mutations/006-no_storage/grader.test.ts b/evals/003-mutations/006-no_storage/grader.test.ts
index d0e49fd..4c3376b 100644
--- a/evals/003-mutations/006-no_storage/grader.test.ts
+++ b/evals/003-mutations/006-no_storage/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   deleteAllDocuments,
   listTable,
 } from "../../../grader";
@@ -19,10 +18,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("successfully uploads file and stores metadata", async () => {
   const testContent = "Hello, World!";
   const fileName = "test.txt";
@@ -40,8 +35,11 @@ test("successfully uploads file and stores metadata", async () => {
   expect(result.url).toMatch(/^https?:\/\//);
 
   // Verify file metadata in database
-  const files = (await listTable(responseAdminClient, "files")) as Doc<"files">[];
-  const storedFile = files.find(f => f._id === result.fileId);
+  const files = (await listTable(
+    responseAdminClient,
+    "files",
+  )) as Doc<"files">[];
+  const storedFile = files.find((f) => f._id === result.fileId);
   expect(storedFile).toBeDefined();
   expect(storedFile?.fileName).toBe(fileName);
   expect(storedFile?.storageId).toBe(result.storageId);
@@ -58,8 +56,11 @@ test("handles empty file", async () => {
   expect(result).toHaveProperty("storageId");
   expect(result).toHaveProperty("url");
 
-  const files = (await listTable(responseAdminClient, "files")) as Doc<"files">[];
-  const storedFile = files.find(f => f._id === result.fileId);
+  const files = (await listTable(
+    responseAdminClient,
+    "files",
+  )) as Doc<"files">[];
+  const storedFile = files.find((f) => f._id === result.fileId);
   expect(storedFile?.size).toBe(0);
 });
 
@@ -71,8 +72,11 @@ test("handles large file content", async () => {
   });
 
   expect(result).toHaveProperty("fileId");
-  const files = (await listTable(responseAdminClient, "files")) as Doc<"files">[];
-  const storedFile = files.find(f => f._id === result.fileId);
+  const files = (await listTable(
+    responseAdminClient,
+    "files",
+  )) as Doc<"files">[];
+  const storedFile = files.find((f) => f._id === result.fileId);
   expect(storedFile?.size).toBe(1000000);
 });
 
@@ -83,8 +87,11 @@ test("handles special characters in filename", async () => {
     fileName,
   });
 
-  const files = (await listTable(responseAdminClient, "files")) as Doc<"files">[];
-  const storedFile = files.find(f => f._id === result.fileId);
+  const files = (await listTable(
+    responseAdminClient,
+    "files",
+  )) as Doc<"files">[];
+  const storedFile = files.find((f) => f._id === result.fileId);
   expect(storedFile?.fileName).toBe(fileName);
 });
 
@@ -97,18 +104,21 @@ test("maintains consistent metadata", async () => {
   ];
 
   const results = await Promise.all(
-    files.map(async file =>
-      responseClient.action(api.index.uploadFile, file)
-    )
+    files.map(async (file) =>
+      responseClient.action(api.index.uploadFile, file),
+    ),
   );
 
   // Verify all metadata records
-  const storedFiles = (await listTable(responseAdminClient, "files")) as Doc<"files">[];
+  const storedFiles = (await listTable(
+    responseAdminClient,
+    "files",
+  )) as Doc<"files">[];
   expect(storedFiles).toHaveLength(files.length);
 
   for (let i = 0; i < files.length; i++) {
-    const storedFile = storedFiles.find(f => f._id === results[i].fileId);
+    const storedFile = storedFiles.find((f) => f._id === results[i].fileId);
     expect(storedFile?.fileName).toBe(files[i].fileName);
     expect(storedFile?.size).toBe(files[i].contents.length);
   }
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/000-fetch/TASK.txt b/evals/004-actions/000-fetch/TASK.txt
index 3dd6530..de529e8 100644
--- a/evals/004-actions/000-fetch/TASK.txt
+++ b/evals/004-actions/000-fetch/TASK.txt
@@ -1,6 +1,6 @@
 Create a backend function that makes HTTP requests to httpbin.org to demonstrate external API calls from Convex.
 
-Export a single public API function `fetchFromHttpBin` in `convex/index.ts` that:
+Export a single public API action `fetchFromHttpBin` in `convex/index.ts` that:
    - Takes no arguments
    - Makes a GET request to https://httpbin.org/get using the global `fetch` API
    - Parses the JSON response
diff --git a/evals/004-actions/000-fetch/grader.test.ts b/evals/004-actions/000-fetch/grader.test.ts
index 8c728eb..7b0b914 100644
--- a/evals/004-actions/000-fetch/grader.test.ts
+++ b/evals/004-actions/000-fetch/grader.test.ts
@@ -1,14 +1,7 @@
 import { expect, test } from "vitest";
-import {
-  responseClient,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("fetches data from httpbin", async () => {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
   const response = await responseClient.action(api.index.fetchFromHttpBin, {});
@@ -42,4 +35,4 @@ test("returns valid JSON", async () => {
   const jsonString = JSON.stringify(response);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   expect(() => JSON.parse(jsonString)).not.toThrow();
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/001-run_mutation/TASK.txt b/evals/004-actions/001-run_mutation/TASK.txt
index fdceaad..0c1b687 100644
--- a/evals/004-actions/001-run_mutation/TASK.txt
+++ b/evals/004-actions/001-run_mutation/TASK.txt
@@ -16,12 +16,12 @@ export default defineSchema({
 Implement these functions in `convex/index.ts`:
 
 1. Create a mutation `saveFetchResult` that:
-   - Takes a url (string) and data (any) as arguments
+   - Takes arguments:  `{ url: string, data: any }`
    - Inserts a new record into the fetchResults table
    - Returns the ID of the new record
 
 2. Create an action `fetchAndSave` that:
-   - Takes a url string as an argument
+   - Takes arguments:  `{ url: string }`
    - Makes a fetch request to the provided URL
    - Parses the response as JSON
    - It's not important to handle errors here
diff --git a/evals/004-actions/001-run_mutation/answer/convex/schema.ts b/evals/004-actions/001-run_mutation/answer/convex/schema.ts
index 8ea3eef..8518dcb 100644
--- a/evals/004-actions/001-run_mutation/answer/convex/schema.ts
+++ b/evals/004-actions/001-run_mutation/answer/convex/schema.ts
@@ -6,4 +6,4 @@ export default defineSchema({
     url: v.string(),
     data: v.any(),
   }),
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/001-run_mutation/grader.test.ts b/evals/004-actions/001-run_mutation/grader.test.ts
index 1b934d0..e67bf3f 100644
--- a/evals/004-actions/001-run_mutation/grader.test.ts
+++ b/evals/004-actions/001-run_mutation/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   deleteAllDocuments,
   listTable,
 } from "../../../grader";
@@ -19,10 +18,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("saveFetchResult saves data correctly", async () => {
   const testUrl = "https://httpbin.org/json";
   const testData = { test: "data" };
@@ -34,7 +29,10 @@ test("saveFetchResult saves data correctly", async () => {
 
   expect(id).toBeDefined();
 
-  const results = (await listTable(responseAdminClient, "fetchResults")) as Doc<"fetchResults">[];
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchResults",
+  )) as Doc<"fetchResults">[];
   expect(results).toHaveLength(1);
   expect(results[0].url).toBe(testUrl);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -50,39 +48,61 @@ test("fetchAndSave fetches and saves external data", async () => {
 
   expect(id).toBeDefined();
 
-  const results = (await listTable(responseAdminClient, "fetchResults")) as Doc<"fetchResults">[];
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchResults",
+  )) as Doc<"fetchResults">[];
   expect(results).toHaveLength(1);
   expect(results[0].url).toBe(testUrl);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   expect(results[0].data.slideshow).toBeDefined();
 });
 
+test("fetchAndSave then saveFetchResult persists identical URL and data", async () => {
+  const testUrl = "https://httpbin.org/get";
+
+  const id = await responseClient.action(api.index.fetchAndSave, {
+    url: testUrl,
+  });
+  expect(id).toBeDefined();
+
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchResults",
+  )) as Doc<"fetchResults">[];
+  const saved = results.find((r) => r._id === id);
+  expect(saved?.url).toBe(testUrl);
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  expect(saved?.data).toBeDefined();
+});
+
 test("fetchAndSave handles different JSON responses", async () => {
-  const urls = [
-    "https://httpbin.org/json",
-    "https://httpbin.org/get",
-  ];
+  const urls = ["https://httpbin.org/json", "https://httpbin.org/get"];
 
   const ids = await Promise.all(
-    urls.map(async url =>
-      await responseClient.action(api.index.fetchAndSave, { url })
-    )
+    urls.map(
+      async (url) =>
+        await responseClient.action(api.index.fetchAndSave, { url }),
+    ),
   );
 
   expect(ids).toHaveLength(2);
 
-  const results = (await listTable(responseAdminClient, "fetchResults")) as Doc<"fetchResults">[];
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchResults",
+  )) as Doc<"fetchResults">[];
   expect(results).toHaveLength(2);
 
   // Verify each URL was saved
-  const savedUrls = results.map(r => r.url);
+  const savedUrls = results.map((r) => r.url);
   expect(savedUrls).toEqual(expect.arrayContaining(urls));
 
   // Verify we got different data structures back
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  expect(results.some(r => r.data.slideshow)).toBe(true);
+  expect(results.some((r) => r.data.slideshow)).toBe(true);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  expect(results.some(r => r.data.url)).toBe(true);
+  expect(results.some((r) => r.data.url)).toBe(true);
 });
 
 test("handles complex nested JSON data", async () => {
@@ -90,8 +110,11 @@ test("handles complex nested JSON data", async () => {
     url: "https://httpbin.org/json",
   });
 
-  const results = (await listTable(responseAdminClient, "fetchResults")) as Doc<"fetchResults">[];
-  const savedData = results.find(r => r._id === id);
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchResults",
+  )) as Doc<"fetchResults">[];
+  const savedData = results.find((r) => r._id === id);
   expect(savedData).toBeDefined();
 
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -100,4 +123,4 @@ test("handles complex nested JSON data", async () => {
   expect(savedData?.data.slideshow.author).toBeDefined();
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   expect(savedData?.data.slideshow.date).toBeDefined();
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/002-run_query_mutation/TASK.txt b/evals/004-actions/002-run_query_mutation/TASK.txt
index e8a4d7a..22abdce 100644
--- a/evals/004-actions/002-run_query_mutation/TASK.txt
+++ b/evals/004-actions/002-run_query_mutation/TASK.txt
@@ -16,21 +16,21 @@ export default defineSchema({
 Implement these functions in `convex/index.ts`:
 
 1. Create a query `getFetchResult` that:
-   - Takes a url string as argument
+   - Takes arguments:  `{ url: string }`
    - Uses the "by_url" index to look up any existing fetch result
    - Returns the ID of the record if found, null if not found
 
 2. Create a mutation `saveFetchResult` that:
-   - Takes url (string) and data (any) as arguments
-   - Inserts a new record with the current timestamp, or updates an existing record if the URL already exists
-   - Has the handler return type of `Promise<Id<"fetchResults">>`
+   - Takes arguments:  `{ url: string, data: any }`
+   - Inserts a new record, or updates an existing record if the URL already exists (maintaining only one record per URL)
+   - Has the handler return type of `Promise<Id<"fetchRequests">>`
    - Returns the ID of the new record
 
 3. Create an action `fetchIfNeeded` that uses the query and mutation to:
-   - Takes a url string as argument
+   - Takes arguments:  `{ url: string }`
    - Makes a fetch request to the URL, if the result is not already cached in fetchResults.
    - If it isn't cached, write the JSON response to the fetchResults table
-   - Has the handler return type of `Promise<Id<"fetchResults">>`
+   - Has the handler return type of `Promise<Id<"fetchRequests">>`
    - Returns the newly created record ID
 
 Add appropriate ESLint directives for any type handling:
diff --git a/evals/004-actions/002-run_query_mutation/grader.test.ts b/evals/004-actions/002-run_query_mutation/grader.test.ts
index 7c441d1..433f592 100644
--- a/evals/004-actions/002-run_query_mutation/grader.test.ts
+++ b/evals/004-actions/002-run_query_mutation/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   deleteAllDocuments,
   listTable,
 } from "../../../grader";
@@ -19,10 +18,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("fetchIfNeeded caches new requests", async () => {
   const testUrl = "https://httpbin.org/json";
 
@@ -33,7 +28,10 @@ test("fetchIfNeeded caches new requests", async () => {
   expect(id1).toBeDefined();
 
   // Check the cached data
-  const results = (await listTable(responseAdminClient, "fetchRequests")) as Doc<"fetchRequests">[];
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchRequests",
+  )) as Doc<"fetchRequests">[];
   expect(results).toHaveLength(1);
   expect(results[0].url).toBe(testUrl);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -60,25 +58,27 @@ test("fetchIfNeeded reuses cached results", async () => {
 });
 
 test("fetchIfNeeded handles different URLs separately", async () => {
-  const urls = [
-    "https://httpbin.org/json",
-    "https://httpbin.org/get",
-  ];
+  const urls = ["https://httpbin.org/json", "https://httpbin.org/get"];
 
   // Fetch both URLs
   const ids = await Promise.all(
-    urls.map(async url => responseClient.action(api.index.fetchIfNeeded, { url }))
+    urls.map(async (url) =>
+      responseClient.action(api.index.fetchIfNeeded, { url }),
+    ),
   );
 
   // Should get different IDs
   expect(ids[0]).not.toBe(ids[1]);
 
   // Should have two cached results
-  const results = (await listTable(responseAdminClient, "fetchRequests")) as Doc<"fetchRequests">[];
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchRequests",
+  )) as Doc<"fetchRequests">[];
   expect(results).toHaveLength(2);
 
   // Verify different data structures were cached
-  const resultsByUrl = new Map(results.map(r => [r.url, r]));
+  const resultsByUrl = new Map(results.map((r) => [r.url, r]));
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   expect(resultsByUrl.get(urls[0])?.data.slideshow).toBeDefined();
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -107,10 +107,66 @@ test("handles invalid URLs appropriately", async () => {
   const invalidUrl = "https://invalid-url-that-does-not-exist.example.com";
 
   await expect(
-    responseClient.action(api.index.fetchIfNeeded, { url: invalidUrl })
+    responseClient.action(api.index.fetchIfNeeded, { url: invalidUrl }),
   ).rejects.toThrow();
 
   // Should not cache failed requests
   const results = await listTable(responseAdminClient, "fetchRequests");
   expect(results).toHaveLength(0);
-});
\ No newline at end of file
+});
+
+test("getFetchResult returns null when URL not cached", async () => {
+  // @ts-ignore
+  const missing = await responseClient.query(api.index.getFetchResult, {
+    url: "https://not-cached.example.com",
+  });
+  expect(missing).toBeNull();
+});
+
+test("saveFetchResult updates existing record for same URL", async () => {
+  const testUrl = "https://httpbin.org/json";
+  const firstData = { v: 1 } as const;
+  const secondData = { v: 2 } as const;
+
+  // @ts-ignore
+  const id1 = await responseClient.mutation(api.index.saveFetchResult, {
+    url: testUrl,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: firstData,
+  });
+  expect(id1).toBeDefined();
+
+  // @ts-ignore
+  const id2 = await responseClient.mutation(api.index.saveFetchResult, {
+    url: testUrl,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: secondData,
+  });
+  expect(id2).toBeDefined();
+
+  const results = (await listTable(
+    responseAdminClient,
+    "fetchRequests",
+  )) as Doc<"fetchRequests">[];
+  expect(results).toHaveLength(1);
+  expect(results[0].url).toBe(testUrl);
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  expect(results[0].data.v).toBe(2);
+});
+
+test("getFetchResult returns ID when URL is cached", async () => {
+  const testUrl = "https://httpbin.org/get";
+
+  // Seed cache via action
+  const createdId = await responseClient.action(api.index.fetchIfNeeded, {
+    url: testUrl,
+  });
+  expect(createdId).toBeDefined();
+
+  // Query should return same ID
+  // @ts-ignore
+  const queriedId = await responseClient.query(api.index.getFetchResult, {
+    url: testUrl,
+  });
+  expect(queriedId).toBe(createdId);
+});
diff --git a/evals/004-actions/003-mutation_schedule_action/TASK.txt b/evals/004-actions/003-mutation_schedule_action/TASK.txt
index 19d2fad..33cc806 100644
--- a/evals/004-actions/003-mutation_schedule_action/TASK.txt
+++ b/evals/004-actions/003-mutation_schedule_action/TASK.txt
@@ -18,7 +18,7 @@ export default defineSchema({
 Implement these functions in `convex/index.ts`:
 
 1. Create a mutation `initiateRequest` that:
-   - Takes a URL as argument
+   - Takes arguments:  `{ url: string }`
    - Checks if the URL already exists in the requests table
    - If it does, return the existing record ID
    - If it doesn't, inserts a pending record into requests table
@@ -26,12 +26,17 @@ Implement these functions in `convex/index.ts`:
    - Returns the ID of the new record
 
 2. Create an internal action `performHttpbinFetch` that:
-   - Takes a URL and request ID as arguments
+   - Takes arguments:  `{ url: string, requestId: Id<"requests"> }`
    - Makes a POST request to the URL
-   - Updates the requests record with an internal function `updateRequest`
-     - Pass the completed status and timestamp as parameters
+   - Updates the requests record with an exported mutation `updateRequest`
+     - Define `updateRequest` to take arguments: `{ requestId: Id<"requests">, status: "completed", completedAt: number }`
+     - It should set the status to "completed" and set `completedAt` to the provided timestamp
    - Returns nothing
 
+Behavioral expectations:
+- Multiple concurrent `initiateRequest` calls for the same URL must return the same existing request ID and not create duplicates.
+- Requests that fail the POST should not transition to completed; the request should remain `pending` and `completedAt` should be unset.
+
 The implementation should demonstrate:
 - Proper scheduling of async work using actions
 - Proper state management in the database
diff --git a/evals/004-actions/003-mutation_schedule_action/grader.test.ts b/evals/004-actions/003-mutation_schedule_action/grader.test.ts
index 384e5e9..88f883d 100644
--- a/evals/004-actions/003-mutation_schedule_action/grader.test.ts
+++ b/evals/004-actions/003-mutation_schedule_action/grader.test.ts
@@ -3,7 +3,6 @@ import {
   responseAdminClient,
   responseClient,
   compareSchema,
-  compareFunctionSpec,
   deleteAllDocuments,
   listTable,
 } from "../../../grader";
@@ -19,10 +18,6 @@ test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("initiateRequest creates new request record", async () => {
   const testUrl = "https://httpbin.org/post";
 
@@ -32,7 +27,10 @@ test("initiateRequest creates new request record", async () => {
 
   expect(requestId).toBeDefined();
 
-  const requests = (await listTable(responseAdminClient, "requests")) as Doc<"requests">[];
+  const requests = (await listTable(
+    responseAdminClient,
+    "requests",
+  )) as Doc<"requests">[];
   expect(requests).toHaveLength(1);
 
   const request = requests[0];
@@ -71,14 +69,17 @@ test("request eventually completes", async () => {
 
   const start = Date.now();
   while (Date.now() - start < 2000) {
-    const requests = (await listTable(responseAdminClient, "requests")) as Doc<"requests">[];
-    const request = requests.find(r => r._id === requestId);
+    const requests = (await listTable(
+      responseAdminClient,
+      "requests",
+    )) as Doc<"requests">[];
+    const request = requests.find((r) => r._id === requestId);
     expect(request).toBeDefined();
     if (request?.status === "completed") {
       expect(request?.completedAt).toBeTypeOf("number");
       break;
     }
-    await new Promise(resolve => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 50));
   }
 });
 
@@ -91,19 +92,25 @@ test("handles multiple concurrent requests", async () => {
 
   // Initiate multiple requests concurrently
   const requestIds = await Promise.all(
-    urls.map(async url => await responseClient.mutation(api.index.initiateRequest, { url }))
+    urls.map(
+      async (url) =>
+        await responseClient.mutation(api.index.initiateRequest, { url }),
+    ),
   );
 
   expect(new Set(requestIds).size).toBe(urls.length);
 
   // Wait for requests to complete
-  await new Promise(resolve => setTimeout(resolve, 2000));
+  await new Promise((resolve) => setTimeout(resolve, 2000));
 
-  const requests = (await listTable(responseAdminClient, "requests")) as Doc<"requests">[];
+  const requests = (await listTable(
+    responseAdminClient,
+    "requests",
+  )) as Doc<"requests">[];
   expect(requests).toHaveLength(urls.length);
 
   // Verify all requests completed
-  const completedRequests = requests.filter(r => r.status === "completed");
+  const completedRequests = requests.filter((r) => r.status === "completed");
   expect(completedRequests).toHaveLength(urls.length);
 
   // Verify timestamps
@@ -112,6 +119,26 @@ test("handles multiple concurrent requests", async () => {
   }
 });
 
+test("initiateRequest does not duplicate async work for same URL concurrently", async () => {
+  const testUrl = "https://httpbin.org/post";
+
+  const ids = await Promise.all([
+    responseClient.mutation(api.index.initiateRequest, { url: testUrl }),
+    responseClient.mutation(api.index.initiateRequest, { url: testUrl }),
+    responseClient.mutation(api.index.initiateRequest, { url: testUrl }),
+  ]);
+
+  // All should be same id
+  expect(new Set(ids).size).toBe(1);
+
+  // Only one request record
+  const records = (await listTable(
+    responseAdminClient,
+    "requests",
+  )) as Doc<"requests">[];
+  expect(records).toHaveLength(1);
+});
+
 test("handles request failures gracefully", async () => {
   const invalidUrl = "https://invalid-url-that-will-fail.example.com";
 
@@ -122,13 +149,16 @@ test("handles request failures gracefully", async () => {
   expect(requestId).toBeDefined();
 
   // Wait for potential completion
-  await new Promise(resolve => setTimeout(resolve, 2000));
+  await new Promise((resolve) => setTimeout(resolve, 2000));
 
-  const requests = (await listTable(responseAdminClient, "requests")) as Doc<"requests">[];
-  const request = requests.find(r => r._id === requestId);
+  const requests = (await listTable(
+    responseAdminClient,
+    "requests",
+  )) as Doc<"requests">[];
+  const request = requests.find((r) => r._id === requestId);
 
   expect(request).toBeDefined();
   // Request should still be in pending state since the action failed
   expect(request?.status).toBe("pending");
   expect(request?.completedAt).toBeUndefined();
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/004-storage/TASK.txt b/evals/004-actions/004-storage/TASK.txt
index 53a6684..c56be05 100644
--- a/evals/004-actions/004-storage/TASK.txt
+++ b/evals/004-actions/004-storage/TASK.txt
@@ -3,15 +3,16 @@ Create a backend that interacts with Convex file storage to write and read text
 Implement these functions in `convex/index.ts`:
 
 1. Create an action `writeTextToStorage` that:
-   - Takes text (string) as argument
+   - Takes arguments:  `{ text: string }`
    - Uploads the data to Convex storage
    - Returns an object containing:
      - storageId: The storage ID
      - url: The public URL of the stored file
 
 2. Create an action `readTextFromStorage` that:
-   - Takes storageId (string) as argument
+   - Takes arguments:  `{ storageId: string }`
    - Retrieves the data from storage and returns it as a string
+   - If the storageId is invalid or the file doesn't exist, throw an error
 
 The implementation should demonstrate:
 - Proper use of Convex storage APIs
diff --git a/evals/004-actions/004-storage/grader.test.ts b/evals/004-actions/004-storage/grader.test.ts
index abf3b50..9e65164 100644
--- a/evals/004-actions/004-storage/grader.test.ts
+++ b/evals/004-actions/004-storage/grader.test.ts
@@ -1,26 +1,26 @@
 import { expect, test } from "vitest";
-import {
-  responseClient,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
+import { Id } from "./answer/convex/_generated/dataModel";
 
 test("writes and reads text content", async () => {
   const testText = "Hello, world!";
 
   // Write the text to storage
-  const { storageId } = await responseClient.action(api.index.writeTextToStorage, {
-    text: testText,
-  });
+  const { storageId } = await responseClient.action(
+    api.index.writeTextToStorage,
+    {
+      text: testText,
+    },
+  );
 
   // Read the text back
-  const retrievedText = await responseClient.action(api.index.readTextFromStorage, {
-    storageId,
-  });
+  const retrievedText = await responseClient.action(
+    api.index.readTextFromStorage,
+    {
+      storageId,
+    },
+  );
 
   expect(retrievedText).toBe(testText);
 });
@@ -28,13 +28,19 @@ test("writes and reads text content", async () => {
 test("handles empty text", async () => {
   const emptyText = "";
 
-  const { storageId } = await responseClient.action(api.index.writeTextToStorage, {
-    text: emptyText,
-  });
+  const { storageId } = await responseClient.action(
+    api.index.writeTextToStorage,
+    {
+      text: emptyText,
+    },
+  );
 
-  const retrievedText = await responseClient.action(api.index.readTextFromStorage, {
-    storageId,
-  });
+  const retrievedText = await responseClient.action(
+    api.index.readTextFromStorage,
+    {
+      storageId,
+    },
+  );
 
   expect(retrievedText).toBe(emptyText);
 });
@@ -42,13 +48,19 @@ test("handles empty text", async () => {
 test("handles long text content", async () => {
   const longText = "a".repeat(1000) + "b".repeat(1000) + "c".repeat(1000);
 
-  const { storageId } = await responseClient.action(api.index.writeTextToStorage, {
-    text: longText,
-  });
+  const { storageId } = await responseClient.action(
+    api.index.writeTextToStorage,
+    {
+      text: longText,
+    },
+  );
 
-  const retrievedText = await responseClient.action(api.index.readTextFromStorage, {
-    storageId,
-  });
+  const retrievedText = await responseClient.action(
+    api.index.readTextFromStorage,
+    {
+      storageId,
+    },
+  );
 
   expect(retrievedText).toBe(longText);
   expect(retrievedText.length).toBe(3000);
@@ -57,13 +69,19 @@ test("handles long text content", async () => {
 test("handles special characters", async () => {
   const specialChars = "!@#$%^&*()_+-=[]{}|;:'\",.<>/?\n\t";
 
-  const { storageId } = await responseClient.action(api.index.writeTextToStorage, {
-    text: specialChars,
-  });
+  const { storageId } = await responseClient.action(
+    api.index.writeTextToStorage,
+    {
+      text: specialChars,
+    },
+  );
 
-  const retrievedText = await responseClient.action(api.index.readTextFromStorage, {
-    storageId,
-  });
+  const retrievedText = await responseClient.action(
+    api.index.readTextFromStorage,
+    {
+      storageId,
+    },
+  );
 
   expect(retrievedText).toBe(specialChars);
 });
@@ -78,16 +96,30 @@ test("returns valid URL", async () => {
   expect(url).toMatch(/^https?:\/\//);
 });
 
+test("readTextFromStorage throws for invalid storageId", async () => {
+  await expect(
+    responseClient.action(api.index.readTextFromStorage, {
+      storageId: "invalid" as unknown as Id<"_storage">,
+    }),
+  ).rejects.toThrow();
+});
+
 test("handles Unicode characters", async () => {
   const unicodeText = "Hello, 世界! 👋 🌍";
 
-  const { storageId } = await responseClient.action(api.index.writeTextToStorage, {
-    text: unicodeText,
-  });
+  const { storageId } = await responseClient.action(
+    api.index.writeTextToStorage,
+    {
+      text: unicodeText,
+    },
+  );
 
-  const retrievedText = await responseClient.action(api.index.readTextFromStorage, {
-    storageId,
-  });
+  const retrievedText = await responseClient.action(
+    api.index.readTextFromStorage,
+    {
+      storageId,
+    },
+  );
 
   expect(retrievedText).toBe(unicodeText);
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/005-storage_http_action/TASK.txt b/evals/004-actions/005-storage_http_action/TASK.txt
index 50f211c..05c5fd4 100644
--- a/evals/004-actions/005-storage_http_action/TASK.txt
+++ b/evals/004-actions/005-storage_http_action/TASK.txt
@@ -3,12 +3,14 @@ Create a backend that receives HTTP requests and stores the request body content
 Implement these functions in `convex/http.ts`:
 
 1. Create an HTTP action `/store` that:
+   - Takes the raw request body
    - Stores the request body in Convex storage
    - Returns a JSON response containing:
      - storageId: The storage ID string
      - url: The public URL of the stored file
+   - Only accept POST requests; other methods should return 404
 
-2. Create a query `getSiteURL` that takes no arguments and returns `process.env.CONVEX_SITE_URL!` (string)
+2. Create a query `getSiteURL` that takes no arguments (empty object `{}`) and returns `process.env.CONVEX_SITE_URL!` (string)
 
 No schema is required since this demo only uses file storage.
 
diff --git a/evals/004-actions/005-storage_http_action/grader.test.ts b/evals/004-actions/005-storage_http_action/grader.test.ts
index 9e7aaf6..53d70a4 100644
--- a/evals/004-actions/005-storage_http_action/grader.test.ts
+++ b/evals/004-actions/005-storage_http_action/grader.test.ts
@@ -1,13 +1,7 @@
 import { expect, test } from "vitest";
-import {
-  compareFunctionSpec,
-  responseAdminClient,
-} from "../../../grader";
+import { responseAdminClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 import { getSiteURL } from "./answer/convex/http";
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
 
 async function getStoreURL(): Promise<string> {
   const siteURL = await responseAdminClient.query(api.http.getSiteURL, {});
@@ -110,4 +104,4 @@ test("rejects non-POST requests", async () => {
 
     expect(response.status).toBe(404);
   }
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/006-node/TASK.txt b/evals/004-actions/006-node/TASK.txt
index bf744c7..6442cc8 100644
--- a/evals/004-actions/006-node/TASK.txt
+++ b/evals/004-actions/006-node/TASK.txt
@@ -3,13 +3,17 @@ Create a backend that demonstrates using the "node" runtime within a Convex acti
 Implement this function in `convex/index.ts`:
 
 1. Create an action `processWithNode` that:
-   - Takes data (string) as argument
+   - Takes arguments:  `{ data: string }`
    - Uses Node.js 'crypto' module to generate a hash of the input
    - Uses Node.js 'path' module to manipulate file paths
    - Returns an object containing:
      - hash: The SHA-256 hash of the input string
      - normalizedPath: A normalized version of "/some/test/path"
 
+Behavioral expectations:
+- The hash must be a lowercase hexadecimal SHA-256 string of length 64.
+- `normalizedPath` must equal "/some/test/path" consistently for all inputs.
+
 This function should assume it needs libraries not available with the default Convex runtime.
 Create only the `convex/index.ts` and `package.json` files. Do not generate any other files.
 No schema is required for this demo since it doesn't use the database.
diff --git a/evals/004-actions/006-node/grader.test.ts b/evals/004-actions/006-node/grader.test.ts
index 7a4e4ce..dbed3e0 100644
--- a/evals/004-actions/006-node/grader.test.ts
+++ b/evals/004-actions/006-node/grader.test.ts
@@ -1,14 +1,7 @@
 import { expect, test } from "vitest";
-import {
-  responseClient,
-  compareFunctionSpec,
-} from "../../../grader";
+import { responseClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("processes string input correctly", async () => {
   const result = await responseClient.action(api.index.processWithNode, {
     data: "test string",
@@ -22,17 +15,19 @@ test("processes string input correctly", async () => {
 
 test("generates consistent hashes", async () => {
   const input = "hello world";
-  
+
   const result1 = await responseClient.action(api.index.processWithNode, {
     data: input,
   });
-  
+
   const result2 = await responseClient.action(api.index.processWithNode, {
     data: input,
   });
 
   expect(result1.hash).toBe(result2.hash);
-  expect(result1.hash).toBe("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");
+  expect(result1.hash).toBe(
+    "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+  );
 });
 
 test("handles empty string input", async () => {
@@ -40,13 +35,15 @@ test("handles empty string input", async () => {
     data: "",
   });
 
-  expect(result.hash).toBe("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); // Empty string SHA-256
+  expect(result.hash).toBe(
+    "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  ); // Empty string SHA-256
   expect(result.normalizedPath).toBe("/some/test/path");
 });
 
 test("handles long string input", async () => {
   const longString = "a".repeat(1000);
-  
+
   const result = await responseClient.action(api.index.processWithNode, {
     data: longString,
   });
@@ -57,7 +54,7 @@ test("handles long string input", async () => {
 
 test("handles special characters", async () => {
   const specialChars = "!@#$%^&*()_+-=[]{}|;:'\",.<>/?";
-  
+
   const result = await responseClient.action(api.index.processWithNode, {
     data: specialChars,
   });
@@ -84,4 +81,4 @@ test("normalizedPath is consistent", async () => {
   for (const result of results) {
     expect(result.normalizedPath).toBe("/some/test/path");
   }
-});
\ No newline at end of file
+});
diff --git a/evals/004-actions/007-http_action_routing/TASK.txt b/evals/004-actions/007-http_action_routing/TASK.txt
index 7da93c0..e5403e8 100644
--- a/evals/004-actions/007-http_action_routing/TASK.txt
+++ b/evals/004-actions/007-http_action_routing/TASK.txt
@@ -7,9 +7,9 @@ Implement these HTTP handlers in `convex/http.ts`:
 3. Create a PUT endpoint `/putBaz` that:
 4. Create a GET handler for all paths under `/api/*` that:
 
-They should all return a JSON response: `{ ok: true }` and only accept the specified methods.
+They should all return a JSON response: `{ ok: true }` and only accept the specified methods (reject other methods with 404). Non-existent paths should return 404.
 
-Also create a query `getSiteURL` that takes no arguments and returns `process.env.CONVEX_SITE_URL!`.
+Also create a query `getSiteURL` that takes no arguments (empty object `{}`) and returns `process.env.CONVEX_SITE_URL!`.
 This will require the @types/node npm dev dependency.
 
 Create only the `convex/http.ts` and `package.json` files. Do not generate any other files.
diff --git a/evals/004-actions/007-http_action_routing/grader.test.ts b/evals/004-actions/007-http_action_routing/grader.test.ts
index 2802e62..6302c28 100644
--- a/evals/004-actions/007-http_action_routing/grader.test.ts
+++ b/evals/004-actions/007-http_action_routing/grader.test.ts
@@ -1,14 +1,7 @@
 import { expect, test } from "vitest";
-import {
-  compareFunctionSpec,
-  responseAdminClient,
-} from "../../../grader";
+import { responseAdminClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 async function getBaseURL(): Promise<string> {
   return await responseAdminClient.query(api.http.getSiteURL, {});
 }
@@ -55,11 +48,7 @@ test("PUT /putBaz returns correct response", async () => {
 
 test("GET /api/* wildcard returns correct response", async () => {
   const baseUrl = await getBaseURL();
-  const testPaths = [
-    "/api/test",
-    "/api/foo/bar",
-    "/api/deeply/nested/path",
-  ];
+  const testPaths = ["/api/test", "/api/foo/bar", "/api/deeply/nested/path"];
 
   for (const path of testPaths) {
     const response = await fetch(`${baseUrl}${path}`);
@@ -97,7 +86,7 @@ test("non-existent paths return 404", async () => {
     "/nonexistent",
     "/getFooBar",
     "/post",
-    "/api",  // without trailing path
+    "/api", // without trailing path
   ];
 
   for (const path of nonExistentPaths) {
@@ -122,4 +111,4 @@ test("handles special characters in API paths", async () => {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     expect(data.ok).toBe(true);
   }
-});
\ No newline at end of file
+});
diff --git a/evals/005-idioms/000-internal_fns/TASK.txt b/evals/005-idioms/000-internal_fns/TASK.txt
index 6e6635e..1f1644f 100644
--- a/evals/005-idioms/000-internal_fns/TASK.txt
+++ b/evals/005-idioms/000-internal_fns/TASK.txt
@@ -8,7 +8,7 @@ Implement these functions in `convex/index.ts`:
    - Should be accessible to client applications
 
 2. Create a mutation `logClientEvent` that:
-   - Takes eventName (string) and data (any) as arguments
+   - Takes arguments:  `{ eventName: string, data: any }`
    - Logs the event to the console
    - Returns the current timestamp
    - Should be accessible to client applications
@@ -18,16 +18,20 @@ Implement these functions in `convex/index.ts`:
    - Is meant to be run from the dashboard
    - Logs "Running daily cleanup" to console
    - Does nothing else
-   - Returns nothing
+   - Returns nothing (use `return null`)
    - Should NOT be accessible to clients
 
 4. Create a mutation `resetCounter` that:
    - Takes no arguments
    - Is meant to be called from CLI or scheduled asynchronously from another function
    - Does nothing but logs "Resetting counter" to console
-   - Returns nothing
+   - Returns nothing (use `return null`)
    - Should NOT be accessible to clients
 
+Function visibility and access expectations:
+- `getPublicStats` and `logClientEvent` must be public and callable by regular clients.
+- `dailyCleanup` (action) and `resetCounter` (mutation) must be internal-only and not callable by regular clients; they should be callable by admin clients.
+
 
 Create only the `convex/index.ts` and `package.json` files. Do not generate any other files.
 No schema is required since this demo doesn't use the database.
\ No newline at end of file
diff --git a/evals/005-idioms/000-internal_fns/grader.test.ts b/evals/005-idioms/000-internal_fns/grader.test.ts
index c4e0013..d76263a 100644
--- a/evals/005-idioms/000-internal_fns/grader.test.ts
+++ b/evals/005-idioms/000-internal_fns/grader.test.ts
@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, test, vi } from "vitest";
 import {
   responseClient,
   responseAdminClient,
@@ -6,10 +6,6 @@ import {
 } from "../../../grader";
 import { api, internal } from "./answer/convex/_generated/api";
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("getPublicStats returns correct static data", async () => {
   const stats = await responseClient.query(api.index.getPublicStats, {});
 
@@ -22,7 +18,7 @@ test("getPublicStats returns correct static data", async () => {
 test("getPublicStats is accessible to clients", async () => {
   // Should not throw
   await expect(
-    responseClient.query(api.index.getPublicStats, {})
+    responseClient.query(api.index.getPublicStats, {}),
   ).resolves.toBeDefined();
 });
 
@@ -48,58 +44,99 @@ test("logClientEvent handles different data types", async () => {
   ];
 
   for (const testCase of testCases) {
-    const timestamp = await responseClient.mutation(api.index.logClientEvent, testCase);
+    const timestamp = await responseClient.mutation(
+      api.index.logClientEvent,
+      testCase,
+    );
     expect(typeof timestamp).toBe("number");
   }
 });
 
 test("dailyCleanup is not accessible to regular clients", async () => {
-  // @ts-expect-error - Testing that this function is not accessible
-  await expect(responseClient.action(api.index.dailyCleanup)).rejects.toThrow();
+  await expect(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    responseClient.action(internal.index.dailyCleanup as any, {}),
+  ).rejects.toThrow();
 });
 
 test("dailyCleanup is accessible to admin clients", async () => {
   // Should not throw
   await expect(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    responseAdminClient.action((internal.index.dailyCleanup as any), {})
+    responseAdminClient.action(internal.index.dailyCleanup as any, {}),
   ).resolves.toBeNull();
 });
 
 test("resetCounter is not accessible to regular clients", async () => {
-  // @ts-expect-error - Testing that this function is not accessible
-  await expect(responseClient.mutation(api.index.resetCounter)).rejects.toThrow();
+  await expect(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    responseClient.mutation(internal.index.resetCounter as any, {}),
+  ).rejects.toThrow();
 });
 
 test("resetCounter is accessible to admin clients", async () => {
   // Should not throw
   await expect(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    responseAdminClient.mutation((internal.index.resetCounter as any), {})
+    responseAdminClient.mutation(internal.index.resetCounter as any, {}),
   ).resolves.toBeNull();
 });
 
+test("dailyCleanup and resetCounter log expected messages", async () => {
+  const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await responseAdminClient.action(internal.index.dailyCleanup as any, {});
+  const loggedCleanup = spy.mock.calls.some((callArgs) =>
+    callArgs.some(
+      (arg) => typeof arg === "string" && arg.includes("Running daily cleanup"),
+    ),
+  );
+  expect(loggedCleanup).toBe(true);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await responseAdminClient.mutation(internal.index.resetCounter as any, {});
+  const loggedReset = spy.mock.calls.some((callArgs) =>
+    callArgs.some(
+      (arg) => typeof arg === "string" && arg.includes("Resetting counter"),
+    ),
+  );
+  expect(loggedReset).toBe(true);
+
+  spy.mockRestore();
+});
+
 test("function visibility is correctly set", async () => {
   // Public functions should be accessible
-  await expect(responseClient.query(api.index.getPublicStats, {})).resolves.toBeDefined();
+  await expect(
+    responseClient.query(api.index.getPublicStats, {}),
+  ).resolves.toBeDefined();
   await expect(
     responseClient.mutation(api.index.logClientEvent, {
       eventName: "test",
       data: null,
-    })
+    }),
   ).resolves.toBeDefined();
 
   // Internal functions should not be accessible to regular clients
-  // @ts-expect-error - Testing that these functions are not accessible
-  await expect(responseClient.action(api.index.dailyCleanup)).rejects.toThrow();
-  // @ts-expect-error - Testing that these functions are not accessible
-  await expect(responseClient.mutation(api.index.resetCounter)).rejects.toThrow();
+  await expect(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    responseClient.action(internal.index.dailyCleanup as any, {}),
+  ).rejects.toThrow();
+  await expect(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    responseClient.mutation(internal.index.resetCounter as any, {}),
+  ).rejects.toThrow();
 
   // But should be accessible to admin clients
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await expect(responseAdminClient.action((internal.index.dailyCleanup as any), {})).resolves.toBeNull();
+  await expect(
+    responseAdminClient.action(internal.index.dailyCleanup as any, {}),
+  ).resolves.toBeNull();
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await expect(responseAdminClient.mutation((internal.index.resetCounter as any), {})).resolves.toBeNull();
+  await expect(
+    responseAdminClient.mutation(internal.index.resetCounter as any, {}),
+  ).resolves.toBeNull();
 });
 
 test("getPublicStats returns consistent data", async () => {
@@ -113,4 +150,4 @@ test("getPublicStats returns consistent data", async () => {
   for (const result of rest) {
     expect(result).toEqual(first);
   }
-});
\ No newline at end of file
+});
diff --git a/evals/005-idioms/001-file_organization/TASK.txt b/evals/005-idioms/001-file_organization/TASK.txt
index 205d863..3da8dfe 100644
--- a/evals/005-idioms/001-file_organization/TASK.txt
+++ b/evals/005-idioms/001-file_organization/TASK.txt
@@ -17,3 +17,20 @@ Each set of operations should be organized into a separate file.
 For each table, export a public function called `get`, `create`, and `destroy`.
 Only the `get` and `create` functions return anything (the full document, or the id of the created document).
 You don't need to specify a returns validator for any function.
+
+Error behavior for missing documents:
+- For `users.get`, if the user does not exist, throw an error with the message "User not found".
+- For `posts.get`, if the post does not exist, throw an error with the message "Post not found".
+- `destroy` should not return a value.
+
+Function argument specifications:
+
+- `convex/users.ts`:
+  - `get`: Takes arguments:  `{ id: Id<"users"> }`
+  - `create`: Takes arguments:  `{ name: string, email: string }`
+  - `destroy`: Takes arguments:  `{ id: Id<"users"> }`
+
+- `convex/posts.ts`:
+  - `get`: Takes arguments:  `{ id: Id<"posts"> }`
+  - `create`: Takes arguments:  `{ userId: Id<"users">, title: string, content: string }`
+  - `destroy`: Takes arguments:  `{ id: Id<"posts"> }`
diff --git a/evals/005-idioms/001-file_organization/grader.test.ts b/evals/005-idioms/001-file_organization/grader.test.ts
index a9d83c3..0fc40d7 100644
--- a/evals/005-idioms/001-file_organization/grader.test.ts
+++ b/evals/005-idioms/001-file_organization/grader.test.ts
@@ -1,19 +1,6 @@
 import { expect, test } from "vitest";
-import {
-  responseClient,
-  compareFunctionSpec,
-  compareSchema,
-} from "../../../grader";
+import { responseClient } from "../../../grader";
 import { api } from "./answer/convex/_generated/api";
-import { Id } from "./answer/convex/_generated/dataModel";
-
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
-test("compare schema", async ({ skip }) => {
-  await compareSchema(skip);
-});
 
 test("can create and get user", async () => {
   const userData = {
@@ -57,7 +44,7 @@ test("can delete user", async () => {
   await responseClient.mutation(api.users.destroy, { id: userId });
 
   await expect(
-    responseClient.query(api.users.get, { id: userId })
+    responseClient.query(api.users.get, { id: userId }),
   ).rejects.toThrow("User not found");
 });
 
@@ -76,7 +63,7 @@ test("can delete post", async () => {
   await responseClient.mutation(api.posts.destroy, { id: postId });
 
   await expect(
-    responseClient.query(api.posts.get, { id: postId })
+    responseClient.query(api.posts.get, { id: postId }),
   ).rejects.toThrow("Post not found");
 });
 
@@ -114,7 +101,7 @@ test("schema validations work", async () => {
     responseClient.mutation(api.users.create, {
       name: 123, // Should be string
       email: "test@example.com",
-    } as any)
+    } as any),
   ).rejects.toThrow();
   /* eslint-enable */
 
@@ -130,7 +117,7 @@ test("schema validations work", async () => {
       userId,
       title: 123, // Should be string
       content: "Valid content",
-    } as any)
+    } as any),
   ).rejects.toThrow();
   /* eslint-enable */
-});
\ No newline at end of file
+});
diff --git a/evals/005-idioms/002-batch_queries/TASK.txt b/evals/005-idioms/002-batch_queries/TASK.txt
index 8e734fd..a22488d 100644
--- a/evals/005-idioms/002-batch_queries/TASK.txt
+++ b/evals/005-idioms/002-batch_queries/TASK.txt
@@ -22,17 +22,18 @@ Implement these functions:
 
 1. In convex/users.ts:
    - Create an internal query `getUserByEmail` that:
-     - Takes email (string) as argument
+     - Takes arguments:  `{ email: string }`
      - Returns the user document or null
 
 2. In convex/posts.ts:
    - Create an internal query `getPostsByUserId` that:
-     - Takes userId (Id<"users">) as argument
-     - Returns array of post documents
+     - Takes arguments:  `{ userId: Id<"users"> }`
+     - Returns array of post documents (empty array if none)
    - Create a query `getUserAndPosts` that:
-     - Takes an argument of an email.
+     - Takes arguments:  `{ email: string }`
      - Fetches the user and their posts
      - Returns an object with the user and their posts
+     - If the user does not exist for the given email, return `{ user: null, posts: [] }`
 
 Don't specify returns validators for query/mutations.
 Create any helper functions you need to avoid duplicating code.
diff --git a/evals/005-idioms/002-batch_queries/grader.test.ts b/evals/005-idioms/002-batch_queries/grader.test.ts
index f391ca4..c7677c2 100644
--- a/evals/005-idioms/002-batch_queries/grader.test.ts
+++ b/evals/005-idioms/002-batch_queries/grader.test.ts
@@ -15,10 +15,6 @@ beforeEach(async () => {
   await deleteAllDocuments(responseAdminClient, ["users", "posts"]);
 });
 
-test("compare function spec", async ({ skip }) => {
-  await compareFunctionSpec(skip);
-});
-
 test("compare schema", async ({ skip }) => {
   await compareSchema(skip);
 });
diff --git a/evals/006-clients/000-use_query/TASK.txt b/evals/006-clients/000-use_query/TASK.txt
index 3fbfe16..c7e7daf 100644
--- a/evals/006-clients/000-use_query/TASK.txt
+++ b/evals/006-clients/000-use_query/TASK.txt
@@ -14,12 +14,6 @@ No indexes are required.
 ```ts
 export const getAllMessages = query({
   args: {},
-  returns: v.object({
-    _id: v.id("messages"),
-    _creationTime: v.number(),
-    author: v.string(),
-    body: v.string(),
-  }),
   handler: async (ctx) => {
     return ctx.db.query("messages").order("desc").collect();
   }
diff --git a/evals/006-clients/000-use_query/answer/backend.stderr.log b/evals/006-clients/000-use_query/answer/backend.stderr.log
deleted file mode 100644
index e69de29..0000000
diff --git a/evals/006-clients/000-use_query/answer/backend.stdout.log b/evals/006-clients/000-use_query/answer/backend.stdout.log
deleted file mode 100644
index 6a32d0b..0000000
--- a/evals/006-clients/000-use_query/answer/backend.stdout.log
+++ /dev/null
@@ -1,53 +0,0 @@
-2025-02-04T08:40:55.106648Z  INFO convex_local_backend: Starting a Convex backend
-2025-02-04T08:40:55.106732Z  INFO convex_local_backend: The self-host Convex backend will periodically communicate with a remote beacon server. This is to help Convex understand and improve the product. You can disable this telemetry by setting the --disable-beacon flag.
-2025-02-04T08:40:55.106800Z  INFO convex_local_backend: Sentry is not enabled.
-2025-02-04T08:40:55.107853Z  INFO search::searcher::searcher: Searchlight starting, local_storage_path: /var/folders/tr/jh_4svr15cx26b53nx91m6qh0000gn/T/.tmpDlnnw0 max_size: 524.3 MB
-2025-02-04T08:40:55.110892Z  INFO database::database: Bootstrapping indexes...
-2025-02-04T08:40:55.113126Z  INFO indexing::backend_in_memory_indexes: Loading 65 enabled indexes
-2025-02-04T08:40:55.114754Z  INFO database::database: Bootstrapping table metadata...
-2025-02-04T08:40:55.116686Z  INFO database::subscription: Starting subscriptions worker
-2025-02-04T08:40:55.125464Z  INFO database::database: Set search storage to LocalDirStorage { dir: "/Users/ianmacartney/src/convex-evals/evals/006-clients/000-use_query/answer/convex_local_storage/search" }
-2025-02-04T08:40:55.126808Z  INFO node_executor::local: Using local node executor. Source: /var/folders/tr/jh_4svr15cx26b53nx91m6qh0000gn/T/.tmpl0sz3f/local.cjs
-2025-02-04T08:40:55.126828Z  WARN local_backend: Running without a proxy in release mode -- UDF `fetch` requests are unrestricted!
-2025-02-04T08:40:55.131187Z  INFO database::index_worker: Starting IndexWorker
-2025-02-04T08:40:55.131214Z  INFO database::index_workers::retriable_worker: Starting VectorFlusher
-2025-02-04T08:40:55.131221Z  INFO database::index_workers::retriable_worker: Starting SearchFlusher
-2025-02-04T08:40:55.131188Z  INFO database::index_workers::retriable_worker: Starting FastForwardWorker
-2025-02-04T08:40:55.131245Z  INFO database::index_workers::retriable_worker: Starting VectorCompactor
-2025-02-04T08:40:55.131271Z  INFO application::schema_worker: Starting SchemaWorker
-2025-02-04T08:40:55.131319Z  INFO application::scheduled_jobs: Starting scheduled job executor
-2025-02-04T08:40:55.131325Z  INFO application::system_table_cleanup: Starting SystemTableCleanupWorker
-2025-02-04T08:40:55.131227Z  INFO database::index_workers::retriable_worker: Starting TextCompactor
-2025-02-04T08:40:55.131282Z  INFO application::table_summary_worker: Starting background table summary worker
-2025-02-04T08:40:55.131375Z  INFO model::migrations: Attempting migration
-2025-02-04T08:40:55.131354Z  INFO database::search_index_bootstrap: Loaded 0 revisions (0 bytes) in 81.875µs.
-2025-02-04T08:40:55.131476Z  INFO application::cron_jobs: Starting cron job executor
-2025-02-04T08:40:55.131478Z  INFO database::committer: Committed backfilled vector indexes
-2025-02-04T08:40:55.131589Z  INFO database::search_index_bootstrap: SearchIndexBoostrapWorker finished!
-2025-02-04T08:40:55.131591Z  INFO local_backend::beacon: Starting beacon coroutine...
-2025-02-04T08:40:55.131826Z  INFO model::migrations: db metadata version up to date at 115
-2025-02-04T08:40:55.131839Z  INFO model::migrations: Migration complete
-2025-02-04T08:40:55.131958Z  INFO database::index_worker: 0 database indexes to backfill @ 1738658455109078000
-2025-02-04T08:40:55.131972Z  INFO database::index_worker: IndexWorker loop completed successfully, going to sleep
-2025-02-04T08:40:55.132516Z  INFO application::exports::worker: No exports requested or in progress.
-2025-02-04T08:40:55.133689Z  INFO common::http: backend listening on 0.0.0.0:56654
-2025-02-04T08:40:55.133773Z  INFO local_backend::proxy: Starting dev site proxy at 0.0.0.0:56655...
-2025-02-04T08:40:55.133817Z  INFO common::http: backend_http_proxy listening on 0.0.0.0:56655
-2025-02-04T08:40:55.135025Z  INFO application::table_summary_worker: Writing table summary checkpoint at ts 1738658455109078000
-2025-02-04T08:40:55.138402Z  INFO application::table_summary_worker: Finishing table summary bootstrap
-2025-02-04T08:40:55.141288Z  INFO database::committer: Bootstrapped table summaries at ts 1738658455109078000
-2025-02-04T08:40:55.141305Z  INFO application::table_summary_worker: Table summary bootstrap finished
-2025-02-04T08:40:55.511883Z  INFO local_backend::beacon: Beacon request with json {"database_uuid":"h0207zy3zxafqf3351cq92j28x79qbtb","migration_version":115,"compiled_revision":"7d6e1db5022c989f6e57c13b2c004a298d07400a","commit_timestamp":"2025-02-04T00:42:18.000000000Z","uptime":0,"beacon_tag":"self-host"} sent successfully to https://api.convex.dev/api/self_host_beacon. This anonymized data is used to help Convex understand and improve the product. You can disable this telemetry by setting the --disable-beacon flag.
-2025-02-04T08:40:56.442543Z  INFO isolate::client: Created funrun isolate worker 0
-2025-02-04T08:40:56.467020Z  INFO database::bootstrap_model::index: Preparing new and mutated indexes. Adding 0. Dropping 0.
-2025-02-04T08:40:56.467161Z  INFO convex-cloud-http: [] 127.0.0.1:56661 "POST /api/prepare_schema HTTP/1.1" 200 "-" "undici" application/json 71 25.610ms
-2025-02-04T08:40:56.473958Z  INFO convex-cloud-http: [] 127.0.0.1:56662 "GET /api/schema_state/jg2fnvwm325n71tmrn45sszv4s79pg2c HTTP/1.1" 200 "-" "undici" application/json 47 0.650ms
-2025-02-04T08:40:56.476404Z  INFO convex-cloud-http: [] 127.0.0.1:56661 "POST /api/get_config_hashes HTTP/1.1" 200 "-" "undici" application/json 200 0.581ms
-2025-02-04T08:40:56.979763Z  INFO convex-cloud-http: [] 127.0.0.1:56664 "GET /api/1.18.2/sync HTTP/1.1" 101 "-" "-" - 0 0.090ms
-2025-02-04T08:40:56.979871Z  INFO convex-cloud-http: [] 127.0.0.1:56665 "GET /api/1.18.2/sync HTTP/1.1" 101 "-" "-" - 0 0.052ms
-2025-02-04T08:40:57.108902Z ERROR isolate::client: Restarting Isolate unhandled_promise_rejection: UnhandledPromiseRejection, last request: "UDF: _system/frontend/addDocument.js:default"
-2025-02-04T08:40:57.123028Z ERROR isolate::client: Restarting Isolate unhandled_promise_rejection: UnhandledPromiseRejection, last request: "UDF: _system/frontend/addDocument.js:default"
-2025-02-04T08:40:57.128693Z ERROR common::errors: Caught error (RUST_BACKTRACE=1 RUST_LOG=info,common::errors=debug for full trace): WebSocket protocol error: Connection reset without closing handshake: Your request couldn't be completed. Try again later.
-2025-02-04T08:40:57.128728Z ERROR common::errors: Not reporting above error to sentry.
-2025-02-04T08:40:57.128694Z ERROR common::errors: Caught error (RUST_BACKTRACE=1 RUST_LOG=info,common::errors=debug for full trace): WebSocket protocol error: Connection reset without closing handshake: Your request couldn't be completed. Try again later.
-2025-02-04T08:40:57.128761Z ERROR common::errors: Not reporting above error to sentry.
diff --git a/evals/006-clients/000-use_query/answer/convex_local_backend.sqlite3 b/evals/006-clients/000-use_query/answer/convex_local_backend.sqlite3
deleted file mode 100644
index 2157df5..0000000
Binary files a/evals/006-clients/000-use_query/answer/convex_local_backend.sqlite3 and /dev/null differ
diff --git a/evals/006-clients/000-use_query/answer/convex_local_storage/modules/1939b90c-9793-4464-a61a-f9c8368fad50.blob b/evals/006-clients/000-use_query/answer/convex_local_storage/modules/1939b90c-9793-4464-a61a-f9c8368fad50.blob
deleted file mode 100644
index ab0fa65..0000000
Binary files a/evals/006-clients/000-use_query/answer/convex_local_storage/modules/1939b90c-9793-4464-a61a-f9c8368fad50.blob and /dev/null differ
diff --git a/grader/index.ts b/grader/index.ts
index 78b78a9..17c9410 100644
--- a/grader/index.ts
+++ b/grader/index.ts
@@ -8,10 +8,11 @@ import { expect } from "vitest";
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 
-const responsePort = process.env.CONVEX_PORT;
-if (!responsePort) {
+const responsePortStr = process.env.CONVEX_PORT;
+if (!responsePortStr) {
   throw new Error("CONVEX_PORT is not set");
 }
+const responsePort = Number(responsePortStr);
 
 export const cloudUrl = `http://0.0.0.0:${responsePort}`;
 export const siteUrl = `http://0.0.0.0:${responsePort + 1}`;
@@ -134,3 +135,80 @@ export async function compareFunctionSpec(skip: (note?: string) => void) {
   const answerFunctionSpec = await getFunctionSpec(answerAdminClient);
   expect(responseFunctionSpec).toEqual(answerFunctionSpec);
 }
+
+/**
+ * Helpers for inspecting schema indexes in graders
+ */
+export function findTable(
+  schema: any,
+  tableName: string,
+): {
+  tableName: string;
+  indexes?: { fields?: string[]; fieldNames?: string[] }[];
+} | null {
+  if (!schema || !Array.isArray(schema.tables)) return null;
+  return schema.tables.find((t: any) => t.tableName === tableName) ?? null;
+}
+
+export function hasIndexForFields(
+  schema: any,
+  tableName: string,
+  fields: string[],
+): boolean {
+  const table = findTable(schema, tableName);
+  if (!table) return false;
+  const indexes = (table.indexes ?? []) as {
+    fields?: string[];
+    fieldNames?: string[];
+  }[];
+  return indexes.some((idx) => {
+    const idxFields = idx.fields ?? idx.fieldNames ?? [];
+    return (
+      Array.isArray(idxFields) &&
+      idxFields.length === fields.length &&
+      idxFields.every((f, i) => f === fields[i])
+    );
+  });
+}
+
+export async function hasIndexOn(
+  adminClient: any,
+  tableName: string,
+  fields: string[],
+): Promise<boolean> {
+  const schema = await getSchema(adminClient);
+  if (!schema) return false;
+  return hasIndexForFields(schema, tableName, fields);
+}
+
+export function hasIndexForPrefix(
+  schema: any,
+  tableName: string,
+  fieldsPrefix: string[],
+): boolean {
+  const table = findTable(schema, tableName);
+  if (!table) return false;
+  const indexes = (table.indexes ?? []) as {
+    fields?: string[];
+    fieldNames?: string[];
+  }[];
+  return indexes.some((idx) => {
+    const idxFields = (idx.fields ?? idx.fieldNames ?? []) as string[];
+    if (!Array.isArray(idxFields)) return false;
+    if (idxFields.length < fieldsPrefix.length) return false;
+    for (let i = 0; i < fieldsPrefix.length; i++) {
+      if (idxFields[i] !== fieldsPrefix[i]) return false;
+    }
+    return true;
+  });
+}
+
+export async function hasIndexWithPrefix(
+  adminClient: any,
+  tableName: string,
+  fieldsPrefix: string[],
+): Promise<boolean> {
+  const schema = await getSchema(adminClient);
+  if (!schema) return false;
+  return hasIndexForPrefix(schema, tableName, fieldsPrefix);
+}
diff --git a/package.json b/package.json
index c114a26..c704098 100644
--- a/package.json
+++ b/package.json
@@ -26,13 +26,19 @@
     "typescript-eslint": "^8.23.0",
     "vitest": "^3.0.2"
   },
-  "scripts": {   
-    "local:run:fundamentals": "cross-env TEST_FILTER=000-fundamentals npm run local:run",
-    "local:run:one": "cross-env TEST_FILTER=000-fundamentals/000 npm run local:run",
-    "local:run": "cross-env MODELS=gpt-4.1 DISABLE_BRAINTRUST=1 VERBOSE_INFO_LOGS=1 LOCAL_RESULTS=local_results.jsonl npm run run:evals",
-    "braintrust:fundamentals": "cross-env TEST_FILTER=000-fundamentals npm run braintrust:run",
-    "braintrust:run:one": "cross-env TEST_FILTER=000-fundamentals/000 npm run braintrust:run",
-    "braintrust:run": "cross-env MODELS=gpt-4.1 VERBOSE_INFO_LOGS=1 LOCAL_RESULTS=local_results.jsonl npm run run:evals",
-    "run:evals": "pdm run python -m runner.eval_convex_coding"
+  "scripts": {
+    "local:run:fundamentals": "cross-env MODELS=gpt-5 TEST_FILTER=000-fundamentals npm run local:run",
+    "local:run:one": "cross-env MODELS=gpt-5 TEST_FILTER=000-fundamentals/000 npm run local:run",
+    "local:run": "cross-env DISABLE_BRAINTRUST=1 VERBOSE_INFO_LOGS=1 LOCAL_RESULTS=local_results.jsonl npm run run:evals",   
+    "grade:last": "bun run scripts/gradeLast.ts --concise",
+    "braintrust:fundamentals": "cross-env MODELS=gpt-5 TEST_FILTER=000-fundamentals npm run braintrust:run",
+    "braintrust:run:one": "cross-env MODELS=gpt-5 TEST_FILTER=000-fundamentals/000 npm run braintrust:run",
+    "braintrust:run": "cross-env LOCAL_RESULTS=local_results.jsonl VERBOSE_INFO_LOGS=1 npm run run:evals",
+    "run:evals": "pdm run python -m runner.eval_convex_coding",
+    "answers:run:fundamentals": "cross-env TEST_FILTER=000-fundamentals bun run answers:run",
+    "answers:run:one": "cross-env TEST_FILTER=000-fundamentals/000 bun run answers:run",
+    "answers:run": "cross-env VERBOSE_INFO_LOGS=1 bun run scripts/gradeAnswers.ts",
+    "answers:codegen": "bun run scripts/codegenAllAnswers.ts",
+    "local:visualize": "bun run scripts/visualizeResults.ts"
   }
 }
diff --git a/runner/eval_convex_coding.py b/runner/eval_convex_coding.py
index 613989b..f2f1d93 100644
--- a/runner/eval_convex_coding.py
+++ b/runner/eval_convex_coding.py
@@ -82,6 +82,7 @@ def convex_coding_evals(model: ModelTemplate):
                     "name": name,
                     "model": model.name,
                     "model_name": model.formatted_name,
+                    "tempdir": tempdir,
                 },
             }
         )
diff --git a/runner/models/__init__.py b/runner/models/__init__.py
index 9d77414..3b0df51 100644
--- a/runner/models/__init__.py
+++ b/runner/models/__init__.py
@@ -71,6 +71,22 @@ class ModelTemplate(BaseModel):
         uses_system_prompt=False,
         provider=ModelProvider.OPENAI,
     ),
+    ModelTemplate(
+        name="gpt-5-mini",
+        formatted_name="GPT-5 mini",
+        max_concurrency=int(os.getenv("OPENAI_CONCURRENCY", "4")),
+        requires_chain_of_thought=False,
+        uses_system_prompt=False,
+        provider=ModelProvider.OPENAI,
+    ),
+      ModelTemplate(
+        name="gpt-5-nano",
+        formatted_name="GPT-5 nano",
+        max_concurrency=int(os.getenv("OPENAI_CONCURRENCY", "4")),
+        requires_chain_of_thought=False,
+        uses_system_prompt=False,
+        provider=ModelProvider.OPENAI,
+    ),
     ModelTemplate(
         name="deepseek-ai/DeepSeek-V3",
         formatted_name="DeepSeek V3",
diff --git a/runner/models/model_codegen.py b/runner/models/model_codegen.py
index 2f1d4c6..10ce68c 100644
--- a/runner/models/model_codegen.py
+++ b/runner/models/model_codegen.py
@@ -45,14 +45,22 @@ def generate(self, prompt: str):
             system_message = {"role": "system", "content": SYSTEM_PROMPT}
         else:
             system_message = {"role": "user", "content": SYSTEM_PROMPT}
-        response = self.client.chat.completions.create(
-            model=self.model.name,
-            messages=[
+        # Build parameters, selecting the correct token limit key for newer models
+        max_token_limit = 8192 if self.model.name == "claude-3-5-sonnet-latest" else 16384
+        create_params = {
+            "model": self.model.name,
+            "messages": [
                 system_message,
                 {"role": "user", "content": user_prompt},
             ],
-            max_tokens=8192 if self.model.name == "claude-3-5-sonnet-latest" else 16384,
-        )
+        }
+        # Some newer models (e.g., GPT-5 family) expect `max_completion_tokens` instead of `max_tokens`.
+        if self.model.name.startswith("gpt-5"):
+            create_params["max_completion_tokens"] = max_token_limit
+        else:
+            create_params["max_tokens"] = max_token_limit
+
+        response = self.client.chat.completions.create(**create_params)
         return self._parse_response(response.choices[0].message.content)
 
     def _parse_response(self, response: str):
diff --git a/runner/reporting.py b/runner/reporting.py
index ee137b4..727c0ea 100644
--- a/runner/reporting.py
+++ b/runner/reporting.py
@@ -111,8 +111,113 @@ def report_run(eval_reports, verbose, jsonl):
 
 def _write_local_results(result: EvalResultWithSummary):
     try:
+        # Try to capture the tempdir from the first result's metadata (eval-level metadata is propagated)
+        tempdir_value = None
+        model_name = "unknown"
+        try:
+            if result and getattr(result, "results", None):
+                first = result.results[0]
+                if first and getattr(first, "metadata", None) and isinstance(first.metadata, dict):
+                    tempdir_value = first.metadata.get("tempdir")
+                    model_name = first.metadata.get("model_name", "unknown")
+        except Exception:
+            tempdir_value = None
+
+        # Extract individual evaluation results with detailed information
+        individual_results = []
+        category_summaries = {}
+        
+        for r in result.results:
+            if r.error:
+                continue  # Skip failed results for now
+                
+            category = r.metadata.get("category", "unknown") if r.metadata else "unknown"
+            name = r.metadata.get("name", "unknown") if r.metadata else "unknown"
+            
+            # Determine pass/fail based on "Tests pass" score
+            tests_pass_score = 0.0
+            if r.scores and "Tests pass" in r.scores:
+                try:
+                    tests_pass_score = float(r.scores["Tests pass"])
+                except:
+                    tests_pass_score = 0.0
+            
+            passed = tests_pass_score >= 0.999
+            
+            # Determine failure reason from scores
+            failure_reason = None
+            if not passed:
+                if r.scores:
+                    for score_name, score_value in r.scores.items():
+                        if isinstance(score_value, (int, float)) and score_value < 0.999:
+                            if score_name == "Valid filesystem output":
+                                failure_reason = "filesystem fail"
+                                break
+                            elif score_name == "`bun install` succeeds":
+                                failure_reason = "install fail"
+                                break
+                            elif score_name == "`convex codegen` succeeds":
+                                failure_reason = "codegen fail"
+                                break
+                            elif score_name == "Passes tsc":
+                                failure_reason = "tsc fail"
+                                break
+                            elif score_name == "Passes eslint":
+                                failure_reason = "eslint fail"
+                                break
+                            elif score_name == "`convex dev` succeeds":
+                                failure_reason = "convex dev fail"
+                                break
+                            elif score_name == "Tests pass":
+                                failure_reason = "tests fail"
+                                break
+                if not failure_reason:
+                    failure_reason = "unknown fail"
+            
+            # Build directory path
+            directory_path = None
+            if tempdir_value:
+                model = r.metadata.get("model", "unknown") if r.metadata else "unknown"
+                directory_path = f"{tempdir_value}/output/{model}/{category}/{name}"
+            
+            individual_result = {
+                "category": category,
+                "name": name,
+                "passed": passed,
+                "tests_pass_score": tests_pass_score,
+                "failure_reason": failure_reason,
+                "directory_path": directory_path,
+                "scores": r.scores if r.scores else {}
+            }
+            individual_results.append(individual_result)
+            
+            # Build category summaries
+            if category not in category_summaries:
+                category_summaries[category] = {"total": 0, "passed": 0, "failed": 0}
+            category_summaries[category]["total"] += 1
+            if passed:
+                category_summaries[category]["passed"] += 1
+            else:
+                category_summaries[category]["failed"] += 1
+
+        # Calculate overall statistics using binary pass/fail
+        total_tests = len(individual_results)
+        total_passed = sum(1 for r in individual_results if r["passed"])
+        # With binary scoring, average of test scores equals pass/fail ratio
+        overall_score = (total_passed / total_tests) if total_tests > 0 else 0.0
+
         entry = {
             "summary": result.summary.as_dict(),
+            "tempdir": tempdir_value,
+            "model_name": model_name,
+            "individual_results": individual_results,
+            "category_summaries": category_summaries,
+            "run_stats": {
+                "total_tests": total_tests,
+                "total_passed": total_passed,
+                "total_failed": total_tests - total_passed,
+                "overall_score": overall_score
+            }
         }
         with open(OUTPUT_RESULTS_FILE, "a", encoding="utf-8") as f:
             f.write(json.dumps(entry) + "\n")
@@ -126,11 +231,23 @@ def file_report_eval(evaluator, result: EvalResultWithSummary, verbose, jsonl):
     # Pretty console output as well
     results = result.results
     failing_results = [x for x in results if x.error]
+    if failing_results:
+        print()
+        print("=== Eval Failures ===")
+        for r in failing_results:
+            category = r.metadata.get("category") if r.metadata else "unknown"
+            name = r.metadata.get("name") if r.metadata else "unknown"
+            error_text = r.error if isinstance(r.error, str) else str(r.error)
+            print(f"- {category}/{name}: {error_text}")
+        print(f"Results written to: {OUTPUT_RESULTS_FILE}")
+        return False
 
     num_tests: dict[str, int] = {}
     tests_pass_scores: dict[str, float] = {}
+    passed_counts: dict[str, int] = {}
     total_score = 0.0
     total_num_tests = 0
+    total_passed = 0
     for r in results:
         category = r.metadata.get("category") if r.metadata else "unknown"
         num_tests[category] = num_tests.get(category, 0) + 1
@@ -138,6 +255,9 @@ def file_report_eval(evaluator, result: EvalResultWithSummary, verbose, jsonl):
         if r.scores and "Tests pass" in r.scores and isinstance(r.scores["Tests pass"], (int, float)):
             score_val = float(r.scores["Tests pass"])  # already normalized ratio per our scorer
         tests_pass_scores[category] = tests_pass_scores.get(category, 0.0) + score_val
+        if score_val >= 0.999:
+            passed_counts[category] = passed_counts.get(category, 0) + 1
+            total_passed += 1
         total_num_tests += 1
         total_score += score_val
 
@@ -149,10 +269,11 @@ def file_report_eval(evaluator, result: EvalResultWithSummary, verbose, jsonl):
     log_info("")
     log_info("=== Eval Summary ===")
     log_info(f"Model: {model_name if model_name else 'unknown'}")
-    log_info(f"Overall: {overall_rate:.2%} ({total_num_tests} tests)")
+    log_info(f"Overall: {overall_rate:.2%} ({total_passed} pass, {total_num_tests - total_passed} fail)")
     for category in sorted(num_tests.keys()):
         rate = (tests_pass_scores.get(category, 0.0) / num_tests[category]) if num_tests[category] > 0 else 0.0
-        log_info(f"- {category}: {rate:.2%} ({num_tests[category]} tests)")
+        cat_pass = passed_counts.get(category, 0)
+        log_info(f"- {category}: {rate:.2%} ({cat_pass} pass, {num_tests[category] - cat_pass} fail)")
     if failing_results:
         log_info(f"Failures: {len(failing_results)} case(s)")
     log_info(f"Results written to: {OUTPUT_RESULTS_FILE}")
diff --git a/runner/run_grader.py b/runner/run_grader.py
index 8d77888..de0b718 100644
--- a/runner/run_grader.py
+++ b/runner/run_grader.py
@@ -31,23 +31,31 @@ def run_grader(category: str, name: str, project_dir: str):
         message.append("  - `bun install` succeeds")
     except Exception as e:
         message.append(f"  - `bun install` fails: {e}")
+        print("\n".join(message))
+        return False
     try:
         generate_code(project_dir)
         message.append("  - `convex codegen` succeeds")
     except Exception as e:
         message.append(f"  - `convex codegen` fails: {e}")
+        print("\n".join(message))
+        return False
 
     try:
         typecheck_code(project_dir)
         message.append("  - Passes tsc")
     except Exception as e:
         message.append(f"  - Fails tsc: {e}")
+        print("\n".join(message))
+        return False
 
     try:
         lint_code(project_dir)
         message.append("  - Passes eslint")
     except Exception as e:
         message.append(f"  - Fails eslint: {e}")
+        print("\n".join(message))
+        return False
 
     with convex_backend(project_dir) as backend:
         try:
@@ -55,6 +63,8 @@ def run_grader(category: str, name: str, project_dir: str):
             message.append("  - `convex dev` succeeds")
         except Exception as e:
             message.append(f"  - `convex dev` fails: {e}")
+            print("\n".join(message))
+            return False
 
         test_file = f"evals/{category}/{name}/grader.test.ts"
         try:
diff --git a/runner/scorer.py b/runner/scorer.py
index 391f19f..77dccce 100644
--- a/runner/scorer.py
+++ b/runner/scorer.py
@@ -49,6 +49,11 @@ def convex_scorer(model, tempdir, *, input, expected, metadata, output):
         passed_install = True
     else:
         scores.append(Score("`bun install` succeeds", 0))
+        print(
+            f"Result ❌ – bun install fail – dir: {output_project_dir_abs}",
+            flush=True,
+        )
+        return scores
 
     log_info(f"[{category}/{name}] Running convex codegen")
     if run_command_step(run_log_path, lambda: generate_code(output_project_dir_abs), "codegen", "convex codegen"):
@@ -56,6 +61,11 @@ def convex_scorer(model, tempdir, *, input, expected, metadata, output):
         passed_codegen = True
     else:
         scores.append(Score("`convex codegen` succeeds", 0))
+        print(
+            f"Result ❌ – codegen fail – dir: {output_project_dir_abs}",
+            flush=True,
+        )
+        return scores
 
     log_info(f"[{category}/{name}] Typechecking (tsc)")
     if run_command_step(run_log_path, lambda: typecheck_code(output_project_dir_abs), "tsc", "tsc"):
@@ -63,6 +73,11 @@ def convex_scorer(model, tempdir, *, input, expected, metadata, output):
         passed_tsc = True
     else:
         scores.append(Score("Passes tsc", 0))
+        print(
+            f"Result ❌ – tsc fail – dir: {output_project_dir_abs}",
+            flush=True,
+        )
+        return scores
 
     log_info(f"[{category}/{name}] Linting (eslint)")
     if run_command_step(run_log_path, lambda: lint_code(output_project_dir_abs), "eslint", "eslint"):
@@ -70,6 +85,11 @@ def convex_scorer(model, tempdir, *, input, expected, metadata, output):
         passed_eslint = True
     else:
         scores.append(Score("Passes eslint", 0))
+        print(
+            f"Result ❌ – eslint fail – dir: {output_project_dir_abs}",
+            flush=True,
+        )
+        return scores
 
     output_backend_dir = f"{tempdir}/backends/output/{model}/{category}/{name}"
     os.makedirs(output_backend_dir, exist_ok=True)
@@ -81,6 +101,11 @@ def convex_scorer(model, tempdir, *, input, expected, metadata, output):
             passed_deploy = True
         else:
             scores.append(Score("`convex dev` succeeds", 0))
+            print(
+                f"Result ❌ – convex dev fail – dir: {output_project_dir_abs}",
+                flush=True,
+            )
+            return scores
 
         eval_path = f"evals/{category}/{name}"
         answer_project_dir, answer_backend_dir = setup_answer_backend(
@@ -342,7 +367,8 @@ def run_tests(backend, answer_backend, test_file):
 
         total = results["numTotalTests"]
         passed = results["numPassedTests"]
-        ratio = (passed / total) if total > 0 else 0
+        # Binary pass/fail: 1.0 if ALL tests pass, 0.0 otherwise
+        ratio = 1.0 if (total > 0 and passed == total) else 0.0
     except Exception as e:
         if done.returncode != 0:
             raise Exception(f"Failed to run tests:\n{done.stdout}")
diff --git a/scripts/codegenAllAnswers.ts b/scripts/codegenAllAnswers.ts
new file mode 100644
index 0000000..e300902
--- /dev/null
+++ b/scripts/codegenAllAnswers.ts
@@ -0,0 +1,103 @@
+// Run Convex codegen in every eval's answer project
+import { readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listCategories(root: string): string[] {
+  return readdirSync(root, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+}
+
+function listEvals(catDir: string): string[] {
+  return readdirSync(catDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+}
+
+function getArgValue(flag: string): string | undefined {
+  const pref = `${flag}=`;
+  for (const a of process.argv.slice(2))
+    if (a.startsWith(pref)) return a.slice(pref.length);
+  return undefined;
+}
+
+function shouldInclude(
+  category: string,
+  name: string,
+  filter: string | undefined,
+): boolean {
+  if (!filter) return true;
+  try {
+    const rx = new RegExp(filter);
+    return rx.test(`${category}/${name}`);
+  } catch {
+    return `${category}/${name}`.includes(filter);
+  }
+}
+
+async function runCodegen(cwd: string): Promise<number> {
+  const p = Bun.spawn(["bunx", "--yes", "convex", "codegen"], {
+    cwd,
+    stdio: ["inherit", "inherit", "inherit"],
+  });
+  return await p.exited;
+}
+
+async function main() {
+  const repoRoot = process.cwd();
+  const evalsRoot = resolve(repoRoot, "evals");
+  const filter = getArgValue("--filter") ?? process.env.TEST_FILTER;
+
+  if (!isDirectory(evalsRoot)) {
+    console.error(`Missing evals directory at ${evalsRoot}`);
+    process.exit(1);
+  }
+
+  console.log(`Scanning evals at ${evalsRoot}`);
+  if (filter) console.log(`Filter: ${filter}`);
+
+  let found = 0;
+  let attempted = 0;
+  let succeeded = 0;
+  const failures: { path: string; code: number }[] = [];
+
+  for (const category of listCategories(evalsRoot)) {
+    const catDir = join(evalsRoot, category);
+    for (const name of listEvals(catDir)) {
+      if (!shouldInclude(category, name, filter)) continue;
+      const answerDir = join(catDir, name, "answer");
+      if (!isDirectory(answerDir)) continue;
+      found++;
+
+      console.log(`- Running codegen in ${category}/${name} ...`);
+      attempted++;
+      const exitCode = await runCodegen(answerDir);
+      if (exitCode === 0) {
+        succeeded++;
+      } else {
+        failures.push({ path: `${category}/${name}`, code: exitCode });
+      }
+    }
+  }
+
+  console.log(`\nSummary:`);
+  console.log(`- Answers discovered: ${found}`);
+  console.log(`- Codegen attempted: ${attempted}`);
+  console.log(`- Succeeded: ${succeeded}`);
+  console.log(`- Failed: ${failures.length}`);
+  if (failures.length > 0) {
+    for (const f of failures) console.log(`  * ${f.path} (exit ${f.code})`);
+    process.exit(1);
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+main();
diff --git a/scripts/gradeAnswers.ts b/scripts/gradeAnswers.ts
new file mode 100644
index 0000000..a49e5bb
--- /dev/null
+++ b/scripts/gradeAnswers.ts
@@ -0,0 +1,187 @@
+// Prepare answer projects into a tempdir and run the grader against them
+import {
+  mkdirSync,
+  existsSync,
+  readdirSync,
+  statSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { tmpdir } from "node:os";
+
+// -------- CLI/env --------
+function getArgValue(flag: string): string | undefined {
+  const pref = `${flag}=`;
+  for (const a of process.argv.slice(2))
+    if (a.startsWith(pref)) return a.slice(pref.length);
+  return undefined;
+}
+
+const filterArg = getArgValue("--filter");
+const modelLabel = getArgValue("--model") ?? process.env.MODEL ?? "answers";
+
+const TEST_FILTER = filterArg ?? process.env.TEST_FILTER ?? "";
+
+// -------- Filesystem helpers --------
+function ensureDir(path: string): void {
+  if (!existsSync(path)) mkdirSync(path, { recursive: true });
+}
+
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listCategories(): string[] {
+  const root = resolve(process.cwd(), "evals");
+  if (!isDirectory(root)) throw new Error(`Missing evals directory at ${root}`);
+  return readdirSync(root, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+}
+
+function listEvals(category: string): string[] {
+  const catDir = resolve(process.cwd(), "evals", category);
+  return readdirSync(catDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+}
+
+function shouldInclude(category: string, name: string): boolean {
+  if (!TEST_FILTER) return true;
+  try {
+    const rx = new RegExp(TEST_FILTER);
+    return rx.test(`${category}/${name}`);
+  } catch {
+    // Treat invalid regex as literal substring
+    return `${category}/${name}`.includes(TEST_FILTER);
+  }
+}
+
+function walkAnswerFiles(
+  answerDir: string,
+  baseDir: string,
+  out: string[] = [],
+): string[] {
+  for (const entry of readdirSync(answerDir, { withFileTypes: true })) {
+    const full = join(answerDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "_generated")
+        continue;
+      walkAnswerFiles(full, baseDir, out);
+    } else {
+      if (entry.name === "package.json" || entry.name.endsWith(".ts")) {
+        const relative = full.slice(baseDir.length + 1);
+        out.push(relative);
+      }
+    }
+  }
+  return out;
+}
+
+function copyFileEnsuringDir(src: string, dest: string): void {
+  ensureDir(dirname(dest));
+  writeFileSync(dest, readFileSync(src));
+}
+
+function copyAnswerToOutput(
+  tempdir: string,
+  model: string,
+  category: string,
+  name: string,
+): number {
+  const evalDir = resolve(process.cwd(), "evals", category, name);
+  const answerDir = join(evalDir, "answer");
+  if (!isDirectory(answerDir)) return 0;
+
+  const destProjectDir = join(tempdir, "output", model, category, name);
+  ensureDir(destProjectDir);
+
+  const files = walkAnswerFiles(answerDir, answerDir);
+  for (const rel of files) {
+    const src = join(answerDir, rel);
+    const dest = join(destProjectDir, rel);
+    copyFileEnsuringDir(src, dest);
+  }
+  return files.length;
+}
+
+// -------- Grader runner (streaming output) --------
+async function runGraderStreaming(tempdir: string): Promise<number> {
+  const p = Bun.spawn(
+    ["pdm", "run", "python", "-m", "runner.run_grader", tempdir],
+    { stdio: ["inherit", "inherit", "inherit"] },
+  );
+  return await p.exited;
+}
+
+// -------- Main --------
+async function main() {
+  try {
+    const tempBase = Bun.nanoseconds().toString(36);
+    const absTempdir = join(tmpdir(), "convex-evals", tempBase);
+    ensureDir(absTempdir);
+    ensureDir(join(absTempdir, "output"));
+    ensureDir(join(absTempdir, "answer"));
+    ensureDir(join(absTempdir, "backends"));
+
+    console.log(
+      `Initialized workspace: model='${modelLabel}', filter='${
+        TEST_FILTER || "<none>"
+      }'`,
+    );
+    console.log(`Workspace prepared at: ${absTempdir}`);
+
+    let prepared = 0;
+    const categories = listCategories();
+    console.log(
+      `Scanning categories under ${resolve(process.cwd(), "evals")}: ${categories.length} found`,
+    );
+    for (const category of categories) {
+      console.log(`Processing category: ${category}`);
+      for (const name of listEvals(category)) {
+        if (!shouldInclude(category, name)) continue;
+        console.log(`  - Preparing ${category}/${name}`);
+        const count = copyAnswerToOutput(
+          absTempdir,
+          modelLabel,
+          category,
+          name,
+        );
+        if (count > 0) {
+          console.log(`    Copied ${count} file(s)`);
+          prepared++;
+        } else {
+          console.log(`    Skipped (no answer directory)`);
+        }
+      }
+    }
+
+    console.log(`Using tempdir: ${absTempdir}`);
+    console.log(`Prepared ${prepared} project(s) under output/${modelLabel}`);
+    if (prepared === 0) {
+      console.log("No projects matched the filter or had an answer directory");
+      process.exit(0);
+    }
+
+    console.log("Starting grader run...");
+    const code = await runGraderStreaming(absTempdir);
+    console.log(`Grader finished with exit code: ${code}`);
+    if (code !== 0) {
+      const tempdirLink = absTempdir.replace(/\\/g, "/");
+      console.log(`One or more gradings failed. See logs in: ${tempdirLink}`);
+      return;
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// Execute
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+main();
diff --git a/scripts/gradeLast.ts b/scripts/gradeLast.ts
new file mode 100644
index 0000000..e85f295
--- /dev/null
+++ b/scripts/gradeLast.ts
@@ -0,0 +1,179 @@
+// Grade the last run using the tempdir recorded in local_results.jsonl
+import { readFileSync, existsSync, statSync, readdirSync } from "node:fs";
+import { resolve, join } from "node:path";
+
+const RESULTS_FILE = resolve(process.cwd(), "local_results.jsonl");
+const ERROR_MARKER = "[error] vitest:";
+
+// -------- JSONL helpers --------
+function readJsonlLines(filePath: string): string[] {
+  if (!existsSync(filePath))
+    throw new Error(`Results file not found: ${filePath}`);
+  const content = readFileSync(filePath, { encoding: "utf-8" });
+  const lines = content.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  if (lines.length === 0) throw new Error("Results file is empty");
+  return lines;
+}
+
+function parseLastTempdirFromJsonl(lines: string[]): string {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const obj = JSON.parse(lines[i]) as any;
+      if (!obj || typeof obj !== "object") continue;
+      if (typeof obj.tempdir === "string") return obj.tempdir;
+      if (
+        obj.summary?.metadata?.tempdir &&
+        typeof obj.summary.metadata.tempdir === "string"
+      )
+        return obj.summary.metadata.tempdir;
+    } catch {
+      // ignore parse errors and scan upwards
+    }
+  }
+  throw new Error("No tempdir found in local results");
+}
+
+// -------- Filesystem helpers --------
+function assertDirectory(path: string): void {
+  const st = existsSync(path) ? statSync(path) : null;
+  if (!st || !st.isDirectory())
+    throw new Error(`Tempdir not found or not a directory: ${path}`);
+}
+
+// -------- Grader runners --------
+function runGraderConcise(tempdir: string): {
+  exitCode: number;
+  output: string;
+} {
+  const res = Bun.spawnSync([
+    "pdm",
+    "run",
+    "python",
+    "-m",
+    "runner.run_grader",
+    tempdir,
+  ]);
+  const dec = new TextDecoder();
+  const output =
+    (res.stdout ? dec.decode(res.stdout) : "") +
+    (res.stderr ? dec.decode(res.stderr) : "");
+  return { exitCode: res.exitCode ?? 1, output };
+}
+
+async function runGraderStreaming(tempdir: string): Promise<number> {
+  const p = Bun.spawn(
+    ["pdm", "run", "python", "-m", "runner.run_grader", tempdir],
+    {
+      stdio: ["inherit", "inherit", "inherit"],
+    },
+  );
+  return await p.exited;
+}
+
+// -------- Output parsing/printing --------
+function extractInterestingLines(output: string): string[] {
+  return output
+    .split(/\r?\n/)
+    .filter(
+      (l) =>
+        l.startsWith("Running grader for ") ||
+        l.startsWith("Grading ") ||
+        l.trim().startsWith("- Tests fail:") ||
+        l.startsWith("Result "),
+    );
+}
+
+type FailureEntry = {
+  category: string;
+  name: string;
+  messages: string[];
+  logPath: string;
+};
+
+function listProjectLogPaths(
+  tempdir: string,
+): { category: string; name: string; logPath: string }[] {
+  const out: { category: string; name: string; logPath: string }[] = [];
+  const outputRoot = join(tempdir, "output");
+  if (!existsSync(outputRoot)) return out;
+  const models = readdirSync(outputRoot, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+  for (const model of models) {
+    const modelDir = join(outputRoot, model);
+    const categories = readdirSync(modelDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+    for (const category of categories) {
+      const catDir = join(modelDir, category);
+      const names = readdirSync(catDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+      for (const name of names) {
+        const logPath = join(catDir, name, "run.log");
+        if (existsSync(logPath)) out.push({ category, name, logPath });
+      }
+    }
+  }
+  return out;
+}
+
+function parseVitestFailuresFromLog(logPath: string): string[] {
+  const log = readFileSync(logPath, { encoding: "utf-8" });
+  const lines = log.split(/\r?\n/);
+  const messages: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.includes(ERROR_MARKER)) continue;
+    messages.push(line.replace(ERROR_MARKER, "  ").trimEnd());
+    let j = i + 1;
+    while (j < lines.length && lines[j] && !/^\[.+\]/.test(lines[j])) {
+      messages.push(`  ${lines[j]}`);
+      j++;
+    }
+    i = j - 1;
+  }
+  return messages;
+}
+
+function collectConciseFailures(tempdir: string): FailureEntry[] {
+  const entries: FailureEntry[] = [];
+  for (const { category, name, logPath } of listProjectLogPaths(tempdir)) {
+    const messages = parseVitestFailuresFromLog(logPath);
+    if (messages.length > 0)
+      entries.push({ category, name, messages, logPath });
+  }
+  return entries;
+}
+
+function printConciseFailures(failures: FailureEntry[]): void {
+  if (failures.length === 0) return;
+  console.log("\nConcise failure details:");
+  for (const f of failures) {
+    console.log(`- ${f.category}/${f.name}:`);
+    for (const m of f.messages) console.log(m);
+    console.log(`\nSee full log: ${f.logPath}\n`);
+  }
+}
+
+// -------- Main --------
+try {
+  const tempdir = parseLastTempdirFromJsonl(readJsonlLines(RESULTS_FILE));
+  assertDirectory(tempdir);
+
+  const concise = process.argv.includes("--concise");
+  if (concise) {
+    const { exitCode, output } = runGraderConcise(tempdir);
+    for (const l of extractInterestingLines(output)) console.log(l);
+    if (exitCode !== 0) {
+      printConciseFailures(collectConciseFailures(tempdir));
+      process.exit(exitCode || 1);
+    }
+  } else {
+    const code = await runGraderStreaming(tempdir);
+    if (code !== 0) process.exit(code);
+  }
+} catch (err) {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}
diff --git a/scripts/visualizeResults.ts b/scripts/visualizeResults.ts
new file mode 100644
index 0000000..1a40d16
--- /dev/null
+++ b/scripts/visualizeResults.ts
@@ -0,0 +1,3327 @@
+#!/usr/bin/env bun
+// Web server to visualize local_results.jsonl evaluation data
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+const RESULTS_FILE = resolve(process.cwd(), "local_results.jsonl");
+const PORT = 3000;
+
+interface EvalScore {
+  name: string;
+  score: number;
+  improvements: number;
+  regressions: number;
+  diff: any;
+  _longest_score_name?: number;
+}
+
+interface EvalSummary {
+  project_name: string;
+  project_id: string | null;
+  experiment_id: string | null;
+  experiment_name: string | null;
+  project_url: string | null;
+  experiment_url: string | null;
+  comparison_experiment_name: string | null;
+  scores: Record<string, EvalScore>;
+  metrics: Record<string, any>;
+}
+
+interface IndividualResult {
+  category: string;
+  name: string;
+  passed: boolean;
+  tests_pass_score: number;
+  failure_reason: string | null;
+  directory_path: string | null;
+  scores: Record<string, any>;
+}
+
+interface CategorySummary {
+  total: number;
+  passed: number;
+  failed: number;
+}
+
+interface RunStats {
+  total_tests: number;
+  total_passed: number;
+  total_failed: number;
+  overall_score: number;
+}
+
+interface EvalResult {
+  summary: EvalSummary;
+  tempdir: string;
+  model_name?: string;
+  individual_results?: IndividualResult[];
+  category_summaries?: Record<string, CategorySummary>;
+  run_stats?: RunStats;
+}
+
+function readJsonlResults(): EvalResult[] {
+  if (!existsSync(RESULTS_FILE)) {
+    throw new Error(`Results file not found: ${RESULTS_FILE}`);
+  }
+
+  const content = readFileSync(RESULTS_FILE, { encoding: "utf-8" });
+  const lines = content.split(/\r?\n/).filter((l) => l.trim().length > 0);
+
+  return lines.map((line) => {
+    try {
+      return JSON.parse(line) as EvalResult;
+    } catch (err) {
+      console.warn(`Failed to parse line: ${line}`);
+      throw err;
+    }
+  });
+}
+
+function generateRunsListHTML(results: EvalResult[]): string {
+  const runRows = results
+    .map((result, index) => {
+      const modelName = result.model_name || "Unknown Model";
+      const timestamp = new Date().toLocaleString(); // TODO: Add actual timestamp from data
+      const overallScore = result.run_stats?.overall_score || 0;
+      const totalTests = result.run_stats?.total_tests || 0;
+      const passedTests = result.run_stats?.total_passed || 0;
+
+      const percentage = (overallScore * 100).toFixed(1);
+      const statusClass =
+        overallScore >= 0.9
+          ? "excellent"
+          : overallScore >= 0.7
+            ? "good"
+            : overallScore >= 0.5
+              ? "fair"
+              : "poor";
+      const statusIcon =
+        overallScore >= 0.9
+          ? "🟢"
+          : overallScore >= 0.7
+            ? "🟡"
+            : overallScore >= 0.5
+              ? "🟠"
+              : "🔴";
+
+      return `
+        <tr class="run-row ${statusClass}" onclick="showRunDetails(${index})" data-run-index="${index}">
+          <td>
+            <span class="status-icon">${statusIcon}</span>
+            <strong>${modelName}</strong>
+          </td>
+          <td class="score-cell">
+            <div class="score-bar-container">
+              <div class="score-bar" style="width: ${percentage}%"></div>
+              <span class="score-text">${percentage}%</span>
+            </div>
+          </td>
+          <td class="numeric">${passedTests}/${totalTests}</td>
+          <td class="timestamp">${timestamp}</td>
+          <td class="tempdir-cell">
+            <code>${result.tempdir || "N/A"}</code>
+          </td>
+        </tr>
+      `;
+    })
+    .join("");
+
+  return `
+    <div class="runs-list">
+      <div class="card">
+        <div class="card-header">
+          📊 Evaluation Runs
+        </div>
+        <div class="card-content">
+          <div class="table-container">
+            <table>
+              <thead>
+                <tr>
+                  <th>Model</th>
+                  <th>Overall Score</th>
+                  <th>Pass/Total</th>
+                  <th>Timestamp</th>
+                  <th>Temp Directory</th>
+                </tr>
+              </thead>
+              <tbody>
+                ${runRows}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+function generateRunDetailsHTML(result: EvalResult, runIndex: number): string {
+  const modelName = result.model_name || "Unknown Model";
+  const categoryRows = Object.entries(result.category_summaries || {})
+    .map(([category, summary]) => {
+      const percentage =
+        summary.total > 0
+          ? ((summary.passed / summary.total) * 100).toFixed(1)
+          : "0.0";
+      const statusClass =
+        summary.passed === summary.total
+          ? "pass"
+          : summary.failed === summary.total
+            ? "fail"
+            : "warning";
+      const statusIcon =
+        summary.passed === summary.total
+          ? "✅"
+          : summary.failed === summary.total
+            ? "❌"
+            : "⚠️";
+
+      return `
+        <tr class="${statusClass}" onclick="showCategoryDetails('${category}', ${runIndex})">
+          <td>
+            <span class="status-icon">${statusIcon}</span>
+            ${category}
+          </td>
+          <td class="score-cell">
+            <div class="score-bar-container">
+              <div class="score-bar" style="width: ${percentage}%"></div>
+              <span class="score-text">${percentage}%</span>
+            </div>
+          </td>
+          <td class="numeric">${summary.passed}/${summary.total}</td>
+          <td class="numeric">${summary.failed}</td>
+        </tr>
+      `;
+    })
+    .join("");
+
+  return `
+    <div class="run-details">
+      <div class="breadcrumb">
+        <button onclick="showRunsList()" class="breadcrumb-btn">← All Runs</button>
+        <span class="breadcrumb-current">${modelName}</span>
+      </div>
+      
+      <div class="stats-grid">
+        <div class="stat-card overall-score">
+          <div class="stat-number">${((result.run_stats?.overall_score || 0) * 100).toFixed(1)}%</div>
+          <div class="stat-label">Overall Score</div>
+        </div>
+        <div class="stat-card pass-rate">
+          <div class="stat-number">${result.run_stats?.total_passed || 0}</div>
+          <div class="stat-label">Tests Passed</div>
+        </div>
+        <div class="stat-card total-tests">
+          <div class="stat-number">${result.run_stats?.total_failed || 0}</div>
+          <div class="stat-label">Tests Failed</div>
+        </div>
+      </div>
+
+      <div class="card">
+        <div class="card-header">
+          📋 Category Breakdown
+        </div>
+        <div class="card-content">
+          <div class="table-container">
+            <table>
+              <thead>
+                <tr>
+                  <th>Category</th>
+                  <th>Success Rate</th>
+                  <th>Passed</th>
+                  <th>Failed</th>
+                </tr>
+              </thead>
+              <tbody>
+                ${categoryRows}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+function generateCategoryDetailsHTML(
+  category: string,
+  result: EvalResult,
+  runIndex: number,
+): string {
+  const modelName = result.model_name || "Unknown Model";
+  const categoryResults = (result.individual_results || []).filter(
+    (r) => r.category === category,
+  );
+
+  const individualRows = categoryResults
+    .map((individualResult) => {
+      const statusIcon = individualResult.passed ? "✅" : "❌";
+      const statusClass = individualResult.passed ? "pass" : "fail";
+      const failureReason = individualResult.failure_reason || "N/A";
+      const directoryPath = individualResult.directory_path || "";
+
+      // Convert Windows path to file:// URL for clickable links
+      const fileUrl = directoryPath
+        ? `file:///${directoryPath.replace(/\\/g, "/")}`
+        : "";
+
+      return `
+         <tr class="${statusClass}">
+           <td>
+             <span class="status-icon">${statusIcon}</span>
+             ${individualResult.name}
+           </td>
+           <td class="status-text">
+             ${individualResult.passed ? "Pass" : failureReason}
+           </td>
+           <td class="directory-cell">
+             ${directoryPath ? `<button onclick="openDirectory('${directoryPath.replace(/\\/g, "\\\\")}')" class="directory-link" title="Open directory">📁 Open</button>` : "N/A"}
+             ${directoryPath ? `<button onclick="viewLog('${directoryPath.replace(/\\/g, "\\\\")}/run.log')" class="log-link" title="View run.log">📄 Log</button>` : ""}
+           </td>
+         </tr>
+       `;
+    })
+    .join("");
+
+  const categoryStats = result.category_summaries?.[category];
+  const successRate = categoryStats
+    ? ((categoryStats.passed / categoryStats.total) * 100).toFixed(1)
+    : "0.0";
+
+  return `
+    <div class="category-details">
+      <div class="breadcrumb">
+        <button onclick="showRunsList()" class="breadcrumb-btn">All Runs</button>
+        <span class="breadcrumb-separator">→</span>
+        <button onclick="showRunDetails(${runIndex})" class="breadcrumb-btn">${modelName}</button>
+        <span class="breadcrumb-separator">→</span>
+        <span class="breadcrumb-current">${category}</span>
+      </div>
+      
+      <div class="stats-grid">
+        <div class="stat-card overall-score">
+          <div class="stat-number">${successRate}%</div>
+          <div class="stat-label">Success Rate</div>
+        </div>
+        <div class="stat-card pass-rate">
+          <div class="stat-number">${categoryStats?.passed || 0}</div>
+          <div class="stat-label">Passed</div>
+        </div>
+        <div class="stat-card total-tests">
+          <div class="stat-number">${categoryStats?.failed || 0}</div>
+          <div class="stat-label">Failed</div>
+        </div>
+      </div>
+
+      <div class="card">
+        <div class="card-header">
+          🔍 Individual Results - ${category}
+        </div>
+        <div class="card-content">
+          <div class="table-container">
+            <table>
+              <thead>
+                <tr>
+                  <th>Evaluation</th>
+                  <th>Status</th>
+                  <th>Directory</th>
+                </tr>
+              </thead>
+              <tbody>
+                ${individualRows}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+function generateRunsSidebar(
+  results: EvalResult[],
+  selectedRunIndex: number,
+  selectedCategory: string = "",
+): string {
+  return results
+    .map((result, index) => {
+      const modelName = result.model_name || "Unknown Model";
+      const overallScore = result.run_stats?.overall_score || 0;
+      const percentage = (overallScore * 100).toFixed(1);
+      const scoreClass =
+        overallScore >= 0.9
+          ? "score-excellent"
+          : overallScore >= 0.7
+            ? "score-good"
+            : overallScore >= 0.5
+              ? "score-fair"
+              : "score-poor";
+      const isActive = selectedRunIndex === index;
+
+      // Generate categories accordion content
+      const categories = result.category_summaries || {};
+      const categoriesContent = Object.entries(categories)
+        .map(([categoryName, stats]) => {
+          const isSelectedCategory = selectedCategory === categoryName;
+          return `
+            <button class="category-accordion-item ${isSelectedCategory ? "active" : ""}" onclick="showCategoryDetails('${categoryName}', ${index})">
+              <div class="category-item">
+                <div class="category-name">${categoryName}</div>
+                <div class="category-stats">${stats.passed}/${stats.total}</div>
+              </div>
+            </button>
+          `;
+        })
+        .join("");
+
+      const totalPassed = result.run_stats?.total_passed || 0;
+      const totalTests = result.run_stats?.total_tests || 0;
+
+      return `
+        <div class="run-accordion">
+          <button class="sidebar-item run-header ${isActive ? "active" : ""}" onclick="toggleRunAccordion(${index})">
+            <div class="run-item">
+              <div class="run-model">${modelName}</div>
+              <div class="run-scores">
+                <div class="run-score ${scoreClass}">${percentage}%</div>
+                <div class="run-count">${totalPassed}/${totalTests}</div>
+              </div>
+              <div class="accordion-arrow ${isActive ? "expanded" : ""}">▼</div>
+            </div>
+          </button>
+          <div class="categories-accordion ${isActive ? "expanded" : ""}">
+            ${categoriesContent}
+          </div>
+        </div>
+      `;
+    })
+    .join("");
+}
+
+function generateCategoriesSidebar(
+  result: EvalResult,
+  selectedCategory: string,
+): string {
+  const categories = result.category_summaries || {};
+  return Object.entries(categories)
+    .map(([categoryName, stats]) => {
+      const successRate =
+        stats.total > 0
+          ? ((stats.passed / stats.total) * 100).toFixed(1)
+          : "0.0";
+      const isActive = selectedCategory === categoryName;
+
+      return `
+        <button class="sidebar-item ${isActive ? "active" : ""}" onclick="showCategoryDetails('${categoryName}', getCurrentRunIndex())">
+          <div class="category-item">
+            <div class="category-name">${categoryName}</div>
+            <div class="category-stats">${stats.passed}/${stats.total}</div>
+          </div>
+        </button>
+      `;
+    })
+    .join("");
+}
+
+function generateEvalsSidebar(
+  result: EvalResult,
+  selectedCategory: string,
+  selectedEval: string = "",
+): string {
+  const categoryResults = (result.individual_results || []).filter(
+    (r) => r.category === selectedCategory,
+  );
+
+  return categoryResults
+    .map((evalResult) => {
+      const isActive = selectedEval === evalResult.name;
+      const statusClass = evalResult.passed ? "status-pass" : "status-fail";
+
+      // Parse failure reasons from the scores object
+      const failureReasons: string[] = [];
+      if (!evalResult.passed && evalResult.scores) {
+        Object.entries(evalResult.scores).forEach(([key, value]) => {
+          if (value === 0) {
+            if (key.toLowerCase().includes("test"))
+              failureReasons.push("Tests");
+            if (key.toLowerCase().includes("lint"))
+              failureReasons.push("Linting");
+            if (key.toLowerCase().includes("compile"))
+              failureReasons.push("Compile");
+            if (key.toLowerCase().includes("tsc"))
+              failureReasons.push("TypeScript");
+            if (key.toLowerCase().includes("filesystem"))
+              failureReasons.push("Files");
+            if (key.toLowerCase().includes("valid"))
+              failureReasons.push("Validation");
+          }
+        });
+      }
+
+      // Also check failure_reason text for additional context
+      if (!evalResult.passed && evalResult.failure_reason) {
+        const reason = evalResult.failure_reason.toLowerCase();
+        if (reason.includes("tsc") && !failureReasons.includes("TypeScript")) {
+          failureReasons.push("TypeScript");
+        }
+        if (reason.includes("lint") && !failureReasons.includes("Linting")) {
+          failureReasons.push("Linting");
+        }
+        if (reason.includes("test") && !failureReasons.includes("Tests")) {
+          failureReasons.push("Tests");
+        }
+        if (
+          reason.includes("convex dev") &&
+          !failureReasons.includes("Convex Dev")
+        ) {
+          failureReasons.push("Convex Dev");
+        }
+      }
+
+      const statusContent = evalResult.passed
+        ? `<div class="eval-status ${statusClass}">Pass</div>`
+        : `<div class="failure-reasons">
+            ${failureReasons.map((reason) => `<span class="failure-reason">${reason}</span>`).join("")}
+           </div>`;
+
+      return `
+        <button class="sidebar-item ${isActive ? "active" : ""}" onclick="showEvalDetails('${evalResult.name}', getCurrentRunIndex(), '${selectedCategory}')">
+          <div class="eval-item">
+            <div class="eval-name">${evalResult.name}</div>
+            ${statusContent}
+          </div>
+        </button>
+      `;
+    })
+    .join("");
+}
+
+function generateMainContent(
+  results: EvalResult[],
+  currentView: string,
+  runIndex: number,
+  category: string,
+  evalName: string,
+  selectedTab: string = "log",
+  selectedFile: string = "",
+  selectedLine: number | null = null,
+): string {
+  if (currentView === "runs-list") {
+    return `
+      <div class="header">
+        <h1>🚀 Convex Evaluation Results</h1>
+        <p>Select a run from the sidebar to view detailed results</p>
+      </div>
+      <div class="stats-grid">
+        <div class="stat-card">
+          <div class="stat-number">${results.length}</div>
+          <div class="stat-label">Total Runs</div>
+        </div>
+      </div>
+    `;
+  } else if (currentView === "run-details" && runIndex >= 0) {
+    const result = results[runIndex];
+    const modelName = result.model_name || "Unknown Model";
+
+    return `
+      <div class="header">
+        <h1>${modelName}</h1>
+        <p>Select a category from the sidebar to view individual evaluations</p>
+      </div>
+      <div class="stats-grid">
+        <div class="stat-card overall-score">
+          <div class="stat-number">${((result.run_stats?.overall_score || 0) * 100).toFixed(1)}%</div>
+          <div class="stat-label">Overall Score</div>
+        </div>
+        <div class="stat-card pass-rate">
+          <div class="stat-number">${result.run_stats?.total_passed || 0}</div>
+          <div class="stat-label">Tests Passed</div>
+        </div>
+        <div class="stat-card total-tests">
+          <div class="stat-number">${result.run_stats?.total_failed || 0}</div>
+          <div class="stat-label">Tests Failed</div>
+        </div>
+      </div>
+    `;
+  } else if (currentView === "category-details" && runIndex >= 0 && category) {
+    const result = results[runIndex];
+    const modelName = result.model_name || "Unknown Model";
+    const categoryResults = (result.individual_results || []).filter(
+      (r) => r.category === category,
+    );
+
+    const tableRows = categoryResults
+      .map((individualResult) => {
+        const statusIcon = individualResult.passed ? "✅" : "❌";
+        const statusClass = individualResult.passed ? "pass" : "fail";
+        const failureReason = individualResult.failure_reason || "N/A";
+        const directoryPath = individualResult.directory_path || "";
+
+        return `
+          <tr class="${statusClass}">
+            <td>
+              <span class="status-icon">${statusIcon}</span>
+              ${individualResult.name}
+            </td>
+            <td class="status-text">
+              ${individualResult.passed ? "Pass" : failureReason}
+            </td>
+            <td class="directory-cell">
+              ${directoryPath ? `<button onclick="openDirectory('${directoryPath.replace(/\\/g, "\\\\")}')" class="directory-link" title="Open directory">📁 Open</button>` : "N/A"}
+              ${directoryPath ? `<button onclick="viewLog('${directoryPath.replace(/\\/g, "\\\\")}/run.log')" class="log-link" title="View run.log">📄 Log</button>` : ""}
+            </td>
+          </tr>
+        `;
+      })
+      .join("");
+
+    return `
+      <div class="header">
+        <h1>${modelName} - ${category}</h1>
+        <p>Individual evaluation results for this category</p>
+      </div>
+      
+      <div class="card">
+        <div class="card-header">
+          🔍 Individual Results - ${category}
+        </div>
+        <div class="card-content">
+          <div class="table-container">
+            <table>
+              <thead>
+                <tr>
+                  <th>Evaluation</th>
+                  <th>Status</th>
+                  <th>Directory</th>
+                </tr>
+              </thead>
+              <tbody>
+                ${tableRows}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    `;
+  } else if (
+    currentView === "eval-details" &&
+    runIndex >= 0 &&
+    category &&
+    evalName
+  ) {
+    const result = results[runIndex];
+    const modelName = result.model_name || "Unknown Model";
+    const evalResult = (result.individual_results || []).find(
+      (r) => r.category === category && r.name === evalName,
+    );
+
+    if (!evalResult) {
+      return '<div class="header"><h1>Evaluation not found</h1></div>';
+    }
+
+    // Get detailed scores
+    const scoresBreakdown = Object.entries(evalResult.scores || {})
+      .map(([key, value]) => {
+        const status = value === 1 ? "pass" : "fail";
+        const icon = value === 1 ? "✅" : "❌";
+        return `
+          <div class="score-item ${status}">
+            <span class="score-icon">${icon}</span>
+            <span class="score-name">${key}</span>
+            <span class="score-value">${value === 1 ? "Pass" : "Fail"}</span>
+          </div>
+        `;
+      })
+      .join("");
+
+    return `
+             <div class="tab-container">
+         <div class="tab-nav">
+           <button class="tab-button ${selectedTab === "log" ? "active" : ""}" onclick="switchTab('log', '${category}', '${evalName}')">📄 Log</button>
+           <button class="tab-button ${selectedTab === "task" ? "active" : ""}" onclick="switchTab('task', '${category}', '${evalName}')">📋 Task</button>
+           <button class="tab-button ${selectedTab === "steps" ? "active" : ""}" onclick="switchTab('steps', '${category}', '${evalName}')">📊 Steps</button>
+           <button class="tab-button ${selectedTab === "answer" ? "active" : ""}" onclick="switchTab('answer', '${category}', '${evalName}')">💡 Answer</button>
+           <button class="tab-button ${selectedTab === "output" ? "active" : ""}" onclick="switchTab('output', '${category}', '${evalName}')">📁 Output</button>
+         </div>
+        
+                 <div class="tab-content">
+           <!-- Log Tab -->
+           <div class="tab-pane ${selectedTab === "log" ? "active" : ""}" id="log-tab-${category}-${evalName}">
+             <div class="log-content" id="log-content-${category}-${evalName}">
+               <p><em>Loading run log...</em></p>
+             </div>
+           </div>
+           
+           <!-- Task Tab -->
+           <div class="tab-pane ${selectedTab === "task" ? "active" : ""}" id="task-tab-${category}-${evalName}">
+             <div class="task-content" id="task-content-${category}-${evalName}">
+               <p><em>Loading task description...</em></p>
+             </div>
+           </div>
+          
+          <!-- Steps Tab -->
+          <div class="tab-pane ${selectedTab === "steps" ? "active" : ""}" id="steps-tab-${category}-${evalName}">
+            <div class="scores-list">
+              ${scoresBreakdown}
+            </div>
+            ${
+              evalResult.failure_reason
+                ? `
+            <div class="failure-summary">
+              <strong>Failure Reason:</strong> ${evalResult.failure_reason}
+            </div>
+          `
+                : ""
+            }
+          </div>
+          
+          <!-- Answer Tab -->
+          <div class="tab-pane ${selectedTab === "answer" ? "active" : ""}" id="answer-tab-${category}-${evalName}">
+            <div class="file-browser">
+              <div class="file-tree">
+                <div class="file-tree-header">
+                  Answer Directory
+                  <button onclick="copyDirectoryPath('evals/${category}/${evalName}/answer')" class="copy-path-button" title="Copy answer directory path">
+                    📋
+                  </button>
+                </div>
+                <div id="answer-file-tree-content-${category}-${evalName}">
+                  <p><em>Loading answer directory...</em></p>
+                </div>
+              </div>
+              <div class="file-viewer">
+                <div class="file-viewer-header">
+                  <span id="answer-current-file-name-${category}-${evalName}">Select a file</span>
+                </div>
+                <div class="file-content" id="answer-file-content-${category}-${evalName}">
+                  <p><em>Select a file to view its contents</em></p>
+                </div>
+              </div>
+            </div>
+          </div>
+          
+          <!-- Output Tab -->
+          <div class="tab-pane ${selectedTab === "output" ? "active" : ""}" id="output-tab-${category}-${evalName}">
+            <div class="file-browser">
+              <div class="file-tree">
+                <div class="file-tree-header">
+                  Directory Structure
+                  ${
+                    evalResult.directory_path
+                      ? `
+                    <button onclick="copyDirectoryPath('${evalResult.directory_path.replace(/\\/g, "\\\\")}')" class="copy-path-button" title="Copy directory path">
+                      📋
+                    </button>
+                  `
+                      : ""
+                  }
+                </div>
+                <div id="file-tree-content-${category}-${evalName}">
+                  <p><em>Loading directory structure...</em></p>
+                </div>
+              </div>
+              <div class="file-viewer">
+                <div class="file-viewer-header">
+                  <span id="current-file-name-${category}-${evalName}">run.log</span>
+                </div>
+                                 <div class="file-content-split" id="file-content-split-${category}-${evalName}">
+                   <div class="file-content-pane">
+                     <div class="file-content-header">Generated Output</div>
+                     <div class="file-content" id="file-content-${category}-${evalName}">
+                       <p><em>Loading run log...</em></p>
+                     </div>
+                   </div>
+                   <div class="split-handle" onmousedown="initSplitResize(event, '${category}', '${evalName}')"></div>
+                   <div class="file-content-pane" id="answer-pane-${category}-${evalName}" style="display: flex; flex-direction: column;">
+                     <div class="file-content-header answer">Answer (Reference)</div>
+                     <div class="file-content" id="answer-content-${category}-${evalName}">
+                       <p><em>No corresponding answer file</em></p>
+                     </div>
+                   </div>
+                 </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+        
+                 <script>
+           // Define helper functions first
+           function makeLogPathsClickable(logContent, category, evalName) {
+               // Escape HTML first
+               const escapedContent = logContent
+                   .replace(/&/g, '&amp;')
+                   .replace(/</g, '&lt;')
+                   .replace(/>/g, '&gt;');
+               
+               // Regular expression to match file paths with optional line/column numbers
+               const filePathRegex = /(?:^|\\s)((?:[a-zA-Z0-9_-]+\\/)*[a-zA-Z0-9_-]+\\.[a-zA-Z0-9]+)(?:\\((\\d+)(?:,\\d+)?\\)|:(\\d+)(?::\\d+)?)?/gm;
+               
+               return escapedContent.replace(filePathRegex, (match, filePath, lineNumber1, lineNumber2) => {
+                   const lineNumber = lineNumber1 || lineNumber2;
+                   const cleanPath = filePath.trim();
+                   const displayPath = match.trim();
+                   
+                   // Create clickable link that switches to Output tab and opens the file
+                   return \` <span class="log-file-path" onclick="openFileFromLog('\${cleanPath}', '\${category}', '\${evalName}', \${lineNumber || 'null'})" title="Click to open \${cleanPath}">\${displayPath}</span>\`;
+               });
+           }
+           
+           function openFileFromLog(filePath, category, evalName, lineNumber) {
+               // Update URL to navigate to output tab with the specific file
+               const runIndex = getCurrentRunIndex();
+               let newUrl = \`/run-\${runIndex}/\${category}/\${evalName}/output#\${encodeURIComponent(filePath)}\`;
+               if (lineNumber) {
+                   newUrl += \`:\${lineNumber}\`;
+               }
+               
+               // Navigate to the new URL, which will trigger a page reload with the correct state
+               window.location.href = newUrl;
+           }
+           
+           function getCurrentRunIndex() {
+               const path = window.location.pathname;
+               const match = path.match(/\\/run-(\\d+)/);
+               return match ? parseInt(match[1]) : 0;
+           }
+           
+           // Monaco Editor setup
+           let monacoLoaded = false;
+           let editors = new Map(); // Store editor instances
+           
+           // Initialize Monaco Editor
+           function initMonaco() {
+               if (monacoLoaded) return Promise.resolve();
+               
+               return new Promise((resolve) => {
+                   require.config({ paths: { vs: 'https://unpkg.com/monaco-editor@0.45.0/min/vs' } });
+                   require(['vs/editor/editor.main'], function() {
+                       monacoLoaded = true;
+                       resolve();
+                   });
+               });
+           }
+           
+           // Create or update Monaco editor
+           async function createMonacoEditor(containerId, content, language, isReadOnly = true) {
+               console.log('Creating Monaco editor for:', containerId, 'language:', language);
+               
+               try {
+                   await initMonaco();
+                   
+                   const container = document.getElementById(containerId);
+                   if (!container) {
+                       console.error('Container not found:', containerId);
+                       return null;
+                   }
+                   
+                   // Dispose existing editor if any
+                   const existingEditor = editors.get(containerId);
+                   if (existingEditor) {
+                       existingEditor.dispose();
+                   }
+                   
+                   const monacoLanguage = getMonacoLanguage(language);
+                   console.log('Using Monaco language:', monacoLanguage, 'for file language:', language);
+                   
+                   // Create new editor
+                   const editor = monaco.editor.create(container, {
+                       value: content,
+                       language: monacoLanguage,
+                       theme: 'vs',
+                       readOnly: isReadOnly,
+                       automaticLayout: true,
+                       minimap: { enabled: false },
+                       scrollBeyondLastLine: false,
+                       lineNumbers: 'on',
+                       renderWhitespace: 'selection',
+                       fontSize: 14,
+                       fontFamily: 'Monaco, Menlo, "Ubuntu Mono", monospace',
+                       wordWrap: 'off',
+                       glyphMargin: false,
+                       folding: true,
+                       lineDecorationsWidth: 0,
+                       lineNumbersMinChars: 4
+                   });
+                   
+                   editors.set(containerId, editor);
+                   console.log('Monaco editor created successfully');
+                   return editor;
+               } catch (error) {
+                   console.error('Error creating Monaco editor:', error);
+                   return null;
+               }
+           }
+           
+           // Map file extensions to Monaco languages
+           function getMonacoLanguage(fileExt) {
+               const languageMap = {
+                   'ts': 'typescript',
+                   'tsx': 'typescript',
+                   'js': 'javascript',
+                   'jsx': 'javascript',
+                   'json': 'json',
+                   'html': 'html',
+                   'css': 'css',
+                   'scss': 'scss',
+                   'md': 'markdown',
+                   'py': 'python',
+                   'sql': 'sql',
+                   'yaml': 'yaml',
+                   'yml': 'yaml',
+                   'xml': 'xml',
+                   'log': 'plaintext',
+                   'txt': 'plaintext'
+               };
+               return languageMap[fileExt] || 'plaintext';
+           }
+           
+           // Auto-load task file and run log when page loads
+           (async function() {
+             // Load run log into the Log tab
+             ${
+               evalResult.directory_path
+                 ? `
+             try {
+               const logPath = '${evalResult.directory_path.replace(/\\/g, "/")}/run.log';
+               const response = await fetch(\`/file/\${encodeURIComponent(logPath)}\`);
+               const logElement = document.getElementById('log-content-${category}-${evalName}');
+               if (response.ok) {
+                 const data = await response.json();
+                 if (logElement) {
+                   // Process log content to make file paths clickable
+                   const processedContent = makeLogPathsClickable(data.content, '${category}', '${evalName}');
+                   logElement.innerHTML = \`<pre>\${processedContent}</pre>\`;
+                 }
+               } else {
+                 if (logElement) {
+                   logElement.innerHTML = '<p style="color: #f87171; padding: 1.5rem;">Run log not found.</p>';
+                 }
+               }
+             } catch (error) {
+               const logElement = document.getElementById('log-content-${category}-${evalName}');
+               if (logElement) {
+                 logElement.innerHTML = \`<p style="color: #f87171; padding: 1.5rem;">Error loading run log: \${error.message}</p>\`;
+               }
+             }
+             `
+                 : `
+             const logElement = document.getElementById('log-content-${category}-${evalName}');
+             if (logElement) {
+               logElement.innerHTML = '<p style="color: #9ca3af; padding: 1.5rem;">No run log available.</p>';
+             }
+             `
+             }
+             
+             // Load task file
+             try {
+               const response = await fetch(\`/task/\${encodeURIComponent('${category}')}/\${encodeURIComponent('${evalName}')}\`);
+               const taskElement = document.getElementById('task-content-${category}-${evalName}');
+               if (response.ok) {
+                 const data = await response.json();
+                 if (taskElement) {
+                   taskElement.innerHTML = \`<pre style="white-space: pre-wrap; margin: 0; font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.875rem; line-height: 1.6; height: 100%; overflow-y: auto;">\${data.content}</pre>\`;
+                 }
+               } else {
+                 if (taskElement) {
+                   taskElement.innerHTML = '<p style="color: #dc2626;">Task file not found.</p>';
+                 }
+               }
+             } catch (error) {
+               const taskElement = document.getElementById('task-content-${category}-${evalName}');
+               if (taskElement) {
+                 taskElement.innerHTML = \`<p style="color: #dc2626;">Error loading task: \${error.message}</p>\`;
+               }
+             }
+            
+            // Load file browser
+            ${
+              evalResult.directory_path
+                ? `
+            try {
+              const dirPath = '${evalResult.directory_path.replace(/\\/g, "/")}';
+              const response = await fetch(\`/browse/\${encodeURIComponent(dirPath)}\`);
+              const treeElement = document.getElementById('file-tree-content-${category}-${evalName}');
+              
+              if (response.ok) {
+                const data = await response.json();
+                if (treeElement && data.files) {
+                  const fileTreeHTML = data.files.map(file => {
+                    const safeId = btoa(file.path).replace(/[^a-zA-Z0-9]/g, '');
+                    if (file.isDirectory) {
+                      return \`
+                        <div class="directory-container">
+                          <button class="file-tree-item directory" onclick="toggleDirectory('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '${category}', '${evalName}')">
+                            <span>📁 \${file.name}</span>
+                            <span class="expand-arrow">▶</span>
+                          </button>
+                          <div class="file-tree-children collapsed" id="children-\${safeId}"></div>
+                        </div>
+                      \`;
+                    } else {
+                      return \`<button class="file-tree-item file" onclick="loadFile('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '${category}', '${evalName}')" title="\${file.name}">📄 \${file.name}</button>\`;
+                    }
+                  }).join('');
+                  treeElement.innerHTML = fileTreeHTML;
+                  
+                  // Check if we should auto-load a file from URL, otherwise default to run.log
+                  const fragment = window.location.hash.slice(1);
+                  const hasFileInUrl = fragment && (fragment.includes('/') || fragment.includes('.'));
+                  
+                  if (hasFileInUrl) {
+                    // Don't auto-load run.log, let the URL-based loading handle it
+                    console.log('URL fragment detected, skipping run.log auto-load:', fragment);
+                    
+                    // Immediately try to load the file from URL
+                    setTimeout(() => {
+                      autoLoadFileFromUrl('${selectedFile}', '${category}', '${evalName}', ${selectedLine || "null"});
+                    }, 200);
+                  } else {
+                    // Auto-load run.log as default
+                    const runLogFile = data.files.find(f => f.name === 'run.log');
+                    if (runLogFile) {
+                      loadFile(runLogFile.path, 'run.log', '${category}', '${evalName}');
+                      
+                      // Mark run.log as active in the file tree
+                      setTimeout(() => {
+                        const runLogButton = document.querySelector(\`#file-tree-content-\${category}-\${evalName} .file-tree-item[title="run.log"]\`);
+                        if (runLogButton) {
+                          runLogButton.classList.add('active');
+                        }
+                      }, 100);
+                    }
+                  }
+                  
+                  // Also try to load answer for the first file (usually index.ts or similar)
+                  const firstCodeFile = data.files.find(f => !f.isDirectory && (f.name.endsWith('.ts') || f.name.endsWith('.js')));
+                  if (firstCodeFile) {
+                    console.log('Testing answer loading for first code file:', firstCodeFile.path);
+                    loadCorrespondingAnswerFile(firstCodeFile.path, firstCodeFile.name, '${category}', '${evalName}');
+                  }
+                }
+              } else {
+                if (treeElement) {
+                  treeElement.innerHTML = '<p style="color: #dc2626;">Directory not found.</p>';
+                }
+              }
+            } catch (error) {
+              const treeElement = document.getElementById('file-tree-content-${category}-${evalName}');
+              if (treeElement) {
+                treeElement.innerHTML = \`<p style="color: #dc2626;">Error loading directory: \${error.message}</p>\`;
+              }
+            }
+            `
+                : `
+            const treeElement = document.getElementById('file-tree-content-${category}-${evalName}');
+            if (treeElement) {
+              treeElement.innerHTML = '<p style="color: #6b7280;">No directory available.</p>';
+            }
+            `
+            }
+          })();
+        </script>
+      </div>
+    `;
+  }
+
+  return '<div class="header"><h1>Select a run to get started</h1></div>';
+}
+
+function generateHTML(
+  results: EvalResult[],
+  currentView: string = "runs-list",
+  runIndex: number = -1,
+  category: string = "",
+  evalName: string = "",
+  selectedTab: string = "log",
+  selectedFile: string = "",
+  selectedLine: number | null = null,
+): string {
+  const runsListHTML = generateRunsListHTML(results);
+
+  // Generate details for each run (but hidden initially)
+  const runDetailsHTML = results
+    .map((result, index) => generateRunDetailsHTML(result, index))
+    .join("");
+
+  // Generate category details for each run and category (but hidden initially)
+  const categoryDetailsHTML = results
+    .map((result, runIndex) => {
+      return Object.keys(result.category_summaries || {})
+        .map((category) =>
+          generateCategoryDetailsHTML(category, result, runIndex),
+        )
+        .join("");
+    })
+    .join("");
+
+  // Generate sidebar content
+  const runsSidebarHTML = generateRunsSidebar(results, runIndex, category);
+  const categoriesSidebarHTML =
+    runIndex >= 0 ? generateCategoriesSidebar(results[runIndex], category) : "";
+  const evalsSidebarHTML =
+    runIndex >= 0 && category
+      ? generateEvalsSidebar(results[runIndex], category, evalName)
+      : "";
+  const mainContentHTML = generateMainContent(
+    results,
+    currentView,
+    runIndex,
+    category,
+    evalName,
+    selectedTab,
+    selectedFile,
+    selectedLine,
+  );
+
+  return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Convex Evaluation Results</title>
+    <!-- Monaco Editor -->
+    <script src="https://unpkg.com/monaco-editor@0.45.0/min/vs/loader.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #f8fafc;
+            min-height: 100vh;
+            color: #333;
+            margin: 0;
+            overflow-x: hidden;
+        }
+        
+        .layout {
+            display: flex;
+            min-height: 100vh;
+        }
+        
+        /* Sidebar System */
+        .sidebar {
+            background: white;
+            border-right: 1px solid #e5e7eb;
+            overflow-y: auto;
+            flex-shrink: 0;
+        }
+        
+                 .runs-sidebar {
+             width: 280px;
+             background: #f9fafb;
+             padding-left: 0;
+             transition: width 0.3s ease;
+         }
+         
+         .runs-sidebar.collapsed {
+             width: 40px;
+         }
+         
+         .categories-sidebar {
+             width: 240px;
+             background: white;
+             display: none; /* Hide the separate categories sidebar */
+         }
+         
+         .evals-sidebar {
+             width: 300px;
+             background: #f9fafb;
+             transition: width 0.3s ease;
+         }
+         
+         .evals-sidebar.collapsed {
+             width: 40px;
+         }
+        
+        .main-content {
+            flex: 1;
+            background: white;
+            overflow: hidden;
+            padding: 2rem;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        /* Remove padding for eval details with tabs */
+        .main-content .tab-container {
+            margin: -2rem;
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .main-content .tab-container .tab-nav {
+            padding: 0;
+        }
+        
+        .main-content .tab-container .tab-button:first-child {
+            margin-left: 0;
+            padding-left: 2rem;
+        }
+        
+        .main-content .tab-container .tab-button:last-child {
+            padding-right: 2rem;
+        }
+        
+                 .sidebar-header {
+             padding: 1.5rem 1rem;
+             border-bottom: 1px solid #e5e7eb;
+             background: #4f46e5;
+             color: white;
+             display: flex;
+             justify-content: space-between;
+             align-items: center;
+         }
+         
+         .sidebar-header h3 {
+             font-size: 1.1rem;
+             font-weight: 600;
+             margin: 0;
+         }
+         
+         .sidebar-collapse-btn {
+             background: rgba(255, 255, 255, 0.2);
+             border: none;
+             color: white;
+             width: 24px;
+             height: 24px;
+             border-radius: 4px;
+             cursor: pointer;
+             display: flex;
+             align-items: center;
+             justify-content: center;
+             font-size: 14px;
+             transition: all 0.2s ease;
+         }
+         
+         .sidebar-collapse-btn:hover {
+             background: rgba(255, 255, 255, 0.3);
+         }
+         
+         .sidebar.collapsed .sidebar-header {
+             padding: 1rem 0.5rem;
+         }
+         
+         .sidebar.collapsed .sidebar-header h3 {
+             display: none;
+         }
+         
+         .sidebar.collapsed .sidebar-content {
+             display: none;
+         }
+         
+         .sidebar.collapsed .sidebar-collapse-btn {
+             margin: 0 auto;
+         }
+        
+        .sidebar-content {
+            padding: 0;
+        }
+        
+        .runs-sidebar .sidebar-content {
+            padding: 0;
+        }
+        
+        .sidebar-item {
+            display: block;
+            width: 100%;
+            padding: 1rem;
+            border: none;
+            background: none;
+            text-align: left;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            border-bottom: 1px solid #f3f4f6;
+            font-size: 0.875rem;
+            min-height: 60px;
+        }
+        
+        .sidebar-item:hover {
+            background: #f3f4f6;
+            transform: translateX(2px);
+        }
+        
+        .sidebar-item.active {
+            background: #e0e7ff;
+            border-left: 3px solid #4f46e5;
+            font-weight: 600;
+            color: #4f46e5;
+        }
+        
+        .run-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            width: 100%;
+            gap: 1rem;
+        }
+        
+        .run-model {
+            font-weight: 600;
+            color: #374151;
+            flex: 1;
+            min-width: 0;
+        }
+        
+        .run-scores {
+            display: flex;
+            flex-direction: column;
+            align-items: flex-end;
+            gap: 0.125rem;
+            flex-shrink: 0;
+            min-width: fit-content;
+        }
+        
+        .run-score {
+            font-size: 0.75rem;
+            padding: 0.25rem 0.5rem;
+            border-radius: 12px;
+            font-weight: 600;
+        }
+        
+        .run-count {
+            font-size: 0.65rem;
+            color: #6b7280;
+            font-weight: 500;
+        }
+        
+        .score-excellent { background: #dcfce7; color: #166534; }
+        .score-good { background: #dbeafe; color: #1d4ed8; }
+        .score-fair { background: #fef3c7; color: #92400e; }
+        .score-poor { background: #fecaca; color: #dc2626; }
+        
+        .category-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+        
+        .category-name {
+            font-weight: 500;
+        }
+        
+        .category-stats {
+            font-size: 0.75rem;
+            color: #6b7280;
+        }
+        
+        .eval-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+        
+        .eval-name {
+            font-weight: 500;
+            color: #374151;
+        }
+        
+        .eval-status {
+            font-size: 0.75rem;
+            padding: 0.25rem 0.5rem;
+            border-radius: 8px;
+            font-weight: 600;
+        }
+        
+        .status-pass { background: #dcfce7; color: #166534; }
+        .status-fail { background: #fecaca; color: #dc2626; }
+        
+        .failure-reasons {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.25rem;
+        }
+        
+        .failure-reason {
+            background: #dc2626;
+            color: white;
+            font-size: 0.625rem;
+            padding: 0.125rem 0.375rem;
+            border-radius: 50px;
+            font-weight: 600;
+        }
+        
+        .header {
+            margin-bottom: 2rem;
+        }
+        
+        .header h1 {
+            font-size: 2.5rem;
+            font-weight: 700;
+            margin-bottom: 0.5rem;
+            color: #1f2937;
+        }
+        
+        .header p {
+            font-size: 1.1rem;
+            color: #6b7280;
+        }
+        
+        /* Tab Interface */
+        .tab-container {
+            padding: 0;
+        }
+        
+        .tab-nav {
+            display: flex;
+            border-bottom: 2px solid #e5e7eb;
+            margin-bottom: 0;
+        }
+        
+        .tab-button {
+            background: none;
+            border: none;
+            padding: 1rem 2rem;
+            font-size: 1rem;
+            font-weight: 500;
+            cursor: pointer;
+            color: #6b7280;
+            border-bottom: 3px solid transparent;
+            transition: all 0.2s ease;
+        }
+        
+        .tab-button:hover {
+            color: #4f46e5;
+            background: #f8fafc;
+        }
+        
+        .tab-button.active {
+            color: #4f46e5;
+            border-bottom-color: #4f46e5;
+            background: #f8fafc;
+        }
+        
+        .tab-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .tab-pane {
+            display: none;
+            flex: 1;
+            overflow: hidden;
+        }
+        
+        .tab-pane.active {
+            display: flex;
+            flex-direction: column;
+        }
+        
+        /* Add padding to specific content within tabs */
+        .task-content {
+            flex: 1;
+            overflow: hidden;
+            height: 100%;
+            background: #f8fafc;
+            border: 1px solid #e5e7eb;
+            border-radius: 4px;
+            margin: 1.5rem;
+        }
+        
+                 .task-content pre {
+             padding: 1.5rem;
+             margin: 0;
+             height: 100%;
+             overflow-y: auto;
+             box-sizing: border-box;
+             background: transparent;
+             border: none;
+         }
+         
+         .log-content {
+             flex: 1;
+             overflow: hidden;
+             height: 100%;
+             background: #1f2937;
+             border: 1px solid #374151;
+             border-radius: 4px;
+             margin: 1.5rem;
+         }
+         
+         .log-content pre {
+             padding: 1.5rem;
+             margin: 0;
+             height: 100%;
+             overflow-y: auto;
+             box-sizing: border-box;
+             background: transparent;
+             border: none;
+             color: #f3f4f6;
+             font-family: "Monaco", "Menlo", "Ubuntu Mono", monospace;
+             font-size: 0.875rem;
+             line-height: 1.4;
+             white-space: pre-wrap;
+         }
+        
+
+        
+        .failure-summary {
+            margin: 0 1.5rem 1.5rem 1.5rem;
+        }
+        
+        .directory-info {
+            background: #f8fafc;
+            border: 1px solid #e5e7eb;
+            border-radius: 6px;
+            padding: 1rem;
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 1rem;
+        }
+        
+        .directory-path {
+            flex: 1;
+        }
+        
+        .directory-path code {
+            background: #e5e7eb;
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            font-size: 0.875rem;
+        }
+        
+        .status-badge {
+            font-size: 1.25rem;
+            font-weight: 700;
+            padding: 1rem;
+            border-radius: 8px;
+            text-align: center;
+            margin-bottom: 1rem;
+        }
+        
+        .failure-summary {
+            background: #fef2f2;
+            border: 1px solid #fecaca;
+            border-radius: 6px;
+            padding: 1rem 1.25rem;
+            color: #991b1b;
+            margin-top: 0.5rem;
+        }
+        
+        .scores-list {
+            display: flex;
+            flex-direction: column;
+            gap: 0.5rem;
+            padding: 1.5rem;
+            flex: 1;
+            overflow-y: auto;
+        }
+        
+        .score-item {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+            padding: 0.75rem 1rem;
+            border-radius: 6px;
+            border: 1px solid #e5e7eb;
+        }
+        
+        .score-item.pass {
+            background: #f0fdf4;
+            border-color: #bbf7d0;
+        }
+        
+        .score-item.fail {
+            background: #fef2f2;
+            border-color: #fecaca;
+        }
+        
+        .score-name {
+            flex: 1;
+            font-weight: 500;
+        }
+        
+        .score-value {
+            font-weight: 600;
+            font-size: 0.875rem;
+        }
+        
+        .file-actions {
+            display: flex;
+            gap: 0.75rem;
+            flex-wrap: wrap;
+        }
+        
+        .action-button {
+            background: #4f46e5;
+            color: white;
+            border: none;
+            padding: 0.5rem 1rem;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 0.875rem;
+            transition: background-color 0.2s ease;
+        }
+        
+        .action-button:hover {
+            background: #4338ca;
+        }
+        
+        .task-content {
+            line-height: 1.6;
+            padding: 0.5rem 0;
+            max-height: 500px;
+            overflow-y: auto;
+        }
+        
+        .task-content pre {
+            max-height: none;
+            overflow-y: visible;
+        }
+        
+        .directory-info {
+            margin-bottom: 1rem;
+        }
+        
+        .directory-path {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+            background: #f8fafc;
+            padding: 0.75rem;
+            border-radius: 4px;
+            border: 1px solid #e5e7eb;
+            margin-bottom: 1rem;
+        }
+        
+        .directory-path code {
+            flex: 1;
+            background: #e5e7eb;
+            padding: 0.25rem 0.5rem;
+            border-radius: 3px;
+            font-size: 0.875rem;
+            word-break: break-all;
+        }
+        
+        .run-log-content {
+            margin-top: 0.5rem;
+        }
+        
+        /* File Browser Styles */
+        .file-browser {
+            display: flex;
+            flex: 1;
+            border: 1px solid #e5e7eb;
+            border-radius: 4px;
+            overflow: hidden;
+        }
+        
+        .file-tree {
+            width: 300px;
+            min-width: 250px;
+            background: #f8fafc;
+            border-right: 1px solid #e5e7eb;
+            display: flex;
+            flex-direction: column;
+            flex-shrink: 0;
+        }
+        
+        .file-tree-header {
+            padding: 0.75rem;
+            background: #e5e7eb;
+            font-weight: 600;
+            font-size: 0.875rem;
+            border-bottom: 1px solid #d1d5db;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .copy-path-button {
+            background: #4f46e5;
+            color: white;
+            border: none;
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            font-size: 0.75rem;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            margin-left: 0.5rem;
+        }
+        
+        .copy-path-button:hover {
+            background: #4338ca;
+            transform: scale(1.05);
+        }
+        
+        /* Syntax highlighting customizations */
+        pre[class*="language-"] {
+            background: #f8fafc !important;
+            border: 1px solid #e5e7eb;
+            border-radius: 4px;
+            padding: 1rem !important;
+        }
+        
+        code[class*="language-"] {
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important;
+            font-size: 0.875rem !important;
+        }
+        
+        /* Override Prism's default colors for better readability */
+        .token.comment,
+        .token.prolog,
+        .token.doctype,
+        .token.cdata {
+            color: #6b7280;
+        }
+        
+        .token.punctuation {
+            color: #374151;
+        }
+        
+        .token.property,
+        .token.tag,
+        .token.constant,
+        .token.symbol,
+        .token.deleted {
+            color: #dc2626;
+        }
+        
+        .token.boolean,
+        .token.number {
+            color: #7c3aed;
+        }
+        
+        .token.selector,
+        .token.attr-name,
+        .token.string,
+        .token.char,
+        .token.builtin,
+        .token.inserted {
+            color: #059669;
+        }
+        
+        .token.operator,
+        .token.entity,
+        .token.url,
+        .language-css .token.string,
+        .style .token.string,
+        .token.variable {
+            color: #0891b2;
+        }
+        
+        .token.atrule,
+        .token.attr-value,
+        .token.function,
+        .token.class-name {
+            color: #7c2d12;
+        }
+        
+                 .token.keyword {
+             color: #1d4ed8;
+         }
+         
+         /* Monaco Editor container */
+         .monaco-editor-container {
+             width: 100%;
+             height: 100%;
+             border: 1px solid #e5e7eb;
+             border-radius: 4px;
+             overflow: hidden;
+         }
+         
+         /* Monaco Editor line highlighting */
+         .highlight-line {
+             background-color: #fef3c7 !important;
+         }
+         
+         .highlight-line-gutter {
+             background-color: #f59e0b !important;
+         }
+         
+         /* Clickable log file paths */
+         .log-file-path {
+             color: #3b82f6;
+             text-decoration: underline;
+             cursor: pointer;
+             transition: all 0.2s ease;
+         }
+         
+         .log-file-path:hover {
+             color: #1d4ed8;
+             background-color: rgba(59, 130, 246, 0.1);
+             padding: 2px 4px;
+             border-radius: 3px;
+         }
+        
+        .file-viewer {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            background: white;
+        }
+        
+                 .file-content-split {
+             display: flex;
+             flex: 1;
+             position: relative;
+         }
+         
+         .file-content-pane {
+             display: flex;
+             flex-direction: column;
+             overflow: hidden;
+         }
+         
+         .file-content-pane:first-child {
+             flex: 0 0 50%;
+         }
+         
+         .file-content-pane:last-child {
+             flex: 1;
+         }
+         
+         .split-handle {
+             width: 6px;
+             background: #e5e7eb;
+             cursor: col-resize;
+             position: relative;
+             flex-shrink: 0;
+             transition: background-color 0.2s ease;
+         }
+         
+         .split-handle:hover {
+             background: #d1d5db;
+         }
+         
+         .split-handle::after {
+             content: '';
+             position: absolute;
+             top: 50%;
+             left: 50%;
+             transform: translate(-50%, -50%);
+             width: 2px;
+             height: 40px;
+             background: #9ca3af;
+             border-radius: 1px;
+         }
+         
+         .file-content-split:has(.file-content-pane[style*="display: none"]) .file-content-pane:not([style*="display: none"]) {
+             flex: 1;
+         }
+         
+         .file-content-split:has(.file-content-pane[style*="display: none"]) .split-handle {
+             display: none;
+         }
+        
+        .file-content-header {
+            padding: 0.5rem 0.75rem;
+            background: #f8fafc;
+            border-bottom: 1px solid #e5e7eb;
+            font-size: 0.875rem;
+            font-weight: 500;
+            color: #374151;
+        }
+        
+        .file-content-header.answer {
+            background: #fef3c7;
+            color: #92400e;
+        }
+        
+        .file-viewer-header {
+            padding: 0.75rem;
+            background: #f3f4f6;
+            border-bottom: 1px solid #e5e7eb;
+            font-weight: 600;
+            font-size: 0.875rem;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+        }
+        
+        .file-content {
+            flex: 1;
+            overflow-y: auto;
+            padding: 0;
+        }
+        
+        .file-tree-item {
+            display: block;
+            width: 100%;
+            padding: 0.5rem 0.75rem;
+            border: none;
+            background: none;
+            text-align: left;
+            cursor: pointer;
+            font-size: 0.875rem;
+            transition: background-color 0.2s ease;
+            border-bottom: 1px solid #f1f5f9;
+        }
+        
+        .file-tree-item:hover {
+            background: #e2e8f0;
+        }
+        
+        .file-tree-item.active {
+            background: #ddd6fe;
+            color: #4f46e5;
+            font-weight: 600;
+        }
+        
+        .file-tree-item.folder {
+            font-weight: 500;
+        }
+        
+        .file-tree-item.file {
+            padding-left: 1.5rem;
+        }
+        
+        .file-tree-item.directory {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+        
+        .file-tree-item.directory .expand-arrow {
+            font-size: 0.75rem;
+            transition: transform 0.2s ease;
+            color: #6b7280;
+        }
+        
+        .file-tree-item.directory .expand-arrow.expanded {
+            transform: rotate(90deg);
+        }
+        
+        .file-tree-children {
+            margin-left: 1rem;
+            border-left: 1px solid #e5e7eb;
+            padding-left: 0.5rem;
+        }
+        
+        .file-tree-children.collapsed {
+            display: none;
+        }
+        
+        .header-action-button {
+            background: #4f46e5;
+            color: white;
+            border: none;
+            padding: 0.375rem 0.75rem;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 0.75rem;
+            margin-left: auto;
+            transition: background-color 0.2s ease;
+        }
+        
+        .header-action-button:hover {
+            background: #4338ca;
+        }
+        
+        /* Collapsible Card Styles */
+        .collapsible-header {
+            cursor: pointer;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            transition: background-color 0.2s ease;
+        }
+        
+        .collapsible-header:hover {
+            background: #3f3cbb;
+        }
+        
+        .collapse-arrow {
+            font-size: 0.75rem;
+            transition: transform 0.2s ease;
+            color: rgba(255, 255, 255, 0.8);
+        }
+        
+        .collapse-arrow.expanded {
+            transform: rotate(180deg);
+        }
+        
+        .card-content.collapsed {
+            max-height: 0;
+            overflow: hidden;
+            padding: 0 1.5rem;
+            transition: max-height 0.3s ease, padding 0.3s ease;
+        }
+        
+        .card-content.expanded {
+            max-height: 1000px;
+            padding: 1.5rem;
+            transition: max-height 0.3s ease, padding 0.3s ease;
+        }
+        
+        /* Accordion Styles */
+        .run-accordion {
+            border-bottom: 1px solid #f3f4f6;
+        }
+        
+        .run-header {
+            width: 100%;
+            border: none;
+            background: none;
+            padding: 0;
+        }
+        
+        .accordion-arrow {
+            font-size: 0.75rem;
+            transition: transform 0.2s ease;
+            color: #6b7280;
+        }
+        
+        .accordion-arrow.expanded {
+            transform: rotate(180deg);
+        }
+        
+        .categories-accordion {
+            max-height: 0;
+            overflow: hidden;
+            transition: max-height 0.3s ease;
+            background: #f8fafc;
+        }
+        
+        .categories-accordion.expanded {
+            max-height: 500px;
+        }
+        
+        .category-accordion-item {
+            display: block;
+            width: 100%;
+            padding: 0.75rem 1rem 0.75rem 1.5rem;
+            border: none;
+            background: none;
+            text-align: left;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            border-bottom: 1px solid #f1f5f9;
+            font-size: 0.875rem;
+            min-height: 48px;
+        }
+        
+        .category-accordion-item:hover {
+            background: #e2e8f0;
+        }
+        
+        .category-accordion-item.active {
+            background: #ddd6fe;
+            border-left: 3px solid #4f46e5;
+            font-weight: 600;
+            color: #4f46e5;
+        }
+        
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 1.5rem;
+            margin-bottom: 3rem;
+        }
+        
+        .stat-card {
+            background: white;
+            padding: 2rem;
+            border-radius: 16px;
+            box-shadow: 0 8px 32px rgba(0,0,0,0.1);
+            text-align: center;
+            backdrop-filter: blur(10px);
+        }
+        
+        .stat-number {
+            font-size: 2.5rem;
+            font-weight: 700;
+            margin-bottom: 0.5rem;
+        }
+        
+        .stat-label {
+            color: #666;
+            font-size: 0.9rem;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        
+        .overall-score .stat-number {
+            color: #10b981;
+        }
+        
+        .pass-rate .stat-number {
+            color: #10b981;
+        }
+        
+        .total-tests .stat-number {
+            color: #ef4444;
+        }
+        
+        .card {
+            background: white;
+            border-radius: 4px;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+            border: 1px solid #e5e7eb;
+            overflow: hidden;
+            margin-bottom: 2rem;
+        }
+        
+        .card-header {
+            background: #4f46e5;
+            color: white;
+            padding: 1rem 1.5rem;
+            font-size: 1rem;
+            font-weight: 600;
+        }
+        
+        .card-content {
+            padding: 1.5rem;
+        }
+        
+        .table-container {
+            max-height: 600px;
+            overflow-y: auto;
+        }
+        
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        
+        th, td {
+            padding: 1rem;
+            text-align: left;
+            border-bottom: 1px solid #e5e7eb;
+        }
+        
+        th {
+            background: #f8fafc;
+            font-weight: 600;
+            color: #374151;
+            position: sticky;
+            top: 0;
+            z-index: 10;
+        }
+        
+        tr.pass {
+            background: #f0fdf4;
+        }
+        
+        tr.warning {
+            background: #fffbeb;
+        }
+        
+        tr.fail {
+            background: #fef2f2;
+        }
+        
+        /* Hover effects for clickable table rows */
+        tr[onclick] {
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+        
+        tr[onclick]:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+        
+        tr.pass[onclick]:hover {
+            background: #ecfdf5 !important;
+        }
+        
+        tr.warning[onclick]:hover {
+            background: #fefce8 !important;
+        }
+        
+        tr.fail[onclick]:hover {
+            background: #fef7f7 !important;
+        }
+        
+        tr.excellent {
+            background: #f0fdf4;
+        }
+        
+        tr.good {
+            background: #f0f9ff;
+        }
+        
+        tr.fair {
+            background: #fffbeb;
+        }
+        
+        tr.poor {
+            background: #fef2f2;
+        }
+        
+        .run-row {
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+        
+        .run-row:hover {
+            background: #f3f4f6 !important;
+            transform: translateY(-1px);
+            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+        }
+        
+        .status-icon {
+            margin-right: 0.5rem;
+        }
+        
+        .score-cell {
+            min-width: 200px;
+        }
+        
+        .score-bar-container {
+            position: relative;
+            background: #e5e7eb;
+            border-radius: 8px;
+            height: 24px;
+            overflow: hidden;
+        }
+        
+        .score-bar {
+            height: 100%;
+            background: linear-gradient(90deg, #ef4444 0%, #f59e0b 50%, #10b981 100%);
+            transition: width 0.3s ease;
+            border-radius: 8px;
+        }
+        
+        .score-text {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            font-weight: 600;
+            font-size: 0.875rem;
+            color: #374151;
+            text-shadow: 1px 1px 2px rgba(255,255,255,0.8);
+        }
+        
+        .numeric {
+            text-align: right;
+            font-family: 'SF Mono', Monaco, monospace;
+            font-weight: 500;
+        }
+        
+        .timestamp {
+            font-family: 'SF Mono', Monaco, monospace;
+            font-size: 0.875rem;
+            color: #6b7280;
+        }
+        
+        .tempdir-cell code {
+            background: #f3f4f6;
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            font-size: 0.75rem;
+            max-width: 200px;
+            display: inline-block;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+        
+        .breadcrumb {
+            background: rgba(255, 255, 255, 0.1);
+            color: white;
+            padding: 1rem;
+            border-radius: 8px;
+            margin-bottom: 2rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        
+        .breadcrumb-btn {
+            background: rgba(255, 255, 255, 0.2);
+            color: white;
+            border: none;
+            padding: 0.5rem 1rem;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            font-size: 0.875rem;
+        }
+        
+        .breadcrumb-btn:hover {
+            background: rgba(255, 255, 255, 0.3);
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+        }
+        
+        .breadcrumb-separator {
+            opacity: 0.7;
+        }
+        
+        .breadcrumb-current {
+            font-weight: 600;
+        }
+        
+        .status-text {
+            font-family: 'SF Mono', Monaco, monospace;
+            font-size: 0.875rem;
+        }
+        
+        .directory-cell {
+            font-family: 'SF Mono', Monaco, monospace;
+            font-size: 0.875rem;
+        }
+        
+        .directory-link, .log-link {
+            color: #4f46e5;
+            text-decoration: none;
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            background: #f3f4f6;
+            border: none;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            margin-right: 0.5rem;
+            font-size: 0.75rem;
+        }
+        
+        .directory-link:hover, .log-link:hover {
+            background: #e5e7eb;
+            color: #3730a3;
+            transform: translateY(-1px);
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        
+        .log-link {
+            background: #fef3c7;
+            color: #92400e;
+        }
+        
+        .log-link:hover {
+            background: #fde68a;
+            color: #78350f;
+            transform: translateY(-1px);
+            box-shadow: 0 2px 4px rgba(146,64,14,0.2);
+        }
+        
+        .view {
+            display: none;
+        }
+        
+        .view.active {
+            display: block;
+        }
+        
+        .footer {
+            text-align: center;
+            color: white;
+            opacity: 0.8;
+            margin-top: 2rem;
+        }
+        
+
+    </style>
+</head>
+<body>
+    <div class="layout">
+                 <!-- Runs Sidebar -->
+         <div class="sidebar runs-sidebar" id="runs-sidebar">
+             <div class="sidebar-header">
+                 <h3>🚀 Evaluation Runs</h3>
+                 <button class="sidebar-collapse-btn" onclick="toggleSidebar('runs-sidebar')" title="Collapse sidebar">
+                     ◀
+                 </button>
+             </div>
+             <div class="sidebar-content">
+                 ${runsSidebarHTML}
+             </div>
+         </div>
+        
+
+        
+        <!-- Evals Sidebar (shown when a category is selected) -->
+                 ${
+                   runIndex >= 0 && category
+                     ? `
+         <div class="sidebar evals-sidebar" id="evals-sidebar">
+             <div class="sidebar-header">
+                 <h3>🔍 Evaluations</h3>
+                 <button class="sidebar-collapse-btn" onclick="toggleSidebar('evals-sidebar')" title="Collapse sidebar">
+                     ◀
+                 </button>
+             </div>
+             <div class="sidebar-content">
+                 ${evalsSidebarHTML}
+             </div>
+         </div>
+         `
+                     : ""
+                 }
+        
+        <!-- Main Content -->
+        <div class="main-content">
+            ${mainContentHTML}
+        </div>
+    </div>
+    
+
+    
+    <script>
+        // Store the results data for navigation
+        const resultsData = ${JSON.stringify(results)};
+        
+        function hideAllViews() {
+            document.querySelectorAll('.view').forEach(view => {
+                view.classList.remove('active');
+            });
+        }
+        
+        function showRunsList() {
+            window.location.href = '/';
+        }
+        
+        function showRunDetails(runIndex) {
+            window.location.href = \`/run-\${runIndex}\`;
+        }
+        
+        function showCategoryDetails(category, runIndex) {
+            window.location.href = \`/run-\${runIndex}/\${category}\`;
+        }
+        
+
+        
+        // Auto-load file and line from URL fragment on page load (backup for non-output tabs)
+        document.addEventListener('DOMContentLoaded', function() {
+            const fragment = window.location.hash.slice(1);
+            if (fragment && '${selectedTab}' !== 'output' && '${selectedFile}') {
+                // Only auto-load if not already handled by output tab inline script
+                setTimeout(() => {
+                    autoLoadFileFromUrl('${selectedFile}', '${category}', '${evalName}', ${selectedLine || "null"});
+                }, 500);
+            }
+        });
+        
+        // Function to auto-load a file from URL
+        async function autoLoadFileFromUrl(filePath, category, evalName, lineNumber) {
+            console.log('Auto-loading file from URL:', filePath);
+            
+            // Wait for the file tree to be fully loaded
+            let attempts = 0;
+            const maxAttempts = 10;
+            
+            const tryToLoadFile = () => {
+                const fileButtons = document.querySelectorAll(\`#file-tree-content-\${category}-\${evalName} .file-tree-item\`);
+                console.log(\`Attempt \${attempts + 1}: Found \${fileButtons.length} file buttons\`);
+                
+                for (const button of fileButtons) {
+                    const buttonPath = button.getAttribute('onclick');
+                    const buttonTitle = button.getAttribute('title');
+                    
+                    console.log('Checking button - Title:', buttonTitle, 'Path in onclick:', buttonPath);
+                    
+                    // Extract the actual file path from the onclick attribute
+                    let extractedPath = '';
+                    let fileName = '';
+                    if (buttonPath) {
+                        // Extract path and filename from onclick="loadFile('path', 'name', ...)"
+                        const loadFileRegex = new RegExp("loadFile\\\\('([^']+)',\\\\s*'([^']+)'");
+                        const pathMatch = buttonPath.match(loadFileRegex);
+                        if (pathMatch) {
+                            extractedPath = pathMatch[1].replace(/\\\\\\\\/g, '/').replace(/\\\\/g, '/');
+                            fileName = pathMatch[2];
+                        }
+                    }
+                    
+                    console.log('Extracted path:', extractedPath, 'fileName:', fileName, 'Target path:', filePath);
+                    
+                    // Check if this button matches our file path (exact match or ends with the relative path)
+                    const isExactMatch = extractedPath === filePath;
+                    const isRelativeMatch = extractedPath.endsWith(filePath) && extractedPath.includes('/');
+                    const isFileNameMatch = buttonTitle === filePath.split('/').pop() && filePath.includes('/');
+                    
+                    if (isExactMatch || isRelativeMatch || isFileNameMatch) {
+                        console.log('Found matching file, loading directly:', fileName, 'Match type:', 
+                                   isExactMatch ? 'exact' : isRelativeMatch ? 'relative' : 'filename');
+                        
+                        // Load the file directly instead of clicking the button
+                        loadFile(extractedPath, fileName, category, evalName);
+                        
+                        // Mark the button as active
+                        const treeItems = document.querySelectorAll(\`#file-tree-content-\${category}-\${evalName} .file-tree-item\`);
+                        treeItems.forEach(item => item.classList.remove('active'));
+                        button.classList.add('active');
+                        
+                        // If we have a line number, scroll to it after the file loads
+                        if (lineNumber) {
+                            setTimeout(() => {
+                                console.log('Scrolling to line:', lineNumber);
+                                scrollToLineNumber(lineNumber, category, evalName);
+                            }, 1500);
+                        }
+                        return true;
+                    }
+                }
+                return false;
+            };
+            
+            // Try to load the file, with retries
+            const loadWithRetry = () => {
+                if (tryToLoadFile()) {
+                    return; // Success
+                }
+                
+                attempts++;
+                if (attempts < maxAttempts) {
+                    console.log(\`File not found yet, retrying in 200ms... (attempt \${attempts}/\${maxAttempts})\`);
+                    setTimeout(loadWithRetry, 200);
+                } else {
+                    console.log(\`File not found after \${maxAttempts} attempts: \${filePath}\`);
+                }
+            };
+            
+            loadWithRetry();
+        }
+        
+        function showEvalDetails(evalName, runIndex, category) {
+            window.location.href = \`/run-\${runIndex}/\${category}/\${evalName}\`;
+        }
+        
+        function toggleRunAccordion(runIndex) {
+            // Navigate to the run and let the accordion expand
+            window.location.href = \`/run-\${runIndex}\`;
+        }
+        
+                 function switchTab(tabName, category, evalName) {
+             // Hide all tab panes for this eval
+             const tabPanes = document.querySelectorAll(\`[id$="-tab-\${category}-\${evalName}"]\`);
+             tabPanes.forEach(pane => pane.classList.remove('active'));
+             
+             // Remove active class from all tab buttons
+             const tabButtons = document.querySelectorAll(\`[onclick*="switchTab"][onclick*="'\${category}'"][onclick*="'\${evalName}'"]\`);
+             tabButtons.forEach(button => button.classList.remove('active'));
+             
+             // Show the selected tab pane
+             const selectedPane = document.getElementById(\`\${tabName}-tab-\${category}-\${evalName}\`);
+             if (selectedPane) {
+                 selectedPane.classList.add('active');
+             }
+             
+             // Add active class to the clicked button
+             event.target.classList.add('active');
+             
+             // Update URL to include tab
+             updateURL(category, evalName, tabName);
+             
+             // Load answer directory if answer tab is selected
+             if (tabName === 'answer') {
+                 loadAnswerDirectory(category, evalName);
+             }
+         }
+
+        function toggleCollapse(sectionId) {
+            const content = document.getElementById(\`\${sectionId}-content\`);
+            const arrow = document.getElementById(\`\${sectionId}-arrow\`);
+            
+            if (content && arrow) {
+                if (content.classList.contains('collapsed')) {
+                    content.classList.remove('collapsed');
+                    content.classList.add('expanded');
+                    arrow.classList.add('expanded');
+                } else {
+                    content.classList.remove('expanded');
+                    content.classList.add('collapsed');
+                    arrow.classList.remove('expanded');
+                }
+            }
+        }
+        
+        async function loadTaskFile(directoryPath, category, evalName) {
+            try {
+                const response = await fetch(\`/task/\${encodeURIComponent(category)}/\${encodeURIComponent(evalName)}\`);
+                if (response.ok) {
+                    const data = await response.json();
+                    const taskContent = document.querySelector('.task-content');
+                    if (taskContent) {
+                        taskContent.innerHTML = \`<pre style="white-space: pre-wrap; background: #f8fafc; padding: 1rem; border-radius: 6px; border: 1px solid #e5e7eb;">\${data.content}</pre>\`;
+                    }
+                } else {
+                    const taskContent = document.querySelector('.task-content');
+                    if (taskContent) {
+                        taskContent.innerHTML = '<p style="color: #dc2626;">Task file not found or could not be loaded.</p>';
+                    }
+                }
+            } catch (error) {
+                const taskContent = document.querySelector('.task-content');
+                if (taskContent) {
+                    taskContent.innerHTML = \`<p style="color: #dc2626;">Error loading task file: \${error.message}</p>\`;
+                }
+            }
+        }
+        
+        async function toggleDirectory(dirPath, dirName, category, evalName) {
+            // Create a safe ID by encoding the path
+            const safeId = btoa(dirPath).replace(/[^a-zA-Z0-9]/g, '');
+            const childrenContainer = document.getElementById(\`children-\${safeId}\`);
+            
+            // Find the arrow within the button that was clicked
+            const button = event.target.closest('.file-tree-item.directory');
+            const arrow = button ? button.querySelector('.expand-arrow') : null;
+            
+            if (!childrenContainer) {
+                console.error('Children container not found for:', dirPath);
+                return;
+            }
+            
+            if (childrenContainer.classList.contains('collapsed')) {
+                // Expand directory
+                console.log('Expanding directory:', dirPath);
+                try {
+                    const response = await fetch(\`/browse/\${encodeURIComponent(dirPath)}\`);
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.files) {
+                            const childrenHTML = data.files.map(file => {
+                                const childSafeId = btoa(file.path).replace(/[^a-zA-Z0-9]/g, '');
+                                if (file.isDirectory) {
+                                    return \`
+                                        <div class="directory-container">
+                                            <button class="file-tree-item directory" onclick="toggleDirectory('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '\${category}', '\${evalName}')">
+                                                <span>📁 \${file.name}</span>
+                                                <span class="expand-arrow">▶</span>
+                                            </button>
+                                            <div class="file-tree-children collapsed" id="children-\${childSafeId}"></div>
+                                        </div>
+                                    \`;
+                                } else {
+                                    return \`<button class="file-tree-item file" onclick="loadFile('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '\${category}', '\${evalName}')" title="\${file.name}">📄 \${file.name}</button>\`;
+                                }
+                            }).join('');
+                            childrenContainer.innerHTML = childrenHTML;
+                        }
+                    } else {
+                        console.error('Failed to fetch directory:', response.status);
+                        childrenContainer.innerHTML = '<p style="color: #dc2626; padding: 0.5rem;">Error loading directory</p>';
+                    }
+                } catch (error) {
+                    console.error('Error fetching directory:', error);
+                    childrenContainer.innerHTML = '<p style="color: #dc2626; padding: 0.5rem;">Error loading directory</p>';
+                }
+                
+                childrenContainer.classList.remove('collapsed');
+                if (arrow) arrow.classList.add('expanded');
+            } else {
+                // Collapse directory
+                console.log('Collapsing directory:', dirPath);
+                childrenContainer.classList.add('collapsed');
+                if (arrow) arrow.classList.remove('expanded');
+            }
+        }
+
+        function getLanguageFromFileName(fileName) {
+            const ext = fileName.split('.').pop().toLowerCase();
+            const languageMap = {
+                'js': 'javascript',
+                'jsx': 'javascript',
+                'ts': 'typescript',
+                'tsx': 'typescript',
+                'py': 'python',
+                'json': 'json',
+                'html': 'html',
+                'css': 'css',
+                'scss': 'scss',
+                'md': 'markdown',
+                'yaml': 'yaml',
+                'yml': 'yaml',
+                'xml': 'xml',
+                'sql': 'sql',
+                'sh': 'bash',
+                'bash': 'bash',
+                'log': 'log',
+                'txt': 'text'
+            };
+            return languageMap[ext] || 'text';
+        }
+
+        async function loadFile(filePath, fileName, category, evalName) {
+            try {
+                // Update active state in file tree
+                const treeItems = document.querySelectorAll(\`#file-tree-content-\${category}-\${evalName} .file-tree-item\`);
+                treeItems.forEach(item => item.classList.remove('active'));
+                
+                // Only update active state if event.target exists (when clicked)
+                if (typeof event !== 'undefined' && event.target) {
+                    event.target.classList.add('active');
+                }
+                
+                                 // Update file name in header
+                 const fileNameElement = document.getElementById(\`current-file-name-\${category}-\${evalName}\`);
+                 if (fileNameElement) {
+                     fileNameElement.textContent = fileName;
+                 }
+                 
+                 // Update URL to include the selected file
+                 updateURL(category, evalName, 'output', fileName);
+                
+                // Load file content
+                const response = await fetch(\`/file/\${encodeURIComponent(filePath)}\`);
+                const contentElement = document.getElementById(\`file-content-\${category}-\${evalName}\`);
+                
+                if (response.ok) {
+                    const data = await response.json();
+                    if (contentElement) {
+                        const language = getLanguageFromFileName(fileName);
+                        const isLogFile = fileName.endsWith('.log') || fileName.endsWith('.txt');
+                        
+                                                 if (isLogFile || language === 'text' || language === 'log') {
+                             // For log files and plain text, use simple styling
+                             const style = isLogFile 
+                                 ? 'white-space: pre-wrap; background: #1f2937; color: #f3f4f6; padding: 1rem; margin: 0; font-family: "Monaco", "Menlo", "Ubuntu Mono", monospace; font-size: 0.875rem; line-height: 1.4; height: 100%; overflow-y: auto;'
+                                 : 'white-space: pre-wrap; background: #f8fafc; color: #374151; padding: 1rem; margin: 0; font-family: "Monaco", "Menlo", "Ubuntu Mono", monospace; font-size: 0.875rem; line-height: 1.4; height: 100%; overflow-y: auto; border: 1px solid #e5e7eb;';
+                             
+                             contentElement.innerHTML = \`<pre style="\${style}">\${data.content}</pre>\`;
+                         } else {
+                             // Create Monaco editor container
+                             const editorId = \`monaco-editor-main-\${category}-\${evalName}-\${Date.now()}\`;
+                             contentElement.innerHTML = \`<div id="\${editorId}" class="monaco-editor-container"></div>\`;
+                             
+                             // Create Monaco editor
+                             setTimeout(() => {
+                                 createMonacoEditor(editorId, data.content, language);
+                             }, 100);
+                         }
+                        
+                        // Try to load corresponding answer file for split view
+                        await loadCorrespondingAnswerFile(filePath, fileName, category, evalName);
+                    }
+                } else {
+                    if (contentElement) {
+                        contentElement.innerHTML = '<p style="color: #dc2626; padding: 1rem;">File not found or could not be loaded.</p>';
+                    }
+                }
+            } catch (error) {
+                const contentElement = document.getElementById(\`file-content-\${category}-\${evalName}\`);
+                if (contentElement) {
+                    contentElement.innerHTML = \`<p style="color: #dc2626; padding: 1rem;">Error loading file: \${error.message}</p>\`;
+                }
+            }
+        }
+        
+        async function loadCorrespondingAnswerFile(outputFilePath, fileName, category, evalName) {
+            try {
+                console.log('Trying to find answer for:', outputFilePath, 'fileName:', fileName);
+                
+                // Convert output file path to answer file path
+                // Example: /path/to/output/gpt-5/000-fundamentals/007-basic_file_storage/convex/index.ts
+                // Should become: evals/000-fundamentals/007-basic_file_storage/answer/convex/index.ts
+                
+                // Normalize path separators for both Windows and Unix
+                const normalizedPath = outputFilePath.replace(/\\\\/g, '/');
+                const pathParts = normalizedPath.split('/');
+                console.log('Path parts:', pathParts);
+                
+                // Find the category and eval name in the path
+                const categoryIndex = pathParts.findIndex(part => part === category);
+                const evalIndex = pathParts.findIndex(part => part === evalName);
+                
+                if (categoryIndex === -1 || evalIndex === -1) {
+                    console.log('Category or eval not found in path');
+                    return;
+                }
+                
+                // Get the relative path after the eval name
+                const relativePathParts = pathParts.slice(evalIndex + 1);
+                console.log('Relative path parts:', relativePathParts);
+                
+                // Build answer path: evals/category/evalName/answer/relativePath
+                const answerFilePath = \`evals/\${category}/\${evalName}/answer/\${relativePathParts.join('/')}\`;
+                console.log('Trying answer path:', answerFilePath);
+                
+                // Try to load the answer file
+                const response = await fetch(\`/file/\${encodeURIComponent(answerFilePath)}\`);
+                const answerPane = document.getElementById(\`answer-pane-\${category}-\${evalName}\`);
+                const answerContentElement = document.getElementById(\`answer-content-\${category}-\${evalName}\`);
+                
+                if (response.ok && answerContentElement) {
+                    console.log('Answer file found! Loading content...');
+                    const data = await response.json(); // Back to json() since endpoint returns JSON
+                    const content = data.content;
+                    const language = getLanguageFromFileName(fileName);
+                    const isLogFile = fileName.endsWith('.log') || fileName.endsWith('.txt');
+                    
+                         // Create Monaco editor container for answer
+                         const answerEditorId = \`monaco-answer-editor-\${category}-\${evalName}-\${Date.now()}\`;
+                         answerContentElement.innerHTML = \`<div id="\${answerEditorId}" class="monaco-editor-container"></div>\`;
+                         
+                         // Create Monaco editor for answer
+                         setTimeout(() => {
+                             createMonacoEditor(answerEditorId, content, language);
+                         }, 100);
+                    
+                    // Show the answer pane
+                    if (answerPane) {
+                        answerPane.style.display = 'flex';
+                        console.log('Answer pane shown');
+                    }
+                } else {
+                    console.log('No answer file found, response status:', response.status);
+                    // Hide the answer pane if no corresponding file found
+                    if (answerPane) {
+                        answerPane.style.display = 'none';
+                    }
+                }
+            } catch (error) {
+                // Hide the answer pane on error
+                const answerPane = document.getElementById(\`answer-pane-\${category}-\${evalName}\`);
+                if (answerPane) {
+                    answerPane.style.display = 'none';
+                }
+            }
+        }
+        
+        // Directory and log functions
+        function copyDirectoryPath(path) {
+            navigator.clipboard.writeText(path).then(() => {
+                // Show a brief success indicator
+                const button = event.target;
+                const originalText = button.textContent;
+                button.textContent = '✓';
+                button.style.background = '#10b981';
+                setTimeout(() => {
+                    button.textContent = originalText;
+                    button.style.background = '#4f46e5';
+                }, 1000);
+            }).catch(() => {
+                // Fallback for older browsers
+                prompt("Copy this directory path:", path);
+            });
+        }
+
+        function openDirectory(path) {
+            // Try different methods to open directory
+            if (window.electronAPI) {
+                // If running in Electron
+                window.electronAPI.openPath(path);
+            } else {
+                // Fallback: copy path to clipboard and show message
+                navigator.clipboard.writeText(path).then(() => {
+                    alert(\`Directory path copied to clipboard:\\n\${path}\\n\\nPaste this into your file explorer.\`);
+                }).catch(() => {
+                    prompt('Copy this directory path:', path);
+                });
+            }
+        }
+        
+        function viewLog(logPath) {
+            // Open log in a new window/tab
+            const encodedPath = encodeURIComponent(logPath);
+            const logUrl = \`/logs/\${encodedPath}\`;
+            window.open(logUrl, '_blank', 'width=1000,height=600,scrollbars=yes,resizable=yes');
+        }
+        
+        // Auto-refresh disabled for better user experience
+        // setTimeout(() => {
+        //     window.location.reload();
+        // }, 30000);
+        
+                 // Debug function to test answer loading
+         window.testAnswerLoad = function(category, evalName) {
+             console.log('Testing answer load for:', category, evalName);
+             const testPath = \`C:\\\\Users\\\\mikec\\\\AppData\\\\Local\\\\Temp\\\\tmp123/output/gpt-5/\${category}/\${evalName}/convex/index.ts\`;
+             loadCorrespondingAnswerFile(testPath, 'index.ts', category, evalName);
+         };
+         
+         // Split pane resizing functionality
+         let isResizing = false;
+         let currentSplitContainer = null;
+         
+         function initSplitResize(event, category, evalName) {
+             isResizing = true;
+             currentSplitContainer = document.getElementById(\`file-content-split-\${category}-\${evalName}\`);
+             
+             // Prevent text selection during drag
+             document.body.style.userSelect = 'none';
+             document.body.style.cursor = 'col-resize';
+             
+             // Add event listeners
+             document.addEventListener('mousemove', handleSplitResize);
+             document.addEventListener('mouseup', stopSplitResize);
+             
+             event.preventDefault();
+         }
+         
+         function handleSplitResize(event) {
+             if (!isResizing || !currentSplitContainer) return;
+             
+             const containerRect = currentSplitContainer.getBoundingClientRect();
+             const mouseX = event.clientX;
+             const containerLeft = containerRect.left;
+             const containerWidth = containerRect.width;
+             
+             // Calculate percentage (between 20% and 80%)
+             let percentage = ((mouseX - containerLeft) / containerWidth) * 100;
+             percentage = Math.max(20, Math.min(80, percentage));
+             
+             // Update the flex basis of the first pane
+             const firstPane = currentSplitContainer.querySelector('.file-content-pane:first-child');
+             if (firstPane) {
+                 firstPane.style.flex = \`0 0 \${percentage}%\`;
+             }
+         }
+         
+         function stopSplitResize() {
+             isResizing = false;
+             currentSplitContainer = null;
+             
+             // Restore normal cursor and text selection
+             document.body.style.userSelect = '';
+             document.body.style.cursor = '';
+             
+             // Remove event listeners
+             document.removeEventListener('mousemove', handleSplitResize);
+             document.removeEventListener('mouseup', stopSplitResize);
+         }
+         
+         // Sidebar collapse/expand functionality
+         function toggleSidebar(sidebarId) {
+             const sidebar = document.getElementById(sidebarId);
+             const button = sidebar.querySelector('.sidebar-collapse-btn');
+             
+             if (sidebar.classList.contains('collapsed')) {
+                 // Expand
+                 sidebar.classList.remove('collapsed');
+                 button.innerHTML = '◀';
+                 button.title = 'Collapse sidebar';
+             } else {
+                 // Collapse
+                 sidebar.classList.add('collapsed');
+                 button.innerHTML = '▶';
+                 button.title = 'Expand sidebar';
+             }
+         }
+         
+
+         
+         // Function to scroll to a specific line number in Monaco Editor
+         function scrollToLineNumber(lineNumber, category, evalName) {
+             console.log('Scrolling to line number:', lineNumber);
+             
+             // Find the Monaco editor for this file
+             for (const [containerId, editor] of editors.entries()) {
+                 if (containerId.includes(category) && containerId.includes(evalName) && !containerId.includes('answer')) {
+                     console.log('Found editor for scrolling:', containerId);
+                     
+                     // Scroll to the line and highlight it
+                     editor.revealLineInCenter(lineNumber);
+                     editor.setPosition({ lineNumber: lineNumber, column: 1 });
+                     
+                     // Highlight the line temporarily
+                     const decoration = editor.deltaDecorations([], [{
+                         range: new monaco.Range(lineNumber, 1, lineNumber, 1),
+                         options: {
+                             isWholeLine: true,
+                             className: 'highlight-line',
+                             linesDecorationsClassName: 'highlight-line-gutter'
+                         }
+                     }]);
+                     
+                     // Remove highlight after 3 seconds
+                     setTimeout(() => {
+                         editor.deltaDecorations(decoration, []);
+                     }, 3000);
+                     
+                     break;
+                 }
+             }
+         }
+         
+         // Function to update URL with current tab and file
+         function updateURL(category, evalName, tab, fileName) {
+             const runIndex = getCurrentRunIndex();
+             let url = \`/run-\${runIndex}/\${category}/\${evalName}\`;
+             
+             if (tab) {
+                 url += \`/\${tab}\`;
+                 if (fileName && (tab === 'output' || tab === 'answer')) {
+                     url += \`#\${encodeURIComponent(fileName)}\`;
+                 }
+             }
+             
+             // Update URL without triggering page reload
+             window.history.replaceState({}, '', url);
+         }
+        
+        // Answer directory functions
+        async function loadAnswerDirectory(category, evalName) {
+            try {
+                const answerPath = 'evals/' + category + '/' + evalName + '/answer';
+                const response = await fetch(\`/browse/\${encodeURIComponent(answerPath)}\`);
+                const treeElement = document.getElementById(\`answer-file-tree-content-\${category}-\${evalName}\`);
+                
+                if (response.ok) {
+                    const data = await response.json();
+                    if (treeElement && data.files) {
+                        const fileTreeHTML = data.files.map(file => {
+                            const safeId = btoa(file.path).replace(/[^a-zA-Z0-9]/g, '');
+                            if (file.isDirectory) {
+                                return \`
+                                    <div class="directory-container">
+                                        <button class="file-tree-item directory" onclick="toggleAnswerDirectory('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '\${category}', '\${evalName}')">
+                                            <span>📁 \${file.name}</span>
+                                            <span class="expand-arrow">▶</span>
+                                        </button>
+                                        <div class="file-tree-children collapsed" id="answer-children-\${safeId}"></div>
+                                    </div>
+                                \`;
+                            } else {
+                                return \`<button class="file-tree-item file" onclick="loadAnswerFile('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '\${category}', '\${evalName}')" title="\${file.name}">📄 \${file.name}</button>\`;
+                            }
+                        }).join('');
+                        treeElement.innerHTML = fileTreeHTML;
+                    }
+                } else {
+                    if (treeElement) {
+                        treeElement.innerHTML = '<p style="color: #dc2626;">Answer directory not found.</p>';
+                    }
+                }
+            } catch (error) {
+                const treeElement = document.getElementById(\`answer-file-tree-content-\${category}-\${evalName}\`);
+                if (treeElement) {
+                    treeElement.innerHTML = \`<p style="color: #dc2626;">Error loading answer directory: \${error.message}</p>\`;
+                }
+            }
+        }
+        
+        async function toggleAnswerDirectory(dirPath, dirName, category, evalName) {
+            const safeId = btoa(dirPath).replace(/[^a-zA-Z0-9]/g, '');
+            const childrenContainer = document.getElementById(\`answer-children-\${safeId}\`);
+            const button = event.target.closest('.file-tree-item.directory');
+            const arrow = button ? button.querySelector('.expand-arrow') : null;
+            
+            if (!childrenContainer) return;
+            
+            if (childrenContainer.classList.contains('collapsed')) {
+                try {
+                    const response = await fetch(\`/browse/\${encodeURIComponent(dirPath)}\`);
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.files) {
+                            const childrenHTML = data.files.map(file => {
+                                const childSafeId = btoa(file.path).replace(/[^a-zA-Z0-9]/g, '');
+                                if (file.isDirectory) {
+                                    return \`
+                                        <div class="directory-container">
+                                            <button class="file-tree-item directory" onclick="toggleAnswerDirectory('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '\${category}', '\${evalName}')">
+                                                <span>📁 \${file.name}</span>
+                                                <span class="expand-arrow">▶</span>
+                                            </button>
+                                            <div class="file-tree-children collapsed" id="answer-children-\${childSafeId}"></div>
+                                        </div>
+                                    \`;
+                                } else {
+                                    return \`<button class="file-tree-item file" onclick="loadAnswerFile('\${file.path.replace(/\\\\/g, '\\\\\\\\')}', '\${file.name}', '\${category}', '\${evalName}')" title="\${file.name}">📄 \${file.name}</button>\`;
+                                }
+                            }).join('');
+                            childrenContainer.innerHTML = childrenHTML;
+                        }
+                    }
+                } catch (error) {
+                    childrenContainer.innerHTML = '<p style="color: #dc2626; padding: 0.5rem;">Error loading directory</p>';
+                }
+                
+                childrenContainer.classList.remove('collapsed');
+                if (arrow) arrow.classList.add('expanded');
+            } else {
+                childrenContainer.classList.add('collapsed');
+                if (arrow) arrow.classList.remove('expanded');
+            }
+        }
+        
+        async function loadAnswerFile(filePath, fileName, category, evalName) {
+            try {
+                const treeItems = document.querySelectorAll(\`#answer-file-tree-content-\${category}-\${evalName} .file-tree-item\`);
+                treeItems.forEach(item => item.classList.remove('active'));
+                
+                if (typeof event !== 'undefined' && event.target) {
+                    event.target.classList.add('active');
+                }
+                
+                                 const fileNameElement = document.getElementById(\`answer-current-file-name-\${category}-\${evalName}\`);
+                 if (fileNameElement) {
+                     fileNameElement.textContent = fileName;
+                 }
+                 
+                 // Update URL to include the selected answer file
+                 updateURL(category, evalName, 'answer', fileName);
+                
+                const response = await fetch(\`/file/\${encodeURIComponent(filePath)}\`);
+                const contentElement = document.getElementById(\`answer-file-content-\${category}-\${evalName}\`);
+                
+                if (response.ok) {
+                    const data = await response.json();
+                    if (contentElement) {
+                        const language = getLanguageFromFileName(fileName);
+                        const isLogFile = fileName.endsWith('.log') || fileName.endsWith('.txt');
+                        
+                                                 // Create Monaco editor container
+                         const editorId = \`monaco-editor-\${category}-\${evalName}-\${Date.now()}\`;
+                         contentElement.innerHTML = \`<div id="\${editorId}" class="monaco-editor-container"></div>\`;
+                         
+                         // Create Monaco editor
+                         setTimeout(() => {
+                             createMonacoEditor(editorId, data.content, language);
+                         }, 100);
+                    }
+                } else {
+                    if (contentElement) {
+                        contentElement.innerHTML = '<p style="color: #dc2626; padding: 1rem;">File not found or could not be loaded.</p>';
+                    }
+                }
+            } catch (error) {
+                const contentElement = document.getElementById(\`answer-file-content-\${category}-\${evalName}\`);
+                if (contentElement) {
+                    contentElement.innerHTML = \`<p style="color: #dc2626; padding: 1rem;">Error loading file: \${error.message}</p>\`;
+                }
+            }
+        }
+    </script>
+</body>
+</html>
+  `;
+}
+
+async function startServer() {
+  console.log(
+    `🚀 Starting Convex Evaluation Visualizer on http://localhost:${PORT}`,
+  );
+  console.log(`📊 Reading data from: ${RESULTS_FILE}`);
+
+  const server = Bun.serve({
+    port: PORT,
+    fetch(req) {
+      const url = new URL(req.url);
+      const pathParts = url.pathname.split("/").filter((p) => p.length > 0);
+      const fragment = url.hash.slice(1); // Remove the # character
+
+      try {
+        const results = readJsonlResults();
+
+        // Serve log files
+        if (pathParts[0] === "logs") {
+          try {
+            const logPath = decodeURIComponent(pathParts.slice(1).join("/"));
+            const fs = require("fs");
+
+            if (fs.existsSync(logPath)) {
+              const logContent = fs.readFileSync(logPath, "utf-8");
+              return new Response(logContent, {
+                headers: { "Content-Type": "text/plain" },
+              });
+            } else {
+              return new Response("Log file not found", { status: 404 });
+            }
+          } catch (err) {
+            return new Response("Error reading log file", { status: 500 });
+          }
+        }
+
+        // Handle task file requests
+        if (pathParts[0] === "task") {
+          try {
+            const category = decodeURIComponent(pathParts[1] || "");
+            const evalName = decodeURIComponent(pathParts[2] || "");
+            const fs = require("fs");
+            const path = require("path");
+
+            // Look for TASK.txt in the eval directory
+            const taskPath = path.join("evals", category, evalName, "TASK.txt");
+
+            if (!fs.existsSync(taskPath)) {
+              return new Response("Task file not found", { status: 404 });
+            }
+
+            const content = fs.readFileSync(taskPath, "utf-8");
+            return new Response(JSON.stringify({ content }), {
+              headers: { "Content-Type": "application/json" },
+            });
+          } catch (err) {
+            return new Response("Error reading task file", { status: 500 });
+          }
+        }
+
+        // Handle directory listing requests
+        if (pathParts[0] === "browse") {
+          try {
+            const dirPath = decodeURIComponent(pathParts.slice(1).join("/"));
+            const fs = require("fs");
+            const path = require("path");
+
+            if (!fs.existsSync(dirPath)) {
+              return new Response("Directory not found", { status: 404 });
+            }
+
+            const items = fs.readdirSync(dirPath, { withFileTypes: true });
+            const fileTree = items.map((item: any) => ({
+              name: item.name,
+              isDirectory: item.isDirectory(),
+              path: path.join(dirPath, item.name),
+            }));
+
+            return new Response(JSON.stringify({ files: fileTree }), {
+              headers: { "Content-Type": "application/json" },
+            });
+          } catch (err) {
+            return new Response("Error reading directory", { status: 500 });
+          }
+        }
+
+        // Handle file content requests
+        if (pathParts[0] === "file") {
+          try {
+            const filePath = decodeURIComponent(pathParts.slice(1).join("/"));
+            const fs = require("fs");
+
+            if (!fs.existsSync(filePath)) {
+              return new Response("File not found", { status: 404 });
+            }
+
+            const content = fs.readFileSync(filePath, "utf-8");
+            return new Response(JSON.stringify({ content }), {
+              headers: { "Content-Type": "application/json" },
+            });
+          } catch (err) {
+            return new Response("Error reading file", { status: 500 });
+          }
+        }
+
+        // Route handling
+        let currentView = "runs-list";
+        let runIndex = -1;
+        let category = "";
+        let evalName = "";
+        let selectedTab = "log"; // Default tab
+        let selectedFile = "";
+        let selectedLine = null;
+
+        // Parse file and line from URL fragment (e.g., #convex/index.ts:42)
+        if (fragment) {
+          const colonIndex = fragment.lastIndexOf(":");
+          if (colonIndex > 0 && /^\d+$/.test(fragment.slice(colonIndex + 1))) {
+            // Fragment has line number
+            selectedFile = decodeURIComponent(fragment.slice(0, colonIndex));
+            selectedLine = parseInt(fragment.slice(colonIndex + 1));
+          } else {
+            // Fragment is just a file path
+            selectedFile = decodeURIComponent(fragment);
+          }
+        }
+
+        if (pathParts.length >= 1) {
+          // Parse run index from path
+          const runPart = pathParts[0];
+          if (runPart.startsWith("run-")) {
+            runIndex = parseInt(runPart.replace("run-", ""));
+            if (runIndex >= 0 && runIndex < results.length) {
+              const result = results[runIndex];
+
+              if (pathParts.length >= 2) {
+                category = pathParts[1];
+
+                if (pathParts.length >= 3) {
+                  evalName = pathParts[2];
+
+                  // Check if there's a tab specified
+                  if (pathParts.length >= 4) {
+                    selectedTab = pathParts[3];
+                  }
+
+                  currentView = "eval-details";
+                } else {
+                  // Auto-select first eval when clicking a category
+                  const categoryResults = (
+                    result.individual_results || []
+                  ).filter((r) => r.category === category);
+                  if (categoryResults.length > 0) {
+                    evalName = categoryResults[0].name;
+                    currentView = "eval-details";
+                  } else {
+                    currentView = "category-details";
+                  }
+                }
+              } else {
+                // Auto-select first category when opening a run
+                const categories = Object.keys(result.category_summaries || {});
+                if (categories.length > 0) {
+                  category = categories[0];
+                  currentView = "category-details";
+
+                  // Auto-select first eval in first category
+                  const categoryResults = (
+                    result.individual_results || []
+                  ).filter((r) => r.category === category);
+                  if (categoryResults.length > 0) {
+                    evalName = categoryResults[0].name;
+                    currentView = "eval-details";
+                  }
+                } else {
+                  currentView = "run-details";
+                }
+              }
+            }
+          }
+        }
+
+        const html = generateHTML(
+          results,
+          currentView,
+          runIndex,
+          category,
+          evalName,
+          selectedTab,
+          selectedFile,
+          selectedLine,
+        );
+        return new Response(html, {
+          headers: { "Content-Type": "text/html" },
+        });
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        console.error("Error reading results:", errorMessage);
+
+        const errorHtml = `
+          <!DOCTYPE html>
+          <html>
+          <head>
+              <title>Error - Convex Evaluation Visualizer</title>
+              <style>
+                  body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; padding: 2rem; background: #f3f4f6; }
+                  .error { background: white; padding: 2rem; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); }
+                  .error h1 { color: #dc2626; margin-bottom: 1rem; }
+                  .error p { color: #6b7280; line-height: 1.6; }
+                  .error code { background: #f3f4f6; padding: 0.25rem 0.5rem; border-radius: 4px; }
+              </style>
+          </head>
+          <body>
+              <div class="error">
+                  <h1>❌ Error Loading Results</h1>
+                  <p><strong>Error:</strong> ${errorMessage}</p>
+                  <p>Make sure you have run some evaluations and that <code>local_results.jsonl</code> exists in the project root.</p>
+                  <p>Try running: <code>npm run local:run:one</code></p>
+                  <p>Note: You may need to run evaluations again to generate the enhanced result format with individual evaluation details.</p>
+              </div>
+          </body>
+          </html>
+        `;
+
+        return new Response(errorHtml, {
+          status: 500,
+          headers: { "Content-Type": "text/html" },
+        });
+      }
+    },
+  });
+
+  console.log(`✅ Server running at http://localhost:${server.port}`);
+  console.log(`📝 Press Ctrl+C to stop`);
+}
+
+// Handle graceful shutdown
+process.on("SIGINT", () => {
+  console.log("\n👋 Shutting down server...");
+  process.exit(0);
+});
+
+// Start the server
+if (import.meta.main) {
+  await startServer();
+}
diff --git a/tsconfig.evals.json b/tsconfig.evals.json
new file mode 100644
index 0000000..6718a13
--- /dev/null
+++ b/tsconfig.evals.json
@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["evals/**/*"],
+}
+