@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/evals/results/2026-10-05-ga-gate/contaminated-run.json

@@ -0,0 +1,55 @@
+{
+ "run": "react-wallet/v4#14",
+ "contaminated": true,
+ "audit": {
+  "auditable": true,
+  "toolCalls": 9,
+  "attempts": 1,
+  "violations": [
+   {
+    "tool": "Read",
+    "value": "/private/var/folders/f8/k3ttpp4d5ns4shtytwf375ym0000gn/T/ic-reactor-eval-batch-eEb7SZ/react-wallet--v4--014/home/.claude/projects/-private-var-folders-f8-k3ttpp4d5ns4shtytwf375ym0000gn-T-ic-reactor-eval-batch-eEb7SZ-react-wallet--v4--014-work/3df55d72-125e-42cd-81c2-b4a872b1d515/tool-results/b65qfoxqg.txt",
+    "resolved": "/private/var/folders/f8/k3ttpp4d5ns4shtytwf375ym0000gn/T/ic-reactor-eval-batch-eEb7SZ/react-wallet--v4--014/home/.claude/projects/-private-var-folders-f8-k3ttpp4d5ns4shtytwf375ym0000gn-T-ic-reactor-eval-batch-eEb7SZ-react-wallet--v4--014-work/3df55d72-125e-42cd-81c2-b4a872b1d515/tool-results/b65qfoxqg.txt",
+    "reason": "file_path outside the run directory",
+    "blocked": false
+   }
+  ]
+ },
+ "producer": {
+  "tool_call": {
+   "tool": "Bash",
+   "input": {
+    "command": "cat docs/llms.txt src/Wallet.tsx src/main.tsx; cat src/generated/icrc1.ts | head -80; cat test/support/world.ts test/support/auth.ts; cat TASK.md | head -5"
+   }
+  },
+  "tool_result": "<persisted-output>\nOutput too large (29.6KB). Full output saved to: /private/var/folders/f8/k3ttpp4d5ns4shtytwf375ym0000gn/T/ic-reactor-eval-batch-eEb7SZ/react-wallet--v4--014/home/.claude/projects/-private-var-folders-f8-k3ttpp4d5ns4shtytwf375ym0000gn-T-ic-reactor-eval-batch-eEb7SZ-react-wallet--v4--014-work/3df55d72-125e-42cd-81c2-b4a872b1d515/tool-results/b65qfoxqg.txt\n\nPreview (first 2KB):\n# @ic-reactor/core\n\n> How to call Internet Computer canisters with a module `candid-core-cli gen`\n> generated from a `.did`, a client from `@ic-reactor/core`, and TanStack\n> Query. The client applies the rules a hand-written integration must get\n> right; this guide names the call for each.\n\nApplies to `@ic-reactor/core` 4.0.0-beta.1.\n\n## Imports\n\n```ts\nimport { createClient, formatUnits, isReactorError, parseUnits } from \"@ic-reactor/core\"\nimport { ReactorProvider, useAuth, useClient } from \"@ic-reactor/react\"\nimport { isPrincipal, principal, type Principal } from \"@candid-core/schema\"\nimport { skipToken, useMutation, useQuery } from \"@tanstack/react-query\"\nimport { actor, type Actor } from \"./generated/icrc1\"\n```\n\nOne import path per name: Candid values only from `@candid-core/schema`,\n`skipToken` and the hooks only from TanStack Query.\n\nThe generated module (from `candid-core-cli gen` or `@ic-reactor/vite-plugin`;\ndo not edit it) exports a type and schema per Candid type, the service schema\n`actor`, and `type Actor`.\n\n## Setup\n\n```ts\n// src/ledger.ts\nimport { createClient } from \"@ic-reactor/core\"\nimport { actor, type Actor } from \"./generated/icrc1\"\n\nexport const client = createClient({ network: \"ic\", identity: \"anonymous\" })\nexport const ledger = client.canister<Actor>(actor, { id: \"ryjl3-tyaaa-aaaaa-aaaba-cai\" })\n```\n\n`client.canister()` returns the same object each time: safe in render.\n\n`network` and the root key:\n\n- `\"ic\"`: mainnet (`https://icp-api.io`) and its built-in root key.\n- `\"local\"`: `http://127.0.0.1:4943`; its root key is fetched.\n- `{ host, rootKey }`: any other replica. A given `rootKey` is used, never\n  fetched; without one, it is fetched only from a local `host` (`localhost`,\n  `127.0.0.1`, `[::1]`). Never fetch one from any other host.\n- `\"env\"`: the page's network. Canisters can be named, `{ name: \"backend\" }`,\n  from the `ic_env` cookie, believed only on a local replica or with\n...\n</persisted-output>",
+  "cli_message": {
+   "type": "user",
+   "session_id": "3df55d72-125e-42cd-81c2-b4a872b1d515",
+   "uuid": "90ce10f1-5177-47da-9234-03a20d69cf4b",
+   "timestamp": "2026-10-05T10:42:49.972Z",
+   "parent_tool_use_id": null,
+   "tool_use_result": {
+    "stderr": "",
+    "interrupted": false,
+    "isImage": false,
+    "noOutputExpected": false,
+    "persistedOutputPath": "/private/var/folders/f8/k3ttpp4d5ns4shtytwf375ym0000gn/T/ic-reactor-eval-batch-eEb7SZ/react-wallet--v4--014/home/.claude/projects/-private-var-folders-f8-k3ttpp4d5ns4shtytwf375ym0000gn-T-ic-reactor-eval-batch-eEb7SZ-react-wallet--v4--014-work/3df55d72-125e-42cd-81c2-b4a872b1d515/tool-results/b65qfoxqg.txt",
+    "persistedOutputSize": 30301
+   },
+   "tool_use_result_stdout_sha256": "565fec82770d2e814c01d74ec27a5001a039e71bba6f1c665282abfaf502ffca",
+   "tool_use_result_stdout_length": 29991
+  }
+ },
+ "flagged_read": {
+  "tool_call": {
+   "tool": "Read",
+   "input": {
+    "file_path": "/private/var/folders/f8/k3ttpp4d5ns4shtytwf375ym0000gn/T/ic-reactor-eval-batch-eEb7SZ/react-wallet--v4--014/home/.claude/projects/-private-var-folders-f8-k3ttpp4d5ns4shtytwf375ym0000gn-T-ic-reactor-eval-batch-eEb7SZ-react-wallet--v4--014-work/3df55d72-125e-42cd-81c2-b4a872b1d515/tool-results/b65qfoxqg.txt"
+   }
+  },
+  "tool_result": "1\t# @ic-reactor/core\n2\t\n3\t> How to call Internet Computer canisters with a module `candid-core-cli gen`\n4\t> generated from a `.did`, a client from `@ic-reactor/core`, and TanStack\n5\t> Query. The client applies the rules a hand-written integration must get\n6\t> right; this guide names the call for each.\n7\t\n8\tApplies to `@ic-reactor/core` 4.0.0-beta.1.\n9\t\n10\t## Imports\n11\t\n12\t```ts\n13\timport { createClient, formatUnits, isReactorError, parseUnits } from \"@ic-reactor/core\"\n14\timport { ReactorProvider, useAuth, useClient } from \"@ic-reactor/react\"\n15\timport { isPrincipal, principal, type Principal } from \"@candid-core/schema\"\n16\timport { skipToken, useMutation, useQuery } from \"@tanstack/react-query\"\n17\timport { actor, type Actor } from \"./generated/icrc1\"\n18\t```\n19\t\n20\tOne import path per name: Candid values only from `@candid-core/schema`,\n21\t`skipToken` and the hooks only from TanStack Query.\n22\t\n23\tThe generated module (from `candid-core-cli gen` or `@ic-reactor/vite-plugin`;\n24\tdo not edit it) exports a type and schema per Candid type, the service schema\n25\t`actor`, and `type Actor`.\n26\t\n27\t## Setup\n28\t\n29\t```ts\n30\t// src/ledger.ts\n31\timport { createClient } from \"@ic-reactor/core\"\n32\timport { actor, type Actor } from \"./generated/icrc1\"\n33\t\n34\texport const client = createClient({ network: \"ic\", identity: \"anonymous\" })\n35\texport const ledger = client.canister<Actor>(actor, { id: \"ryjl3-tyaaa-aaaaa-aaaba-cai\" })\n36\t```\n37\t\n38\t`client.canister()` returns the same object each time: safe in render.\n39\t\n40\t`network` and the root key:\n41\t\n42\t- `\"ic\"`: mainnet (`https://icp-api.io`) and its built-in root key.\n43\t- `\"local\"`: `http://127.0.0.1:4943`; its root key is fetched.\n44\t- `{ host, rootKey }`: any other replica. A given `rootKey` is used, never\n45\t  fetched; without one, it is fetched only from a local `host` (`localhost`,\n46\t  `127.0.0.1`, `[::1]`). Never fetch one from any other host.\n47\t- `\"env\"`: the page's network. Canisters can be named, `{ name: \"backend\" }`,\n48\t  from the `ic_env` cookie, believed only on a local replica or with\n49\t  `allowEnvConfig: true`. A server has no cookie: use `{ id }` there.\n50\t\n51\tWho calls (exactly one):\n52\t\n53\t- `identity`: a fixed `Identity` (scripts, servers, tests), or `\"anonymous\"`,\n54\t  read-only: every update is refused before sending. A\n55\t  `new AnonymousIdentity()` signs writes, so map one you are handed:\n56\t  `identity: id && !id.getPrincipal().isAnonymous() ? id : \"anonymous\"`.\n57\t- `auth: () => new AuthClient()` (`@icp-sdk/auth/client`): users sign in and\n58\t  out. The factory runs once, in a browser only.\n59\t\n60\tWho is calling, and may they write:\n61\t\n62\t| Question               | Answer                                                                    |\n63\t| ---------------------- | ------------------------------------------------------------------------- |\n64\t| the caller's principal | `useAuth().principal`, `client.caller()` (`\"2vxsx-fae\"` unless signed in) |\n65\t| may a write be sent    | `useAuth().status === \"signed-in\"`; the client refuses the rest itself    |\n66\t| when did it change     | `useAuth()` re-renders; `client.subscribe(fn)`                            |\n67\t\n68\tThe client keeps one agent per principal: a call goes out as the principal\n69\tcurrent when it was made, or not at all.\n70\t\n71\tOne client per browser tab, or per request on a server. In React,\n72\t`<ReactorProvider client={() => createClient(...)}>` builds it once per\n73\tmounted tree and disposes it on unmount; a module-scope client passed as\n74\t`client={() => client}` is borrowed, never disposed. Inside, `useClient()`\n75\treturns it (as anonymous while hydrating) and `useAuth()` returns\n76\t`{ status, principal, signIn, signOut }`, `\"anonymous\"` on a server and in a\n77\thydrating page's first render.\n78\t\n79\tAny other sign-in source becomes an `AuthLike`:\n80\t\n81\t```ts\n82\t// src/auth-like.ts\n83\timport type { AuthLike } from \"@ic-reactor/core\"\n84\timport type { Identity } from \"@icp-sdk/core/agent\"\n85\t\n86\texport interface SignInSource {\n87\t  getIdentity(): Identity // anonymous while signed out\n88\t  isAuthenticated(): boolean\n89\t  login(): Promise<void>\n90\t  logout(): Promise<void>\n91\t  subscribe(listener: () => void): () => void\n92\t}\n93\t\n94\texport function toAuthLike(source: SignInSource): AuthLike {\n95\t  const signedIn = () =>\n96\t    source.isAuthenticated() && !source.getIdentity().getPrincipal().isAnonymous()\n97\t  return {\n98\t    getPrincipal: () => (signedIn() ? source.getIdentity().getPrincipal() : undefined),\n99\t    getStatus: () => ({ state: signedIn() ? \"signed-in\" : \"signed-out\" }),\n100\t    getIdentity: async () => source.getIdentity(),\n101\t    subscribe: (listener) => source.subscribe(listener),\n102\t    signIn: () => source.login(),\n103\t    signOut: () => source.logout(),\n104\t  }\n105\t}\n106\t```\n107\t\n108\t## Values\n109\t\n110\tMethods use the generated types:\n111\t\n112\t| Candid                                   | Value                                          |\n113\t| ---------------------------------------- | ---------------------------------------------- |\n114\t| `nat`, `int`, `nat64`, `int64`           | `bigint` (never `number`)                      |\n115\t| `nat8`..`nat32`, `int8`..`int32`, floats | `number`                                       |\n116\t| `text`, `bool`                           | `string`, `boolean`                            |\n117\t| `principal`                              | `Principal`: branded principal text            |\n118\t| `blob` / `vec nat8`                      | `Uint8Array`                                   |\n119\t| `opt T`                                  | `T \\| null` (the property is always present)   |\n120\t| `opt opt T`, `opt null`                  | `{ some: T \\| null } \\| null`, `{ some: null } \\| null` |\n121\t| `vec T`                                  | `T[]`                                          |\n122\t| `record { a : T }`                       | `{ a: T }`, every field present                |\n123\t| `variant { A : T; B }`                   | `{ tag: \"A\"; value: T } \\| { tag: \"B\" }`       |\n124\t\n125\tMake principals from user input with `principal(text)`, which throws a\n126\t`TypeError` for invalid text: catch it and refuse the input. In render, test with `isPrincipal(text)` first.\n127\t\n128\tDirect calls take the parameters `type Actor` lists; the builders below take\n129\tthem as one value: nothing for none, the value for one, a tuple `[a, b]` for\n130\tmore.\n131\t\n132\tToken amounts are base units:\n133\t\n134\t```ts\n135\t/// <reference lib=\"es2023.intl\" />\n136\timport { formatUnits, parseUnits } from \"@ic-reactor/core\"\n137\t\n138\tconst units = parseUnits(\"1.5\", 8) // 150000000n\n139\tconst text = formatUnits(units, 8, { minFractionDigits: 8 }) // \"1.50000000\"\n140\tconst local = new Intl.NumberFormat(undefined, { maximumFractionDigits: 8 }).format(\n141\t  text as Intl.StringNumericLiteral // the cast needs lib ES2023\n142\t)\n143\t```\n144\t\n145\t`parseUnits` throws for text that is not a plain decimal (`\"1e3\"`, `\"1,5\"`),\n146\ta negative, or excess fraction digits: refuse that input. A cap is the Candid\n147\ttype's: a `nat64` field refuses 2^64 at encoding (`invalid_args`); an ICRC-1\n148\t`amount` is a `nat`, with none.\n149\t\n150\t### Results\n151\t\n152\tA method whose result is `variant { Ok : T; Err : E }` resolves with the `Ok`\n153\tvalue; `Err` rejects as kind `\"canister_err\"`, with the `Err` value in `err`\n154\t(typed on a query's or mutation's `error`).\n155\t\n156\t## Reads\n157\t\n158\t```tsx\n159\timport type { Principal } from \"@candid-core/schema\"\n160\timport { formatUnits } from \"@ic-reactor/core\"\n161\timport { useClient } from \"@ic-reactor/react\"\n162\timport { skipToken, useQuery } from \"@tanstack/react-query\"\n163\timport { actor, type Actor } from \"./generated/icrc1\"\n164\t\n165\texport function Balance({ owner }: { owner: Principal | undefined }) {\n166\t  const client = useClient()\n167\t  const ledger = client.canister<Actor>(actor, { id: \"ryjl3-tyaaa-aaaaa-aaaba-cai\" })\n168\t  const balance = useQuery(\n169\t    client.queryOptions(ledger, \"icrc1_balance_of\", owner ? { owner, subaccount: null } : skipToken)\n170\t  )\n171\t  return <p>{balance.data === undefined ? \"…\" : formatUnits(balance.data, 8)}</p>\n172\t}\n173\t```\n174\t\n175\t`skipToken` stands in for arguments not known yet;\n176\targuments that do not encode make the read reject `invalid_args`.\n177\t\n178\tKeys are `[\"ic-reactor\", network, caller, canisterId, method, args]`, so one\n179\tprincipal's cached answer is never served to another: after a sign-in,\n180\tsign-out or switch, the new caller's key is empty (`data` is `undefined`)\n181\tuntil it loads, and a read made for the previous caller never lands in it.\n182\tKeep it so: build the options in render, and add nothing that carries data\n183\tacross keys (`placeholderData: keepPreviousData`, cross-key `initialData`).\n184\t`client.queryKey(ledger, method?, args?)` gives keys for the cache.\n185\t\n186\tReads retry transient failures (never on a server). Spread to add options:\n187\t`{ ...client.queryOptions(...), staleTime }`.\n188\t\n189\t`queryOptions` throws for an update method; one that answers the same however\n190\toften it runs (ckBTC's `get_btc_address`) opts in with a fourth argument,\n191\t`{ update: \"idempotent\" }`. The target `{ id, certified: true }` certifies\n192\t`query` replies.\n193\t\n194\t## Writes\n195\t\n196\t```tsx\n197\timport { useClient } from \"@ic-reactor/react\"\n198\timport { useMutation } from \"@tanstack/react-query\"\n199\timport { actor, type Actor, type TransferArg } from \"./generated/icrc1\"\n200\t\n201\texport function Send({ arg }: { arg: TransferArg }) {\n202\t  const client = useClient()\n203\t  const ledger = client.canister<Actor>(actor, { id: \"ryjl3-tyaaa-aaaaa-aaaba-cai\" })\n204\t  const transfer = useMutation(client.mutationOptions(ledger, \"icrc1_transfer\"))\n205\t  return <button disabled={transfer.isPending} onClick={() => transfer.mutate(arg)}>Send</button>\n206\t}\n207\t```\n208\t\n209\t- The mutation invalidates the canister's reads, for every caller, after a\n210\t  success, a `canister_err` and a failure that may have executed. Nothing\n211\t  else is needed after an unknown outcome.\n212\t  A third argument, `{ invalidates: [canister, [canister, \"method\"]] }`,\n213\t  names other reads; `[]`, none. To add an `onSettled`, call the client's\n214\t  from yours.\n215\t- Do not retry a write. `retry` is `false`; keep it. The client itself\n216\t  re-sends an update, at most twice, only after a failure proving the canister\n217\t  never got it (reject code 2, status 429); any other failure is final.\n218\t- A write is sent as whoever is signed in when it runs. If nobody is, the\n219\t  client refuses it (`unauthenticated`) before calling anything.\n220\t- Call update methods only from `useMutation` or directly, never from\n221\t  `useQuery`; call query methods from `useQuery` or directly.\n222\t\n223\t## Errors\n224\t\n225\tEvery rejection is a `ReactorError`: test with `isReactorError(error)`, then\n226\tread `kind` and `mayHaveExecuted`. A failed write either certainly had no\n227\teffect, or may have executed:\n228\t\n229\t| What happened                                                                   | `kind`                            | May have executed |\n230\t| ------------------------------------------------------------------------------- | --------------------------------- | ----------------- |\n231\t| refused before sending: arguments that do not encode, a write while signed out  | `invalid_args`, `unauthenticated` | no                |\n232\t| HTTP 4xx except 408 (429 included): the replica or a boundary node refused it    | `not_delivered`                   | no                |\n233\t| reject code 1, 2 (transient) or 3: rejected before any canister code ran         | `rejected` (2: `not_delivered`)   | no                |\n234\t| reject code 4 or 5: the canister rejected or trapped, maybe after changing state | `rejected`                        | yes (a write)     |\n235\t| a sent write got no trustworthy answer: network drop, timeout, 5xx, 408          | `outcome_unknown`                 | yes               |\n236\t| a reply that did not decode                                                      | `invalid_reply`                   | yes (a write)     |\n237\t| the canister returned `Err`                                                      | `canister_err`                    | no                |\n238\t| the caller changed, or the call was aborted                                      | `cancelled`                       | no (an aborted write: yes) |\n239\t\n240\tOn the management canister (`aaaaa-aa`), codes 1 to 3 prove nothing: a write\n241\tthere may have executed. A query changes nothing, so a failed read never \"may\n242\thave executed\".\n243\t\n244\t## Outside React\n245\t\n246\t```ts\n247\timport { principal } from \"@candid-core/schema\"\n248\timport { isReactorError, parseUnits } from \"@ic-reactor/core\"\n249\timport { client, ledger } from \"./ledger\"\n250\t\n251\tconst account = { owner: principal(\"aaaaa-aa\"), subaccount: null }\n252\t\n253\tconst cached = await client.queryClient.fetchQuery(client.queryOptions(ledger, \"icrc1_balance_of\", account))\n254\tawait client.queryClient.invalidateQueries({ queryKey: client.queryKey(ledger) })\n255\tconst fresh = await ledger.icrc1_balance_of(account)\n256\t\n257\ttry {\n258\t  const arg = { to: account, amount: parseUnits(\"1.5\", 8), fee: null, memo: null, from_subaccount: null, created_at_time: null }\n259\t  await ledger.icrc1_transfer(arg) // refused unless `client` was built with an Identity\n260\t} catch (error) {\n261\t  if (!isReactorError(error)) throw error\n262\t  console.error(error.mayHaveExecuted ? \"unknown outcome: re-read first\" : error.kind)\n263\t}\n264\t```\n265\t\n266\tDirect calls never touch a cache. To test, `createTestClient()` from\n267\t`@ic-reactor/core/testing` gives a real client over an in-memory replica with\n268\ta sign-in you control.\n269\t\n270\t## Example\n271\t\n272\t```tsx\n273\timport { principal } from \"@candid-core/schema\"\n274\timport { createClient } from \"@ic-reactor/core\"\n275\timport { ReactorProvider, useAuth, useClient } from \"@ic-reactor/react\"\n276\timport { skipToken, useMutation, useQuery } from \"@tanstack/react-query\"\n277\timport { toAuthLike, type SignInSource } from \"./auth-like\"\n278\timport { actor, type Actor } from \"./generated/backend\"\n279\t\n280\texport function App({ auth }: { auth: SignInSource }) {\n281\t  return (\n282\t    <ReactorProvider client={() => createClient({ network: \"ic\", auth: () => toAuthLike(auth) })}>\n283\t      <Profile />\n284\t    </ReactorProvider>\n285\t  )\n286\t}\n287\t\n288\tfunction Profile() {\n289\t  const client = useClient()\n290\t  const { status, principal: caller, signIn } = useAuth()\n291\t  const backend = client.canister<Actor>(actor, { id: \"rrkah-fqaaa-aaaaa-aaaaq-cai\" })\n292\t  const me = principal(caller)\n293\t  const signedIn = status === \"signed-in\"\n294\t  const profile = useQuery(client.queryOptions(backend, \"get_profile\", signedIn ? me : skipToken))\n295\t  const rename = useMutation(client.mutationOptions(backend, \"set_name\"))\n296\t\n297\t  if (!signedIn) return <button onClick={() => void signIn()}>Sign in</button>\n298\t  if (profile.data === undefined) return <p>Loading…</p>\n299\t  return (\n300\t    <>\n301\t      <p>{profile.data.name}</p>\n302\t      <button disabled={rename.isPending} onClick={() => rename.mutate([me, \"Ada\"])}>Rename</button>\n303\t      {rename.error && <p>{rename.error.mayHaveExecuted ? \"Unknown outcome\" : rename.error.message}</p>}\n304\t    </>\n305\t  )\n306\t}\n307\t```\n308\t\n309\t## Do not\n310\t\n311\t- Cast text to `Principal`: use `principal(text)`.\n312\t- Convert `bigint` values to `number`: use `parseUnits` and `formatUnits`.\n313\t- Add `retry` to a write (`{ ...client.mutationOptions(...), retry: 3 }`\n314\t  compiles), or call a write from `useQuery`: TanStack Query may run a query's\n315\t  function again whenever it refetches, and every run of an update executes\n316\t  again.\n317\t- Write a query key by hand (it leaves the caller out), or carry data across\n318\t  keys (`keepPreviousData`, cross-key `initialData`).\n319\t- Build agents yourself, a client per render, or one client for every user of\n320\t  a server.\n321\t- Send a write as the anonymous identity: pass `identity: \"anonymous\"`, never\n322\t  an `AnonymousIdentity` you were handed.\n323\t- Treat every failed write as \"not executed\": read `mayHaveExecuted`.\n324\timport type { ReactElement } from \"react\"\n325\timport type { WalletAuth } from \"./auth\"\n326\timport type { LedgerConfig } from \"./config\"\n327\t\n328\texport interface WalletProps {\n329\t  auth: WalletAuth\n330\t  config: LedgerConfig\n331\t}\n332\t\n333\texport function Wallet(_props: WalletProps): ReactElement {\n334\t  return <p>TODO: implement the wallet</p>\n335\t}\n336\timport { StrictMode } from \"react\"\n337\timport { createRoot } from \"react-dom/client\"\n338\timport { MAINNET_ICP_LEDGER } from \"./config\"\n339\timport { createInternetIdentityAuth } from \"./ii-auth\"\n340\timport { Wallet } from \"./Wallet\"\n341\t\n342\tconst auth = await createInternetIdentityAuth()\n343\tconst root = document.getElementById(\"root\")\n344\tif (root) {\n345\t  createRoot(root).render(\n346\t    <StrictMode>\n347\t      <Wallet auth={auth} config={MAINNET_ICP_LEDGER} />\n348\t    </StrictMode>\n349\t  )\n350\t}\n351\t// Generated by candid-core-ts from a candid-core Contract. Do not edit.\n352\timport * as $ from \"@candid-core/schema\";\n353\t\n354\ttype $Account = { owner: $.Principal; subaccount: $Subaccount | null };\n355\tconst $Account: $.Schema<$Account> = $.c.rec(() => $.c.record({ owner: $.c.principal, subaccount: $.c.opt($Subaccount) }));\n356\texport { $Account as Account };\n357\t\n358\ttype $BlockIndex = bigint;\n359\tconst $BlockIndex: $.Schema<$BlockIndex> = $.c.rec(() => $.c.nat);\n360\texport { $BlockIndex as BlockIndex };\n361\t\n362\t/** Number of nanoseconds between two [Timestamp]s. */\n363\ttype $Duration = bigint;\n364\t/** Number of nanoseconds between two [Timestamp]s. */\n365\tconst $Duration: $.Schema<$Duration> = $.c.rec(() => $.c.nat64);\n366\texport { $Duration as Duration };\n367\t\n368\t/** The initialization parameters of the Ledger */\n369\ttype $InitArgs = { token_symbol: string; transfer_fee: bigint; metadata: Array<[string, $Value]>; minting_account: $Account; initial_balances: Array<[$Account, bigint]>; archive_options: { num_blocks_to_archive: bigint; trigger_threshold: bigint; max_message_size_bytes: bigint | null; cycles_for_archive_creation: bigint | null; node_max_memory_size_bytes: bigint | null; controller_id: $.Principal }; token_name: string };\n370\t/** The initialization parameters of the Ledger */\n371\tconst $InitArgs: $.Schema<$InitArgs> = $.c.rec(() => $.c.record({ token_symbol: $.c.text, transfer_fee: $.c.nat64, metadata: $.c.vec($.c.tuple([$.c.text, $Value])), minting_account: $Account, initial_balances: $.c.vec($.c.tuple([$Account, $.c.nat64])), archive_options: $.c.record({ num_blocks_to_archive: $.c.nat64, trigger_threshold: $.c.nat64, max_message_size_bytes: $.c.opt($.c.nat64), cycles_for_archive_creation: $.c.opt($.c.nat64), node_max_memory_size_bytes: $.c.opt($.c.nat64), controller_id: $.c.principal }), token_name: $.c.text }));\n372\texport { $InitArgs as InitArgs };\n373\t\n374\ttype $LedgerArg = { tag: \"Upgrade\"; value: $UpgradeArgs | null } | { tag: \"Init\"; value: $InitArgs };\n375\tconst $LedgerArg: $.Schema<$LedgerArg> = $.c.rec(() => $.c.variant({ Upgrade: $.c.opt($UpgradeArgs), Init: $InitArgs }));\n376\texport { $LedgerArg as LedgerArg };\n377\t\n378\ttype $Subaccount = Uint8Array;\n379\tconst $Subaccount: $.Schema<$Subaccount> = $.c.rec(() => $.c.blob());\n380\texport { $Subaccount as Subaccount };\n381\t\n382\t/** Number of nanoseconds since the UNIX epoch in UTC timezone. */\n383\ttype $Timestamp = bigint;\n384\t/** Number of nanoseconds since the UNIX epoch in UTC timezone. */\n385\tconst $Timestamp: $.Schema<$Timestamp> = $.c.rec(() => $.c.nat64);\n386\texport { $Timestamp as Timestamp };\n387\t\n388\ttype $Tokens = bigint;\n389\tconst $Tokens: $.Schema<$Tokens> = $.c.rec(() => $.c.nat);\n390\texport { $Tokens as Tokens };\n391\t\n392\ttype $TransferArg = { to: $Account; fee: bigint | null; memo: $Subaccount | null; from_subaccount: $Subaccount | null; created_at_time: bigint | null; amount: bigint };\n393\tconst $TransferArg: $.Schema<$TransferArg> = $.c.rec(() => $.c.record({ to: $Account, fee: $.c.opt($.c.nat), memo: $.c.opt($Subaccount), from_subaccount: $.c.opt($Subaccount), created_at_time: $.c.opt($.c.nat64), amount: $.c.nat }));\n394\texport { $TransferArg as TransferArg };\n395\t\n396\ttype $TransferError = { tag: \"GenericError\"; value: { message: string; error_code: bigint } } | { tag: \"TemporarilyUnavailable\" } | { tag: \"BadBurn\"; value: { min_burn_amount: bigint } } | { tag: \"Duplicate\"; value: { duplicate_of: bigint } } | { tag: \"BadFee\"; value: { expected_fee: bigint } } | { tag: \"CreatedInFuture\"; value: { ledger_time: bigint } } | { tag: \"TooOld\" } | { tag: \"InsufficientFunds\"; value: { balance: bigint } };\n397\tconst $TransferError: $.Schema<$TransferError> = $.c.rec(() => $.c.variant({ GenericError: $.c.record({ message: $.c.text, error_code: $.c.nat }), TemporarilyUnavailable: $.c.null, BadBurn: $.c.record({ min_burn_amount: $.c.nat }), Duplicate: $.c.record({ duplicate_of: $.c.nat }), BadFee: $.c.record({ expected_fee: $.c.nat }), CreatedInFuture: $.c.record({ ledger_time: $.c.nat64 }), TooOld: $.c.null, InsufficientFunds: $.c.record({ balance: $.c.nat }) }));\n398\texport { $TransferError as TransferError };\n399\t\n400\ttype $TransferResult = { tag: \"Ok\"; value: bigint } | { tag: \"Err\"; value: $TransferError };\n401\tconst $TransferResult: $.Schema<$TransferResult> = $.c.rec(() => $.c.variant({ Ok: $.c.nat, Err: $TransferError }));\n402\texport { $TransferResult as TransferResult };\n403\t\n404\ttype $UpgradeArgs = { token_symbol: string | null; transfer_fee: bigint | null; metadata: Array<[string, $Value]> | null; token_name: string | null };\n405\tconst $UpgradeArgs: $.Schema<$UpgradeArgs> = $.c.rec(() => $.c.record({ token_symbol: $.c.opt($.c.text), transfer_fee: $.c.opt($.c.nat64), metadata: $.c.opt($.c.vec($.c.tuple([$.c.text, $Value]))), token_name: $.c.opt($.c.text) }));\n406\texport { $UpgradeArgs as UpgradeArgs };\n407\t\n408\t/** The value returned from the [icrc1_metadata] endpoint. */\n409\ttype $Value = { tag: \"Int\"; value: bigint } | { tag: \"Nat\"; value: bigint } | { tag: \"Blob\"; value: $Subaccount } | { tag: \"Text\"; value: string };\n410\t/** The value returned from the [icrc1_metadata] endpoint. */\n411\tconst $Value: $.Schema<$Value> = $.c.rec(() => $.c.variant({ Int: $.c.int, Nat: $.c.nat, Blob: $Subaccount, Text: $.c.text }));\n412\texport { $Value as Value };\n413\t\n414\tconst $actor: $.Schema<$.Principal> = $.c.rec(() => $.c.service({ icrc1_balance_of: $.c.func([$Account], [$.c.nat], \"query\"), icrc1_decimals: $.c.func([], [$.c.nat8], \"query\"), icrc1_fee: $.c.func([], [$.c.nat], \"query\"), icrc1_supported_standards: $.c.func([], [$.c.vec($.c.record({ url: $.c.text, name: $.c.text }))], \"query\"), icrc1_metadata: $.c.func([], [$.c.vec($.c.tuple([$.c.text, $Value]))], \"query\"), icrc1_symbol: $.c.func([], [$.c.text], \"query\"), icrc1_minting_account: $.c.func([], [$.c.opt($Account)], \"query\"), icrc1_name: $.c.func([], [$.c.text], \"query\"), icrc1_total_supply: $.c.func([], [$.c.nat], \"query\"), icrc1_transfer: $.c.func([$TransferArg], [$TransferResult], \"update\") }));\n415\ttype $Actor = {\n416\t  icrc1_balance_of: (arg0: $Account) => Promise<bigint>;\n417\t  icrc1_decimals: () => Promise<number>;\n418\t  icrc1_fee: () => Promise<bigint>;\n419\t  icrc1_supported_standards: () => Promise<Array<{ url: string; name: string }>>;\n420\t  icrc1_metadata: () => Promise<Array<[string, $Value]>>;\n421\t  icrc1_symbol: () => Promise<string>;\n422\t  icrc1_minting_account: () => Promise<$Account | null>;\n423\t  icrc1_name: () => Promise<string>;\n424\t  icrc1_total_supply: () => Promise<bigint>;\n425\t  icrc1_transfer: (arg0: $TransferArg) => Promise<$TransferResult>;\n426\t};\n427\texport { $actor as actor, type $Actor as Actor };\n428\t// Note: the actor is a service class; init args are install-time metadata not exposed here (issue #104).\n429\t// A local test world: a fake Internet Computer replica (./fake-replica.js)\n430\t// running a small ICRC-1 ledger with the interface in ./ledger.idl.js.\n431\t//\n432\t// The replica answers the IC HTTP API at `world.host` through\n433\t// `globalThis.fetch`, and signs certificates and query responses with its own\n434\t// root key (`world.rootKey`), so an agent built with that host and root key\n435\t// talks to it exactly as it would talk to a replica.\n436\t//\n437\t// One replica serves a whole test file: it is installed when this module is\n438\t// first imported (import it before the code under test), and `createWorld()`\n439\t// gives each test a fresh ledger and request log behind it.\n440\timport { Cbor } from \"@icp-sdk/core/agent\"\n441\timport { IDL } from \"@icp-sdk/core/candid\"\n442\timport { Ed25519KeyIdentity } from \"@icp-sdk/core/identity\"\n443\timport { Principal } from \"@icp-sdk/core/principal\"\n444\timport { installFakeReplica, type FakeCallContext } from \"./fake-replica.js\"\n445\timport { idlFactory } from \"./ledger.idl.js\"\n446\t\n447\texport const LEDGER_ID = \"ryjl3-tyaaa-aaaaa-aaaba-cai\"\n448\texport const HOST = \"http://127.0.0.1:4943\"\n449\texport const FEE = 10_000n\n450\t\n451\texport interface LoggedRequest {\n452\t  readonly endpoint: \"status\" | \"query\" | \"call\" | \"read_state\"\n453\t  readonly method?: string\n454\t  readonly sender?: string\n455\t}\n456\t\n457\texport interface TestWorld {\n458\t  readonly host: string\n459\t  readonly rootKey: Uint8Array\n460\t  readonly canisterId: string\n461\t  /** Set the balance, in base units, of an owner's default account. */\n462\t  setBalance(owner: string, e8s: bigint): void\n463\t  balanceOf(owner: string): bigint\n464\t  /** Every request an agent sent since `createWorld()`. */\n465\t  readonly requests: readonly LoggedRequest[]\n466\t  /** A new random signing identity. */\n467\t  newIdentity(): Ed25519KeyIdentity\n468\t}\n469\t\n470\tinterface Account {\n471\t  owner: Principal\n472\t  subaccount: [] | [Uint8Array]\n473\t}\n474\tinterface TransferArg {\n475\t  to: Account\n476\t  amount: bigint\n477\t  fee: [] | [bigint]\n478\t  memo: [] | [Uint8Array]\n479\t  from_subaccount: [] | [Uint8Array]\n480\t  created_at_time: [] | [bigint]\n481\t}\n482\t\n483\tconst keyOf = (owner: Principal, sub: [] | [Uint8Array]) => {\n484\t  const bytes = sub[0]\n485\t  if (!bytes || bytes.every((b) => b === 0)) return owner.toText()\n486\t  return `${owner.toText()}:${Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\"\")}`\n487\t}\n488\t\n489\tlet balances = new Map<string, bigint>()\n490\tlet requests: LoggedRequest[] = []\n491\tlet nextBlock = 0n\n492\t\n493\tconst ledger: Record<\n494\t  string,\n495\t  (args: unknown[], context: FakeCallContext) => unknown\n496\t> = {\n497\t  icrc1_name: () => \"Test Token\",\n498\t  icrc1_symbol: () => \"TST\",\n499\t  icrc1_decimals: () => 8,\n500\t  icrc1_fee: () => FEE,\n501\t  icrc1_metadata: () => [],\n502\t  icrc1_total_supply: () => [...balances.values()].reduce((a, b) => a + b, 0n),\n503\t  icrc1_minting_account: () => [],\n504\t  icrc1_supported_standards: () => [\n505\t    { name: \"ICRC-1\", url: \"https://github.com/dfinity/ICRC-1\" },\n506\t  ],\n507\t  icrc1_balance_of: ([account]) => {\n508\t    const { owner, subaccount } = account as Account\n509\t    return balances.get(keyOf(owner, subaccount)) ?? 0n\n510\t  },\n511\t  icrc1_transfer: ([raw], { caller }) => {\n512\t    const arg = raw as TransferArg\n513\t    const from = keyOf(caller, arg.from_subaccount)\n514\t    if (arg.fee[0] !== undefined && arg.fee[0] !== FEE) {\n515\t      return { Err: { BadFee: { expected_fee: FEE } } }\n516\t    }\n517\t    const balance = balances.get(from) ?? 0n\n518\t    if (balance < arg.amount + FEE) {\n519\t      return { Err: { InsufficientFunds: { balance } } }\n520\t    }\n521\t    const to = keyOf(arg.to.owner, arg.to.subaccount)\n522\t    balances.set(from, balance - arg.amount - FEE)\n523\t    balances.set(to, (balances.get(to) ?? 0n) + arg.amount)\n524\t    return { Ok: nextBlock++ }\n525\t  },\n526\t}\n527\t\n528\tconst service = idlFactory({ IDL }) as IDL.ServiceClass\n529\tconst funcs = new Map<string, IDL.FuncClass>(\n530\t  service._fields as Array<[string, IDL.FuncClass]>\n531\t)\n532\t\n533\tfunction run(\n534\t  kind: \"query\" | \"update\",\n535\t  method: string,\n536\t  arg: Uint8Array,\n537\t  context: FakeCallContext\n538\t) {\n539\t  const func = funcs.get(method)\n540\t  const impl = ledger[method]\n541\t  if (!func || !impl) throw new Error(`the ledger has no method ${method}`)\n542\t  if (kind === \"query\" && !func.annotations.includes(\"query\")) {\n543\t    throw new Error(`${method} is not a query`)\n544\t  }\n545\t  const result = impl(IDL.decode(func.argTypes, arg), context)\n546\t  return new Uint8Array(IDL.encode(func.retTypes, [result]))\n547\t}\n548\t\n549\tconst original = globalThis.fetch\n550\tconst replica = installFakeReplica({\n551\t  host: HOST,\n552\t  canisters: {\n553\t    [LEDGER_ID]: {\n554\t      query: (method, arg, context) => run(\"query\", method, arg, context),\n555\t      update: (method, arg, context) => run(\"update\", method, arg, context),\n556\t    },\n557\t  },\n558\t})\n559\tconst fake = globalThis.fetch\n560\t\n561\t// Log each request in front of the replica. This `fetch` stays installed for\n562\t// the whole file, so agents built at module scope keep working across tests.\n563\tglobalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {\n564\t  const url = new URL(input instanceof Request ? input.url : String(input))\n565\t  const match =\n566\t    /\\/api\\/v\\d+\\/(?:canister\\/[^/]+\\/(query|call|read_state)|(status))$/.exec(\n567\t      url.pathname\n568\t    )\n569\t  if (!match) return original(input, init)\n570\t  if (match[2]) {\n571\t    requests.push({ endpoint: \"status\" })\n572\t    return fake(input, init)\n573\t  }\n574\t  const body = new Uint8Array(\n575\t    await new Response(\n576\t      input instanceof Request ? input.body : (init?.body as BodyInit)\n577\t    ).arrayBuffer()\n578\t  )\n579\t  const { content } = Cbor.decode(body) as {\n580\t    content: { sender?: Uint8Array; method_name?: string }\n581\t  }\n582\t  requests.push({\n583\t    endpoint: match[1] as LoggedRequest[\"endpoint\"],\n584\t    method: content.method_name,\n585\t    sender: content.sender\n586\t      ? Principal.fromUint8Array(content.sender).toText()\n587\t      : undefined,\n588\t  })\n589\t  return fake(url, { ...init, method: \"POST\", body: body as BodyInit })\n590\t}) as typeof globalThis.fetch\n591\t\n592\t/** A fresh ledger and request log for one test. */\n593\texport function createWorld(): TestWorld {\n594\t  balances = new Map()\n595\t  requests = []\n596\t  return {\n597\t    host: replica.host,\n598\t    rootKey: replica.rootKey,\n599\t    canisterId: LEDGER_ID,\n600\t    setBalance: (owner, e8s) => void balances.set(owner, e8s),\n601\t    balanceOf: (owner) => balances.get(owner) ?? 0n,\n602\t    get requests() {\n603\t      return requests\n604\t    },\n605\t    newIdentity: () => Ed25519KeyIdentity.generate(),\n606\t  }\n607\t}\n608\t// A sign-in state for tests, with the shape of the app's WalletAuth: signing\n609\t// in installs the given identity, signing out the anonymous one, and\n610\t// `switchTo` changes the signed-in principal without a sign-out in between.\n611\timport { AnonymousIdentity, type Identity } from \"@icp-sdk/core/agent\"\n612\t\n613\texport interface TestAuth {\n614\t  getIdentity(): Identity\n615\t  isAuthenticated(): boolean\n616\t  login(): Promise<void>\n617\t  logout(): Promise<void>\n618\t  subscribe(listener: () => void): () => void\n619\t  switchTo(identity: Identity): void\n620\t}\n621\t\n622\texport function createTestAuth(\n623\t  loginIdentity: Identity,\n624\t  options: { signedIn?: boolean } = {}\n625\t): TestAuth {\n626\t  let signedIn = options.signedIn ?? false\n627\t  let identity: Identity = signedIn ? loginIdentity : new AnonymousIdentity()\n628\t  const listeners = new Set<() => void>()\n629\t  const set = (next: Identity, nextSignedIn: boolean) => {\n630\t    identity = next\n631\t    signedIn = nextSignedIn\n632\t    for (const listener of [...listeners]) listener()\n633\t  }\n634\t  return {\n635\t    getIdentity: () => identity,\n636\t    isAuthenticated: () => signedIn,\n637\t    login: async () => set(loginIdentity, true),\n638\t    logout: async () => set(new AnonymousIdentity(), false),\n639\t    switchTo: (next) => set(next, true),\n640\t    subscribe: (listener) => {\n641\t      listeners.add(listener)\n642\t      return () => void listeners.delete(listener)\n643\t    },\n644\t  }\n645\t}\n646\tYou are working in a small React 19 + TypeScript project (ESM, strict).\n647\tImplement a wallet component for an ICRC-1 token ledger on the Internet\n648\tComputer.\n649\t\n650\tAvailable library: IC Reactor 4 — `@ic-reactor/core`, a client that calls canisters and builds TanStack Query options, and `@ic-reactor/react` for React — over the module `candid-core-cli gen` generated from the ledger's `.did` in `src/generated/icrc1.ts` (`@candid-core/schema` 0.3.0-beta.1), with `@icp-sdk/core`, `@icp-sdk/auth` and TanStack Query (`@tanstack/react-query`, `@tanstack/query-core`). Its documentation is in `docs/`; read it before you start.\n651\t",
+  "tool_result_sha256": "ba55e58d90f2b7db54043c50dd2d714edca82c5aa85e543a66aa3f3e4ed2d7ac"
+ },
+ "note": "producer.tool_call is the Bash command whose output the CLI persisted; producer.tool_result is the CLI notice the agent received, with its 2 KB preview; flagged_read.tool_result is the whole file as the agent read it (line-numbered by the Read tool). Every file the command prints is in the run's own work/ directory. producer.cli_message is the rest of the user message that carried the notice, from the stored transcript (line 7 of react-wallet/v4/014/agent.stdout), added for Addendum 5: its session_id and the CLI's tool_use_result record of the call, whose persistedOutputPath names the saved file; tool_use_result.stdout, the 29,991-character output itself, is left out and given by its sha256 and length."
+}

package/evals/results/2026-10-05-ga-gate/pilot.json

@@ -0,0 +1,162 @@
+{
+  "margin": 0.1,
+  "power": 0.8,
+  "cells": [
+    {
+      "task": "node-tool",
+      "model": "claude-sonnet-5-5",
+      "effort": "medium",
+      "prompt": "minimal",
+      "condition": "thin-guide",
+      "runs": 20,
+      "safeRate": 1,
+      "safeRateVariance": 0,
+      "requirementsMetMean": 1,
+      "requirementsMetVariance": 0,
+      "minutes": {
+        "mean": 0.654,
+        "median": 0.614
+      },
+      "turns": {
+        "mean": 6.8,
+        "median": 6
+      },
+      "tokens": {
+        "mean": 5117.8,
+        "median": 4824.5
+      },
+      "costUsd": {
+        "mean": 0.159
+      },
+      "exits": {
+        "normal": 20
+      },
+      "warnings": [
+        "ceiling: little room to show a gain"
+      ]
+    },
+    {
+      "task": "node-tool",
+      "model": "claude-sonnet-5-5",
+      "effort": "medium",
+      "prompt": "minimal",
+      "condition": "v4",
+      "runs": 20,
+      "safeRate": 1,
+      "safeRateVariance": 0,
+      "requirementsMetMean": 1,
+      "requirementsMetVariance": 0,
+      "minutes": {
+        "mean": 0.667,
+        "median": 0.649
+      },
+      "turns": {
+        "mean": 7.9,
+        "median": 7.5
+      },
+      "tokens": {
+        "mean": 4629.25,
+        "median": 4664.5
+      },
+      "costUsd": {
+        "mean": 0.173
+      },
+      "exits": {
+        "normal": 20
+      },
+      "warnings": [
+        "ceiling: little room to show a gain"
+      ]
+    },
+    {
+      "task": "react-wallet",
+      "model": "claude-sonnet-5-5",
+      "effort": "medium",
+      "prompt": "minimal",
+      "condition": "thin-guide",
+      "runs": 20,
+      "safeRate": 1,
+      "safeRateVariance": 0,
+      "requirementsMetMean": 1,
+      "requirementsMetVariance": 0,
+      "minutes": {
+        "mean": 0.819,
+        "median": 0.823
+      },
+      "turns": {
+        "mean": 6.2,
+        "median": 6
+      },
+      "tokens": {
+        "mean": 6911.45,
+        "median": 6791
+      },
+      "costUsd": {
+        "mean": 0.182
+      },
+      "exits": {
+        "normal": 20
+      },
+      "warnings": [
+        "ceiling: little room to show a gain"
+      ]
+    },
+    {
+      "task": "react-wallet",
+      "model": "claude-sonnet-5-5",
+      "effort": "medium",
+      "prompt": "minimal",
+      "condition": "v4",
+      "runs": 19,
+      "safeRate": 1,
+      "safeRateVariance": 0,
+      "requirementsMetMean": 1,
+      "requirementsMetVariance": 0,
+      "minutes": {
+        "mean": 0.902,
+        "median": 0.807
+      },
+      "turns": {
+        "mean": 8.316,
+        "median": 8
+      },
+      "tokens": {
+        "mean": 6352.842,
+        "median": 5959
+      },
+      "costUsd": {
+        "mean": 0.199
+      },
+      "exits": {
+        "normal": 19
+      },
+      "warnings": [
+        "ceiling: little room to show a gain"
+      ]
+    }
+  ],
+  "sampleSizes": [
+    {
+      "task": "node-tool",
+      "model": "claude-sonnet-5-5",
+      "effort": "medium",
+      "prompt": "minimal",
+      "comparison": "v4 - thin-guide",
+      "margin": 0.1,
+      "power": 0.8,
+      "runsPerCellForSafeRate": 75,
+      "runsPerCellForRequirementsMet": 4
+    },
+    {
+      "task": "react-wallet",
+      "model": "claude-sonnet-5-5",
+      "effort": "medium",
+      "prompt": "minimal",
+      "comparison": "v4 - thin-guide",
+      "margin": 0.1,
+      "power": 0.8,
+      "runsPerCellForSafeRate": 75,
+      "runsPerCellForRequirementsMet": 4
+    }
+  ]
+}