@jinn-network/client 0.1.8 → 0.1.9-canary.023faefb

package/dist/vendor/@jinn-network/sdk/dist/payloads/jinn-repo.d.ts

@@ -0,0 +1,38 @@
+/**
+ * jinn-repo Solution + Verdict payload schemas.
+ *
+ * Solution: the unified-diff patch the Solver's harness produced for the
+ * jinn-repo instance (a real merged Jinn-Network/mono PR). Mirrors the
+ * swe-rebench-v2 Solution shape; trajectory provenance is pinned via the
+ * envelope, not the payload.
+ *
+ * Verdict: the repo-native test runner's pass/fail, with an optional log
+ * excerpt for human inspection. The full test log is surfaced via the
+ * envelope's `artifacts[]` rather than as a typed payload field.
+ */
+import { z } from 'zod/v3';
+export declare const JinnRepoSolutionPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn-repo-solution.v1">;
+    patch: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo-solution.v1";
+    patch: string;
+}, {
+    schemaVersion: "jinn-repo-solution.v1";
+    patch: string;
+}>;
+export type JinnRepoSolutionPayload = z.infer<typeof JinnRepoSolutionPayloadSchema>;
+export declare const JinnRepoVerdictPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn-repo-verdict.v1">;
+    passed: z.ZodBoolean;
+    test_log_excerpt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo-verdict.v1";
+    passed: boolean;
+    test_log_excerpt?: string | undefined;
+}, {
+    schemaVersion: "jinn-repo-verdict.v1";
+    passed: boolean;
+    test_log_excerpt?: string | undefined;
+}>;
+export type JinnRepoVerdictPayload = z.infer<typeof JinnRepoVerdictPayloadSchema>;

package/dist/vendor/@jinn-network/sdk/dist/payloads/jinn-repo.js

@@ -0,0 +1,22 @@
+/**
+ * jinn-repo Solution + Verdict payload schemas.
+ *
+ * Solution: the unified-diff patch the Solver's harness produced for the
+ * jinn-repo instance (a real merged Jinn-Network/mono PR). Mirrors the
+ * swe-rebench-v2 Solution shape; trajectory provenance is pinned via the
+ * envelope, not the payload.
+ *
+ * Verdict: the repo-native test runner's pass/fail, with an optional log
+ * excerpt for human inspection. The full test log is surfaced via the
+ * envelope's `artifacts[]` rather than as a typed payload field.
+ */
+import { z } from 'zod/v3';
+export const JinnRepoSolutionPayloadSchema = z.object({
+    schemaVersion: z.literal('jinn-repo-solution.v1'),
+    patch: z.string().min(1),
+});
+export const JinnRepoVerdictPayloadSchema = z.object({
+    schemaVersion: z.literal('jinn-repo-verdict.v1'),
+    passed: z.boolean(),
+    test_log_excerpt: z.string().optional(),
+});

package/dist/vendor/@jinn-network/sdk/dist/payloads/prediction-v1.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const PredictionV1RestorationPayloadSchema: z.ZodObject<{
     probabilityYes: z.ZodString;
     submittedAt: z.ZodString;

package/dist/vendor/@jinn-network/sdk/dist/payloads/prediction-v1.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 import { DecimalProbabilitySchema, IsoDateTimeSchema } from '../prediction-v1.js';
 const Sha256Schema = z.string().regex(/^[0-9a-f]{64}$/);
 const EnvelopeRefSchema = z.object({

package/dist/vendor/@jinn-network/sdk/dist/payloads/session-derived.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const SessionDerivedExpectedArtifactsSchema: z.ZodObject<{
     finalPatchRef: z.ZodOptional<z.ZodString>;
     testSuiteRef: z.ZodOptional<z.ZodString>;

package/dist/vendor/@jinn-network/sdk/dist/payloads/session-derived.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 const HexShaSchema = z.string().regex(/^[0-9a-f]{64}$/);
 export const SessionDerivedExpectedArtifactsSchema = z.object({
     finalPatchRef: z.string().min(1).optional(),

package/dist/vendor/@jinn-network/sdk/dist/payloads/swe-rebench-v2.d.ts

@@ -20,7 +20,7 @@
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.2
  */
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const SweRebenchV2SolutionPayloadSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"swe-rebench-v2-solution.v1">;
     /** Unified diff patch (git-format). */
@@ -84,7 +84,7 @@ export declare const SweRebenchV2SolutionPayloadSchema: z.ZodObject<{
     } | undefined;
 }>;
 export type SweRebenchV2SolutionPayload = z.infer<typeof SweRebenchV2SolutionPayloadSchema>;
-export declare const SweRebenchV2VerdictPayloadSchema: z.ZodObject<{
+export declare const SweRebenchV2VerdictV1PayloadSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v1">;
     /** Pass@1 score: 1 if the test suite passed, 0 otherwise. */
     score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
@@ -107,4 +107,111 @@ export declare const SweRebenchV2VerdictPayloadSchema: z.ZodObject<{
     passed_match: boolean;
     evaluator_cost_usd: number;
 }>;
+/**
+ * v2 — additive graded signal (Lever A, #1019). Superset of v1: keeps the
+ * binary `score`/`passed_match` (the objective) and adds the per-test counts
+ * the grader already computes. `gradedScore = passedCount / totalCount` is
+ * derived downstream, never stored, to keep one source of truth.
+ */
+export declare const SweRebenchV2VerdictV2PayloadSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v2">;
+    score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    passed_match: z.ZodBoolean;
+    evaluator_cost_usd: z.ZodNumber;
+    /** Count of individual tests that passed in this run. */
+    passedCount: z.ZodNumber;
+    /** Total gradeable tests in this run (FAIL_TO_PASS ∪ PASS_TO_PASS as the runner reported). */
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>;
+/** Accept either schema version on the read path. */
+export declare const SweRebenchV2VerdictPayloadSchema: z.ZodUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v1">;
+    /** Pass@1 score: 1 if the test suite passed, 0 otherwise. */
+    score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    /**
+     * Whether the actual passed/failed test set matched the expected
+     * `FAIL_TO_PASS ∪ PASS_TO_PASS` exactly. False if extra tests passed
+     * or expected tests failed unexpectedly.
+     */
+    passed_match: z.ZodBoolean;
+    /** Cost of running the evaluator on this Solution (USDC-equivalent). */
+    evaluator_cost_usd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-verdict.v1";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v1";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+}>, z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v2">;
+    score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    passed_match: z.ZodBoolean;
+    evaluator_cost_usd: z.ZodNumber;
+    /** Count of individual tests that passed in this run. */
+    passedCount: z.ZodNumber;
+    /** Total gradeable tests in this run (FAIL_TO_PASS ∪ PASS_TO_PASS as the runner reported). */
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>]>;
+export type SweRebenchV2VerdictV1Payload = z.infer<typeof SweRebenchV2VerdictV1PayloadSchema>;
+export type SweRebenchV2VerdictV2Payload = z.infer<typeof SweRebenchV2VerdictV2PayloadSchema>;
 export type SweRebenchV2VerdictPayload = z.infer<typeof SweRebenchV2VerdictPayloadSchema>;

package/dist/vendor/@jinn-network/sdk/dist/payloads/swe-rebench-v2.js

@@ -20,7 +20,7 @@
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.2
  */
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export const SweRebenchV2SolutionPayloadSchema = z.object({
     schemaVersion: z.literal('swe-rebench-v2-solution.v1'),
     /** Unified diff patch (git-format). */
@@ -43,7 +43,7 @@ export const SweRebenchV2SolutionPayloadSchema = z.object({
     })
         .optional(),
 });
-export const SweRebenchV2VerdictPayloadSchema = z.object({
+export const SweRebenchV2VerdictV1PayloadSchema = z.object({
     schemaVersion: z.literal('swe-rebench-v2-verdict.v1'),
     /** Pass@1 score: 1 if the test suite passed, 0 otherwise. */
     score: z.union([z.literal(0), z.literal(1)]),
@@ -56,3 +56,27 @@ export const SweRebenchV2VerdictPayloadSchema = z.object({
     /** Cost of running the evaluator on this Solution (USDC-equivalent). */
     evaluator_cost_usd: z.number().nonnegative(),
 });
+/**
+ * v2 — additive graded signal (Lever A, #1019). Superset of v1: keeps the
+ * binary `score`/`passed_match` (the objective) and adds the per-test counts
+ * the grader already computes. `gradedScore = passedCount / totalCount` is
+ * derived downstream, never stored, to keep one source of truth.
+ */
+export const SweRebenchV2VerdictV2PayloadSchema = z.object({
+    schemaVersion: z.literal('swe-rebench-v2-verdict.v2'),
+    score: z.union([z.literal(0), z.literal(1)]),
+    passed_match: z.boolean(),
+    evaluator_cost_usd: z.number().nonnegative(),
+    // camelCase matches schemaVersion/totalUsd elsewhere in this file and the #1019 design.
+    /** Count of individual tests that passed in this run. */
+    passedCount: z.number().int().nonnegative(),
+    /** Total gradeable tests in this run (FAIL_TO_PASS ∪ PASS_TO_PASS as the runner reported). */
+    totalCount: z.number().int().nonnegative(),
+}).refine((p) => p.passedCount <= p.totalCount, {
+    message: 'passedCount must not exceed totalCount',
+});
+/** Accept either schema version on the read path. */
+export const SweRebenchV2VerdictPayloadSchema = z.union([
+    SweRebenchV2VerdictV1PayloadSchema,
+    SweRebenchV2VerdictV2PayloadSchema,
+]);

package/dist/vendor/@jinn-network/sdk/dist/prediction-v1.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const DecimalProbabilitySchema: z.ZodString;
 export declare const IsoDateTimeSchema: z.ZodString;
 export declare const PredictionV1ClaimPolicySchema: z.ZodObject<{

package/dist/vendor/@jinn-network/sdk/dist/prediction-v1.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 const WindowSchema = z.object({
     startTs: z.number().int().nonnegative(),
     endTs: z.number().int().nonnegative(),

package/dist/vendor/@jinn-network/sdk/dist/solvernets/jinn-repo.d.ts

@@ -0,0 +1,4 @@
+export { JINN_REPO_SCHEMA_VERSION, JinnRepoTaskSchema, } from '../jinn-repo.js';
+export type { JinnRepoTask } from '../jinn-repo.js';
+export { JinnRepoSolutionPayloadSchema, JinnRepoVerdictPayloadSchema, } from '../payloads/jinn-repo.js';
+export type { JinnRepoSolutionPayload, JinnRepoVerdictPayload, } from '../payloads/jinn-repo.js';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/jinn-repo.js

@@ -0,0 +1,2 @@
+export { JINN_REPO_SCHEMA_VERSION, JinnRepoTaskSchema, } from '../jinn-repo.js';
+export { JinnRepoSolutionPayloadSchema, JinnRepoVerdictPayloadSchema, } from '../payloads/jinn-repo.js';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/manifest-schema.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 import type { JsonSchema } from '../json-schema.js';
 declare const ContractRoleZ: z.ZodEnum<["creator", "solver", "evaluator"]>;
 declare const CredentialRequirementZ: z.ZodObject<{

package/dist/vendor/@jinn-network/sdk/dist/solvernets/manifest-schema.js

@@ -13,7 +13,7 @@
 // - No `recommendedHarnesses`, no `requiredRuntimePlugins`, no `defaultRuntimePlugins`
 // - `evaluationFunction.implementation` is BINDING (canonical evaluator harness reference)
 // - `signature: { alg: 'eip-191'; signer: 0x...; value: 0x... }`
-import { z } from 'zod';
+import { z } from 'zod/v3';
 // JSON Schema is opaque to this validator — manifests carry user-authored
 // schemas whose internal shape we do not constrain here. Manifest readers
 // validate payloads against these schemas at task/solution/verdict handling

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2-held-out-slate.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Held-out task slate for the swe-rebench-v2 RL eval harness (issue #817/#820).
+ *
+ * A slate is a versioned, content-addressed set of swe-rebench-v2
+ * `instance_id`s RESERVED from the training pool. #817 ships the canonical
+ * train-stream exclusion in `client/`; the indexer (this package's consumer)
+ * needs the same membership to slate-scope `frozenResolvedRate` (#820 AC#1),
+ * but the indexer cannot import from `client/` (see
+ * `packages/indexer/src/handlers.ts` header). So the membership is embedded
+ * here, in the SDK both the indexer and clients may depend on.
+ *
+ * The artifact is embedded (not read from disk) so the SDK stays a pure,
+ * bundler-friendly module with no `node:fs` runtime dependency. It carries a
+ * self-declared content hash: the loader recomputes a sha256 over the
+ * canonicalised, instance-id-sorted artifact and fails loud on mismatch. This
+ * preserves #817's fail-loud drift guard — a hand-edit that adds or removes an
+ * instance without re-deriving the hash throws. It is NOT a tamper-proof
+ * anchor (the declared hash lives beside the data it verifies); a deliberate
+ * edit that also re-derives the hash passes.
+ *
+ * The embedded `instanceIds` + `hash` are kept byte-identical to the client
+ * artifact (`client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`)
+ * by a cross-source drift test. Scores are only comparable WITHIN a version; a
+ * slate change is a distinct version (v2, ...), never an in-place edit.
+ *
+ * Hashing mirrors `_swe-rebench-v2-held-out-slate.ts` in `client/`:
+ * `sha256:` + sha256(RFC 8785 canonical JSON of the normalized artifact). The
+ * artifact shape is flat (string scalars + a string array), so a minimal
+ * inlined JCS canonicalizer reproduces the client's `canonicalize`-based hash
+ * exactly — verified by the drift test.
+ */
+export declare const HELD_OUT_SLATE_SCHEMA_VERSION: "held-out-slate.v1";
+export interface HeldOutSlateArtifact {
+    schemaVersion: typeof HELD_OUT_SLATE_SCHEMA_VERSION;
+    solverType: string;
+    version: string;
+    generatedAt: string;
+    instanceIds: string[];
+    /** Declared content hash (sha256 over the canonical, sorted artifact). */
+    hash: `sha256:${string}`;
+}
+export interface LoadedHeldOutSlate {
+    version: string;
+    hash: `sha256:${string}`;
+    instanceIds: Set<string>;
+}
+/**
+ * Embedded v1 slate. Byte-identical (sans the `comment` doc field, which is not
+ * part of the hashed artifact) to
+ * `client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`.
+ * Guarded against drift by `test/solvernets/swe-rebench-v2-held-out-slate-cross-source.test.ts`.
+ */
+export declare const HELD_OUT_SLATE_V1: HeldOutSlateArtifact;
+export declare function hashHeldOutSlateArtifact(artifact: HeldOutSlateArtifact): `sha256:${string}`;
+/**
+ * Load the held-out slate membership for the swe-rebench-v2 solverType at
+ * `version`. Recomputes the content hash and fails loud on mismatch against the
+ * artifact's declared `hash` (catching accidental edit-without-rehash drift —
+ * not deliberate tampering; see the module header). Throws for an unknown
+ * version (scores are only comparable within a known version).
+ *
+ * `override` is for tests only — it lets the fail-loud guard be exercised
+ * against a tampered copy without mutating the canonical embedded artifact.
+ */
+export declare function loadHeldOutSlate(version: string, override?: HeldOutSlateArtifact): LoadedHeldOutSlate;

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2-held-out-slate.js

@@ -0,0 +1,123 @@
+/**
+ * Held-out task slate for the swe-rebench-v2 RL eval harness (issue #817/#820).
+ *
+ * A slate is a versioned, content-addressed set of swe-rebench-v2
+ * `instance_id`s RESERVED from the training pool. #817 ships the canonical
+ * train-stream exclusion in `client/`; the indexer (this package's consumer)
+ * needs the same membership to slate-scope `frozenResolvedRate` (#820 AC#1),
+ * but the indexer cannot import from `client/` (see
+ * `packages/indexer/src/handlers.ts` header). So the membership is embedded
+ * here, in the SDK both the indexer and clients may depend on.
+ *
+ * The artifact is embedded (not read from disk) so the SDK stays a pure,
+ * bundler-friendly module with no `node:fs` runtime dependency. It carries a
+ * self-declared content hash: the loader recomputes a sha256 over the
+ * canonicalised, instance-id-sorted artifact and fails loud on mismatch. This
+ * preserves #817's fail-loud drift guard — a hand-edit that adds or removes an
+ * instance without re-deriving the hash throws. It is NOT a tamper-proof
+ * anchor (the declared hash lives beside the data it verifies); a deliberate
+ * edit that also re-derives the hash passes.
+ *
+ * The embedded `instanceIds` + `hash` are kept byte-identical to the client
+ * artifact (`client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`)
+ * by a cross-source drift test. Scores are only comparable WITHIN a version; a
+ * slate change is a distinct version (v2, ...), never an in-place edit.
+ *
+ * Hashing mirrors `_swe-rebench-v2-held-out-slate.ts` in `client/`:
+ * `sha256:` + sha256(RFC 8785 canonical JSON of the normalized artifact). The
+ * artifact shape is flat (string scalars + a string array), so a minimal
+ * inlined JCS canonicalizer reproduces the client's `canonicalize`-based hash
+ * exactly — verified by the drift test.
+ */
+/// <reference types="node" />
+import { createHash } from 'node:crypto';
+export const HELD_OUT_SLATE_SCHEMA_VERSION = 'held-out-slate.v1';
+/**
+ * Embedded v1 slate. Byte-identical (sans the `comment` doc field, which is not
+ * part of the hashed artifact) to
+ * `client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`.
+ * Guarded against drift by `test/solvernets/swe-rebench-v2-held-out-slate-cross-source.test.ts`.
+ */
+export const HELD_OUT_SLATE_V1 = {
+    schemaVersion: 'held-out-slate.v1',
+    solverType: 'swe-rebench-v2.v1',
+    version: 'v1',
+    generatedAt: '2026-05-29T00:00:00.000Z',
+    hash: 'sha256:2b029de15e271d5d2de35fe6477af98aef9fdc46f357e59139179edab1a42b15',
+    instanceIds: [
+        'ASPP__pelita-863',
+        'ASPP__pelita-875',
+        'AbsaOSS__generate-release-notes-207',
+        'All-Hands-AI__OpenHands-11914',
+        'BQSKit__bqskit-337',
+        'BerriAI__litellm-14715',
+        'BerriAI__litellm-15753',
+        'BrianPugh__cyclopts-609',
+        'carsdotcom__skelebot-280',
+        'pandas-dev__pandas-60736',
+    ],
+};
+const SLATES_BY_VERSION = {
+    v1: HELD_OUT_SLATE_V1,
+};
+/**
+ * Minimal RFC 8785 (JCS) serialization for the flat slate artifact: object keys
+ * sorted by UTF-16 code-unit order, string values JSON-escaped, arrays in
+ * order. Reproduces the client loader's `canonicalize`-based output for this
+ * shape exactly (the cross-source drift test locks this against the client
+ * artifact's declared hash).
+ */
+function canonicalJson(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        const keys = Object.keys(value).sort();
+        return `{${keys
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * The hashed projection: schema/solver/version/generatedAt + the sorted
+ * instanceIds. Excludes the `hash` field itself (a hash never hashes itself).
+ */
+function normalizeHeldOutSlateArtifact(artifact) {
+    return {
+        schemaVersion: HELD_OUT_SLATE_SCHEMA_VERSION,
+        solverType: artifact.solverType,
+        version: artifact.version,
+        generatedAt: artifact.generatedAt,
+        instanceIds: [...artifact.instanceIds].sort((a, b) => a.localeCompare(b)),
+    };
+}
+export function hashHeldOutSlateArtifact(artifact) {
+    const canonical = canonicalJson(normalizeHeldOutSlateArtifact(artifact));
+    return `sha256:${createHash('sha256').update(canonical).digest('hex')}`;
+}
+/**
+ * Load the held-out slate membership for the swe-rebench-v2 solverType at
+ * `version`. Recomputes the content hash and fails loud on mismatch against the
+ * artifact's declared `hash` (catching accidental edit-without-rehash drift —
+ * not deliberate tampering; see the module header). Throws for an unknown
+ * version (scores are only comparable within a known version).
+ *
+ * `override` is for tests only — it lets the fail-loud guard be exercised
+ * against a tampered copy without mutating the canonical embedded artifact.
+ */
+export function loadHeldOutSlate(version, override) {
+    const artifact = override ?? SLATES_BY_VERSION[version];
+    if (!artifact) {
+        throw new Error(`held-out slate not found for swe-rebench-v2 version=${version}`);
+    }
+    if (artifact.version !== version) {
+        throw new Error(`held-out slate version mismatch: artifact declares ${artifact.version}, requested ${version}`);
+    }
+    const computed = hashHeldOutSlateArtifact(artifact);
+    if (artifact.hash !== computed) {
+        throw new Error(`held-out slate hash mismatch for swe-rebench-v2 ${version}: declared ${artifact.hash}, computed ${computed} (artifact was edited without re-deriving the hash)`);
+    }
+    return { version: artifact.version, hash: computed, instanceIds: new Set(artifact.instanceIds) };
+}

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2.d.ts

@@ -1,4 +1,4 @@
 export { SweRebenchV2LanguageSchema, SweRebenchV2TaskSchema, } from '../swe-rebench-v2.js';
 export type { SweRebenchV2Task } from '../swe-rebench-v2.js';
-export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, } from '../payloads/swe-rebench-v2.js';
-export type { SweRebenchV2SolutionPayload, SweRebenchV2VerdictPayload, } from '../payloads/swe-rebench-v2.js';
+export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, SweRebenchV2VerdictV2PayloadSchema, } from '../payloads/swe-rebench-v2.js';
+export type { SweRebenchV2SolutionPayload, SweRebenchV2VerdictPayload, SweRebenchV2VerdictV2Payload, } from '../payloads/swe-rebench-v2.js';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2.js

@@ -1,2 +1,2 @@
 export { SweRebenchV2LanguageSchema, SweRebenchV2TaskSchema, } from '../swe-rebench-v2.js';
-export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, } from '../payloads/swe-rebench-v2.js';
+export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, SweRebenchV2VerdictV2PayloadSchema, } from '../payloads/swe-rebench-v2.js';

package/dist/vendor/@jinn-network/sdk/dist/swe-rebench-v2.d.ts

@@ -5,7 +5,7 @@
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.3
  */
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const SweRebenchV2LanguageSchema: z.ZodEnum<["python", "javascript", "typescript", "go", "c", "cpp", "cs", "java", "rust", "dart"]>;
 export declare const SweRebenchV2TaskSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"swe-rebench-v2.v1">;

package/dist/vendor/@jinn-network/sdk/dist/swe-rebench-v2.js

@@ -5,7 +5,7 @@
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.3
  */
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export const SweRebenchV2LanguageSchema = z.enum([
     'python', 'javascript', 'typescript', 'go',
     'c', 'cpp', 'cs', 'java', 'rust', 'dart',

package/dist/vendor/@jinn-network/sdk/package.json

@@ -31,13 +31,21 @@
       "import": "./dist/solvernets/swe-rebench-v2.js",
       "types": "./dist/solvernets/swe-rebench-v2.d.ts"
     },
+    "./solvernets/jinn-repo": {
+      "import": "./dist/solvernets/jinn-repo.js",
+      "types": "./dist/solvernets/jinn-repo.d.ts"
+    },
+    "./solvernets/swe-rebench-v2-held-out-slate": {
+      "import": "./dist/solvernets/swe-rebench-v2-held-out-slate.js",
+      "types": "./dist/solvernets/swe-rebench-v2-held-out-slate.d.ts"
+    },
     "./checkpoint": {
       "import": "./dist/checkpoint.js",
       "types": "./dist/checkpoint.d.ts"
     }
   },
   "dependencies": {
-    "zod": "^3.22.0",
+    "zod": "^4.4.3",
     "zod-to-json-schema": "^3.23.0"
   }
 }

package/docker-compose.yml

@@ -33,8 +33,9 @@ services:
     volumes:
       # Persistent daemon state: database, keystore, and earning progress
       - jinn-data:/data
-      # Persistent authentication state: stores Claude's OAuth token
-      - jinn-claude-state:/root/.claude
+      # Persistent authentication state: stores Claude's OAuth token. The image
+      # now runs as the non-root `node` user, so file-auth lives at /home/node/.claude.
+      - jinn-claude-state:/home/node/.claude
     command: ["run"]
 
 volumes: