@taifoon/jev 0.2.10 → 0.2.12

package/README.md

@@ -137,7 +137,7 @@ code checks reject is still graded). Exit codes: `0` done, `1` a step failed, `2
 - **What the result is.** *Graded against a published rubric by a pinned decision model, with an appeal.* It is not
   "independently verified". An on-chain record is an attestation by whoever sent it, not a proof the answer is right.
 
-## The five calls
+## The six calls
 
 | Call | What it does |
 |---|---|
@@ -148,13 +148,18 @@ code checks reject is still graded). Exit codes: `0` done, `1` a step failed, `2
 | `evaluatorCall(protocol, jobId, verdict, digest)` | Returns the one unsigned call that ends the job; `null` for needs_review |
 | `verify(receiptOrDigest)` | Recomputes every digest and finds the records on chain |
 
+`verifyDecision(record, { answers? })` does the same for a decision as the coordination layer serves it at
+`/v1/judge/decisions/{id}`: the input fingerprint, the decision digest, the answers digest and the verdict RUBRIC_v1
+composes, all offline. `npx @taifoon/jev verify decision-1790522234088-10691d5017 --network base` runs it on the
+block-proof grade and then finds both entries on Base.
+
 Evaluator seats: `assurance-hook`, `judge-adapter`, `virtuals-erc8183`, `virtuals-memo-acp` and `bitagent-erc8183`.
 Each is tested against calldata a mined transaction carried.
 
 ## Documentation
 
 - [How grading works: Jev, the pipeline, THRESHOLDS_v1, `npx @taifoon/jev run`](docs/PIPELINE.md)
-- [API: the five calls, where Jev is reached, your own rubric](docs/API.md)
+- [API: the six calls, where Jev is reached, your own rubric](docs/API.md)
 - [Evaluator seats, with the transactions they are tested against](docs/EVALUATORS.md)
 - [On chain: contract addresses on Base and devnet, and one real grade end to end](docs/ON_CHAIN.md)
 - [The records: receipt, decision.v2, jev.answer.v1](docs/RECORDS.md)
@@ -163,6 +168,7 @@ Each is tested against calldata a mined transaction carried.
 
 ```
 npx @taifoon/jev verify <digest> --network base
+npx @taifoon/jev verify <decision id> --network base   # recompute the served record offline, then find it on chain
 npx @taifoon/jev workflows export ./jev-workflows
 ```
 

package/bin/jev.mjs

@@ -3,7 +3,7 @@
 //   jev workflows list [--version X]          the bundled n8n workflows (and which nodes and credentials each needs)
 //   jev workflows export <dir> [--version X]  write them, their schemas, manifest and README into <dir>
 //   jev run [--job 8453:81100] [--evidence pack.json] [--network …] [--yes] [--json]   one job through the pipeline, step by step
-//   jev verify <answers-digest> [--network devnet|base|any]  find the digest's JevAnswered / Decided rows (default any: devnet, then Base 8453)
+//   jev verify <answers-digest | decision id> [--network devnet|base|any]  (a decision id: recompute its record offline, then) find the digest's JevAnswered / Decided rows (default any: devnet, then Base 8453)
 import { cpSync, existsSync, readdirSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -34,12 +34,25 @@ if (cmd === 'workflows') {
 } else if (cmd === 'run') {
   await import('./run.mjs').then((m) => m.run(process.argv.slice(3)));
 } else if (cmd === 'verify' && sub) {
-  const { verify } = await import('../dist/index.js');
+  const { verify, verifyDecision, LAYER } = await import('../dist/index.js');
   if (!['devnet', 'base', 'any'].includes(network)) die('--network is devnet, base or any');
-  let v = await verify(sub, { network: network === 'base' ? 'base' : 'devnet' });
+  let digest = sub; let offline = null;
+  // a decision id (or its /v1/judge/decisions URL): read the served record and its answers, recompute both here, then
+  // find the answers digest on chain like any other
+  const m = /(decision-\d+-[0-9a-f]{10})/.exec(sub);
+  if (m) {
+    const get = async (p) => { const r = await fetch(`${LAYER}${p}`, { signal: AbortSignal.timeout(30_000) }); if (!r.ok) die(`${LAYER}${p} answered ${r.status}`); return r.json(); };
+    const rec = await get(`/v1/judge/decisions/${m[1]}`);
+    const ad = rec?.decision?.answers_digest;
+    const ans = ad ? await get(`/v1/judge/answers/${ad}`) : null;
+    offline = verifyDecision(rec, ans?.record ? { answers: ans.record } : {});
+    if (!ad) { console.log(JSON.stringify({ offline }, null, 1)); process.exit(offline.ok ? 0 : 2); }
+    digest = ad;
+  }
+  let v = await verify(digest, { network: network === 'base' ? 'base' : 'devnet' });
   if (network === 'any' && !v.checks.answersOnChain) { const b = await verify(sub, { network: 'base' }); if (b.checks.answersOnChain || !v.ok) v = b; }
-  console.log(JSON.stringify(v, null, 1));
-  process.exit(v.ok ? 0 : 2);
+  console.log(JSON.stringify(offline ? { offline, ...v, ok: v.ok && offline.ok } : v, null, 1));
+  process.exit(v.ok && (!offline || offline.ok) ? 0 : 2);
 } else {
-  console.log(`jev ${PKG.version}\n  jev workflows list [--version X]\n  jev workflows export <dir> [--version X]\n  jev run [--job <chain>:<id>] [--evidence pack.json] [--network none|devnet|base|both] [--yes] [--json]\n  jev verify <answers-digest> [--network devnet|base|any]`);
+  console.log(`jev ${PKG.version}\n  jev workflows list [--version X]\n  jev workflows export <dir> [--version X]\n  jev run [--job <chain>:<id>] [--evidence pack.json] [--network none|devnet|base|both] [--yes] [--json]\n  jev verify <answers-digest | decision id> [--network devnet|base|any]`);
 }

package/dist/addresses.d.ts

@@ -0,0 +1,62 @@
+export declare const REGISTRY_ADDRESSES: {
+    /** jev · JevAnswerLog (devnet) (devnet-only) */
+    readonly devnetAnswerLog: {
+        readonly chainId: 36927;
+        readonly address: "0xD8c1d8188Fc8EE388792f6EB3B3dbd4f341Ba8e3";
+        readonly block: 1106754;
+    };
+    /** jev · JevDecisionLog (devnet) (devnet-only) */
+    readonly devnetDecisionLog: {
+        readonly chainId: 36927;
+        readonly address: "0x1D622511862DD7DEffB8fEeBc225E0FAdA1e9A05";
+        readonly block: 981099;
+    };
+    /** taifoon-assurance · JudgeAdapter (devnet) (devnet-only) */
+    readonly devnetJudgeAdapter: {
+        readonly chainId: 36927;
+        readonly address: "0xbd4c9e797a8DBbfdde9C77bc5A5b21ACf611Db8f";
+        readonly block: null;
+    };
+    /** taifoon-assurance · AssuranceHook (proxy, devnet) (devnet-only) */
+    readonly devnetAssuranceHook: {
+        readonly chainId: 36927;
+        readonly address: "0x7110C8951d17B69054395742e265bbd98259564A";
+        readonly block: 909786;
+    };
+    /** jev · JevAnswerLog (live) */
+    readonly baseAnswerLog: {
+        readonly chainId: 8453;
+        readonly address: "0x8e9B9cE86a2d55c10318607b0c815B7B8C66254d";
+        readonly block: 51863008;
+    };
+    /** jev · JevAnswerLog (first deploy) (superseded) */
+    readonly baseAnswerLogFirstDeploy: {
+        readonly chainId: 8453;
+        readonly address: "0x5bac70eb78224bbCBa83f5A36DF09D549d3f57fa";
+        readonly block: 51856203;
+    };
+    /** jev · JevDecisionLog (live) */
+    readonly baseDecisionLog: {
+        readonly chainId: 8453;
+        readonly address: "0x209490d6A0FFC5368A42b0c2208BDCda853f6a92";
+        readonly block: 51856200;
+    };
+    /** standards-erc8183 · Virtuals ACP v3 (ERC-8183) (live) */
+    readonly virtualsErc8183: {
+        readonly chainId: 8453;
+        readonly address: "0x238E541BfefD82238730D00a2208E5497F1832E0";
+        readonly block: 44427013;
+    };
+    /** standards-erc8183 · memo-ACP router (live) */
+    readonly virtualsMemoAcpRouter: {
+        readonly chainId: 8453;
+        readonly address: "0xa6C9BA866992cfD7fd6460ba912bfa405adA9df0";
+        readonly block: 36786061;
+    };
+    /** standards-erc8183 · BitAgent ERC-8183 escrow (live) */
+    readonly bitagentErc8183: {
+        readonly chainId: 8453;
+        readonly address: "0x5009ABB3A309115a4a682C66BAf3BC9E0329BaB7";
+        readonly block: 48395723;
+    };
+};

package/dist/addresses.js

@@ -0,0 +1,24 @@
+// VENDORED from an address registry (addresses.json, public subset) by scripts/vendor-addresses.mjs - do not edit here.
+// Only the contracts this SDK names; test/addresses-vendor.test.ts checks the copy against the registry.
+export const REGISTRY_ADDRESSES = {
+    /** jev · JevAnswerLog (devnet) (devnet-only) */
+    devnetAnswerLog: { chainId: 36927, address: '0xD8c1d8188Fc8EE388792f6EB3B3dbd4f341Ba8e3', block: 1106754 },
+    /** jev · JevDecisionLog (devnet) (devnet-only) */
+    devnetDecisionLog: { chainId: 36927, address: '0x1D622511862DD7DEffB8fEeBc225E0FAdA1e9A05', block: 981099 },
+    /** taifoon-assurance · JudgeAdapter (devnet) (devnet-only) */
+    devnetJudgeAdapter: { chainId: 36927, address: '0xbd4c9e797a8DBbfdde9C77bc5A5b21ACf611Db8f', block: null },
+    /** taifoon-assurance · AssuranceHook (proxy, devnet) (devnet-only) */
+    devnetAssuranceHook: { chainId: 36927, address: '0x7110C8951d17B69054395742e265bbd98259564A', block: 909786 },
+    /** jev · JevAnswerLog (live) */
+    baseAnswerLog: { chainId: 8453, address: '0x8e9B9cE86a2d55c10318607b0c815B7B8C66254d', block: 51863008 },
+    /** jev · JevAnswerLog (first deploy) (superseded) */
+    baseAnswerLogFirstDeploy: { chainId: 8453, address: '0x5bac70eb78224bbCBa83f5A36DF09D549d3f57fa', block: 51856203 },
+    /** jev · JevDecisionLog (live) */
+    baseDecisionLog: { chainId: 8453, address: '0x209490d6A0FFC5368A42b0c2208BDCda853f6a92', block: 51856200 },
+    /** standards-erc8183 · Virtuals ACP v3 (ERC-8183) (live) */
+    virtualsErc8183: { chainId: 8453, address: '0x238E541BfefD82238730D00a2208E5497F1832E0', block: 44427013 },
+    /** standards-erc8183 · memo-ACP router (live) */
+    virtualsMemoAcpRouter: { chainId: 8453, address: '0xa6C9BA866992cfD7fd6460ba912bfa405adA9df0', block: 36786061 },
+    /** standards-erc8183 · BitAgent ERC-8183 escrow (live) */
+    bitagentErc8183: { chainId: 8453, address: '0x5009ABB3A309115a4a682C66BAf3BC9E0329BaB7', block: 48395723 },
+};

package/dist/contracts.d.ts

@@ -15,7 +15,7 @@ export declare const CONTRACTS: Readonly<{
         };
         /** JudgeAdapter: posts a verdict (with the decision digest) to the devnet assurance hook */
         readonly judgeAdapter: "0xbd4c9e797a8DBbfdde9C77bc5A5b21ACf611Db8f";
-        readonly assuranceHook: "0x7110c8951d17b69054395742e265bbd98259564a";
+        readonly assuranceHook: string;
     };
     /** Base (8453): both logs are live. Only the KMS recorder 0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D is `trusted` on the answer log. */
     readonly base: {

package/dist/contracts.js

@@ -1,31 +1,33 @@
 // Where the records and the evaluator seats live. Every address here was read from the chain or from its deploy
-// broadcast; nothing is deployed by this package.
+// broadcast; nothing is deployed by this package. The contract addresses come from the address registry (src/addresses.ts,
+// vendored by scripts/vendor-addresses.mjs); the recorder and the BitAgent evaluator are accounts, not registry contracts.
+import { REGISTRY_ADDRESSES as R } from './addresses.js';
 export const CONTRACTS = Object.freeze({
     /** the public devnet the logs live on: chain 36927, free gas; anyone may send */
     devnet: {
         chainId: 36927,
         rpc: 'https://rpc.taifoon.dev',
         /** JevAnswerLog: append-only, no owner. Recorders fixed at deploy are `trusted`; any other sender is logged with trusted = false */
-        answerLog: { address: '0xD8c1d8188Fc8EE388792f6EB3B3dbd4f341Ba8e3', fromBlock: 1_106_754 },
+        answerLog: { address: R.devnetAnswerLog.address, fromBlock: R.devnetAnswerLog.block },
         /** JevDecisionLog: append-only, no owner, no upgrade; the recorder is msg.sender */
-        decisionLog: { address: '0x1D622511862DD7DEffB8fEeBc225E0FAdA1e9A05', fromBlock: 981_099 },
+        decisionLog: { address: R.devnetDecisionLog.address, fromBlock: R.devnetDecisionLog.block },
         /** JudgeAdapter: posts a verdict (with the decision digest) to the devnet assurance hook */
-        judgeAdapter: '0xbd4c9e797a8DBbfdde9C77bc5A5b21ACf611Db8f',
-        assuranceHook: '0x7110c8951d17b69054395742e265bbd98259564a',
+        judgeAdapter: R.devnetJudgeAdapter.address,
+        assuranceHook: R.devnetAssuranceHook.address.toLowerCase(),
     },
     /** Base (8453): both logs are live. Only the KMS recorder 0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D is `trusted` on the answer log. */
     base: {
         chainId: 8453,
         rpc: 'https://mainnet.base.org',
         /** JevAnswerLog, redeployed 2026-09-27 (tx 0xeb7d2dac…ae87); supersedes 0x5bac70eb78224bbCBa83f5A36DF09D549d3f57fa */
-        answerLog: { address: '0x8e9B9cE86a2d55c10318607b0c815B7B8C66254d', fromBlock: 51_863_008 },
+        answerLog: { address: R.baseAnswerLog.address, fromBlock: R.baseAnswerLog.block },
         /** JevDecisionLog, deployed 2026-09-27 (tx 0x0e6300c0…4fc7); the recorder is msg.sender */
-        decisionLog: { address: '0x209490d6A0FFC5368A42b0c2208BDCda853f6a92', fromBlock: 51_856_200 },
+        decisionLog: { address: R.baseDecisionLog.address, fromBlock: R.baseDecisionLog.block },
         /** the one trusted recorder of the Base answer log */
         answerRecorder: '0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D',
-        virtualsErc8183: '0x238E541BfefD82238730D00a2208E5497F1832E0',
-        virtualsMemoAcpRouter: '0xa6C9BA866992cfD7fd6460ba912bfa405adA9df0',
-        bitagentErc8183: '0x5009ABB3A309115a4a682C66BAf3BC9E0329BaB7',
+        virtualsErc8183: R.virtualsErc8183.address,
+        virtualsMemoAcpRouter: R.virtualsMemoAcpRouter.address,
+        bitagentErc8183: R.bitagentErc8183.address,
         bitagentEvaluator: '0x4302e523D982f3b89Cfc43cE4530C012b495Ec11',
     },
 });

package/dist/decision.d.ts

@@ -0,0 +1,35 @@
+import { type Hex } from './hash.js';
+import { type AnswerRecord, type DecisionAnswer, type Subject } from './records.js';
+import { type Composed, type Facts, type Rubric, type RubricInput } from './rubric.js';
+/** The fields of a served decision.v2 record this check reads (the rest is carried as is). */
+export type DecisionRecord = {
+    v?: string;
+    id?: string;
+    kind: string;
+    subject: Subject;
+    model: string | null;
+    answers: DecisionAnswer[];
+    input?: string | null;
+    input_digest: Hex;
+    digest: Hex;
+    subject_id?: Hex;
+    kind_id?: Hex;
+    confidence_bps?: number;
+    answers_digest?: Hex | null;
+};
+export type DecisionCheck = {
+    ok: boolean;
+    checks: Record<string, boolean>;
+    problems: string[];
+    composed: Composed | null;
+    digest: Hex;
+};
+export declare function verifyDecision(d: DecisionRecord | {
+    decision: DecisionRecord;
+}, opts?: {
+    answers?: AnswerRecord | {
+        record: AnswerRecord;
+    };
+    facts?: Facts;
+    rubric?: Rubric | RubricInput;
+}): DecisionCheck;

package/dist/decision.js

@@ -0,0 +1,40 @@
+// verifyDecision(): recompute a decision.v2 record exactly as the coordination layer serves it at
+// /v1/judge/decisions/{id} (and its jev.answer.v1 record at /v1/judge/answers/{digest}), offline, with this package's
+// own code: the input fingerprint (sha256 of the text Jev read), the subject and kind ids, the decision digest, the
+// on-chain confidence, the answers digest and the verdict RUBRIC_v1 composes from the answers. `verify()` takes the
+// receipt `grade()` returns; this takes the record a reader finds by its link.
+import { sha256Hex } from './hash.js';
+import { answersDigestOf, confidenceBpsOf, decisionDigest, kindIdOf, subjectIdOf } from './records.js';
+import { defineRubric, RUBRIC_v1 } from './rubric.js';
+const low = (h) => String(h ?? '').toLowerCase();
+export function verifyDecision(d, opts = {}) {
+    const r = ('decision' in d ? d.decision : d);
+    const checks = {};
+    if (typeof r.input === 'string')
+        checks.inputDigest = low(sha256Hex(r.input)) === low(r.input_digest);
+    if (r.subject_id)
+        checks.subjectId = low(subjectIdOf(r.subject)) === low(r.subject_id);
+    if (r.kind_id)
+        checks.kindId = low(kindIdOf(r.kind)) === low(r.kind_id);
+    const digest = decisionDigest({ kind: r.kind, subject: r.subject, answers: r.answers, model: r.model, input_digest: r.input_digest });
+    checks.decisionDigest = low(digest) === low(r.digest);
+    if (typeof r.confidence_bps === 'number')
+        checks.confidenceBps = confidenceBpsOf(r.answers) === r.confidence_bps;
+    const ans = opts.answers ? ('record' in opts.answers ? opts.answers.record : opts.answers) : null;
+    if (ans) {
+        if (r.answers_digest)
+            checks.answersDigest = low(answersDigestOf(ans)) === low(r.answers_digest);
+        checks.answersBindInput = low(ans.input_digest) === low(r.input_digest);
+        checks.answersMatchDecision = r.answers.every((a) => { const b = ans.answers.find((x) => x.id === a.id); return !!b && b.value === a.value && JSON.stringify(b.distribution) === JSON.stringify(a.probabilities); });
+    }
+    let composed = null;
+    if (r.kind === 'grade') {
+        const rubric = opts.rubric ? defineRubric(opts.rubric) : RUBRIC_v1;
+        // A recorded decision exists only once the checks passed (a failed check rejects without asking Jev), so the
+        // default facts are "delivered, checks ok"; pass `facts` to compose under others (e.g. the job's price).
+        const facts = opts.facts ?? { delivered: true, checksOk: true, checks: {}, priceUsdc: null };
+        composed = rubric.compose(facts, Object.fromEntries(r.answers.map((a) => [a.id, { id: a.id, value: a.value, confidence: a.confidence, probabilities: a.probabilities }])));
+    }
+    const problems = Object.entries(checks).filter(([, v]) => !v).map(([k]) => `${k} does not recompute`);
+    return { ok: problems.length === 0, checks, problems, composed, digest };
+}

package/dist/index.d.ts

@@ -7,6 +7,7 @@
  *   record()         the unsigned calls that put the receipt's digests on JevAnswerLog / JevDecisionLog
  *   evaluatorCall()  the unsigned call that ends the job on the protocol whose evaluator seat you hold
  *   verify()         recompute every digest and find the chain events that hold them
+ *   verifyDecision() recompute a decision record as /v1/judge/decisions/{id} serves it, offline
  *   pipeline()       one job through the coordination layer's steps: pick → evidence → facts → grade → record → evaluator → premium → verify
  *   RUBRIC_v1        the questions, thresholds and composition (pass your own rubric to grade)
  *   CONTRACTS        where the logs and the evaluator seats are
@@ -19,6 +20,7 @@ export { prepareJob, runCheck } from './job.js';
 export { record } from './record.js';
 export { evaluatorCall } from './evaluator/index.js';
 export { verify } from './verify.js';
+export { verifyDecision } from './decision.js';
 export { pipeline, STEPS, LAYER, factsFromEvidence, protocolFor, parseJob, localQuote } from './pipeline.js';
 export { RUBRIC_v1 } from './rubric.js';
 export { CONTRACTS } from './contracts.js';
@@ -27,6 +29,7 @@ export type { FactsInput, Check } from './facts.js';
 export type { JobSpec, JobCheck, PreparedJob } from './job.js';
 export type { Recorded, UnsignedCall, Network } from './record.js';
 export type { Verification, AnswerEvent, DecisionEvent } from './verify.js';
+export type { DecisionRecord, DecisionCheck } from './decision.js';
 export type { Protocol, Adapter, AdapterOpts, EvaluatorCall } from './evaluator/index.js';
 export type { JevError } from './ask.js';
 export type { Rubric, RubricInput, Question, Answer, Facts, Verdict, Composed, Thresholds } from './rubric.js';

package/dist/index.js

@@ -7,6 +7,7 @@
  *   record()         the unsigned calls that put the receipt's digests on JevAnswerLog / JevDecisionLog
  *   evaluatorCall()  the unsigned call that ends the job on the protocol whose evaluator seat you hold
  *   verify()         recompute every digest and find the chain events that hold them
+ *   verifyDecision() recompute a decision record as /v1/judge/decisions/{id} serves it, offline
  *   pipeline()       one job through the coordination layer's steps: pick → evidence → facts → grade → record → evaluator → premium → verify
  *   RUBRIC_v1        the questions, thresholds and composition (pass your own rubric to grade)
  *   CONTRACTS        where the logs and the evaluator seats are
@@ -19,6 +20,7 @@ export { prepareJob, runCheck } from './job.js';
 export { record } from './record.js';
 export { evaluatorCall } from './evaluator/index.js';
 export { verify } from './verify.js';
+export { verifyDecision } from './decision.js';
 export { pipeline, STEPS, LAYER, factsFromEvidence, protocolFor, parseJob, localQuote } from './pipeline.js';
 export { RUBRIC_v1 } from './rubric.js';
 export { CONTRACTS } from './contracts.js';

package/docs/API.md

@@ -1,6 +1,6 @@
 # API
 
-## The five calls
+## The six calls
 
 | Call | What it does | Network |
 |---|---|---|
@@ -8,9 +8,11 @@
 | `facts({ delivered, checks, priceUsdc? })` | Runs the checks your protocol supplies. A check is a value or an (async) function; one that throws counts as "could not be checked". | None |
 | `record(receipt, { network, send? })` | Returns the unsigned `JevAnswerLog.record` and `JevDecisionLog.record` calls. `network` is a flag: `none`, `devnet` (default), `base` or `both`. Pass `send` (your wallet) to send every call that has an address. | None unless you pass `send` |
 | `evaluatorCall(protocol, jobId, verdict, digest)` | Returns the one unsigned call that ends the job on that protocol. For `needs_review` it returns `null`. | None |
+| `prepareJob({ id, task, criteria, delivered, source?, checks? })` | Turns a job as the buyer laid it out into the evidence Jev reads and the checks code runs. | None |
 | `verify(receiptOrDigest)` | Recomputes every digest, re-composes the verdict and finds the `JevAnswered` and `Decided` events. | One devnet RPC read |
+| `verifyDecision(record, { answers?, facts? })` | Recomputes a decision record as `/v1/judge/decisions/{id}` serves it: sha256 of the text Jev read, subject and kind ids, the decision digest, the on-chain confidence, the answers digest (with the `/v1/judge/answers/{digest}` record) and the verdict RUBRIC_v1 composes. | None |
 
-It also exports `RUBRIC_v1` and `CONTRACTS`. Nothing else.
+It also exports `RUBRIC_v1`, `CONTRACTS`, `runCheck` and the `jev run` pipeline (`pipeline`, `STEPS`, `LAYER` and its helpers).
 
 **Where Jev is reached.** Calls go to `https://api.typesafe.ai/v1/systemone` with your own TypeSafe key from
 [console.typesafe.ai](https://console.typesafe.ai), and to no one else. The key is not stored and never appears in a receipt. If you already

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taifoon/jev",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Grade AI agent jobs with TypeSafe's Jev and record the verdict on chain: code checks the facts, Jev answers a published rubric, and you get a receipt, the on-chain record and the evaluator call for ERC-8183 and Virtuals ACP. No runtime dependencies, no key inside.",
   "keywords": [
     "jev",