@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/types/task.js

@@ -0,0 +1,88 @@
+/**
+ * Runtime shape of a Task — wraps SignedTaskV1 plus
+ * runtime fields (attempt number, role, etc.).
+ */
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { WindowSchema } from './window.js';
+import { SignedTaskV1Schema, TaskClaimPolicySchema } from './task-document.js';
+// ── Window (re-exported for backwards compat) ─────────────────────────────────
+export { WindowSchema };
+// ── Task schema ─────────────────────────────────────────────────────
+export const TaskSchema = z.object({
+    id: z.string().optional(),
+    description: z.string().min(1).optional(),
+    context: z.record(z.unknown()).optional(),
+    /**
+     * @deprecated Derived from `${contractId}.${contractVersion}` post Task 24
+     * of spec/2026-05-05-solvernet-creation-and-launch.md. Kept on the runtime
+     * Task for migration-period routing; new code should rely on
+     * `contractId` / `contractVersion` and on `solverNetManifestCid` for
+     * protocol identity.
+     */
+    solverType: z.string().optional(),
+    /** SolverNet contract id (e.g. `prediction`). Spec §14. */
+    contractId: z.string().optional(),
+    /** SolverNet contract version (e.g. `v1`). Spec §14. */
+    contractVersion: z.string().optional(),
+    /**
+     * BINDING — IPFS CID of the launched SolverNet manifest. The on-chain
+     * `manifestDigest` is `keccak256(solverNetManifestCid)`. Required for
+     * tasks posted through the production adapter (mech); optional on the
+     * runtime Task type so tests / kitchen-sink consumers don't have to
+     * supply it for paths that never hit `postTask`.
+     */
+    solverNetManifestCid: z.string().optional(),
+    role: z.enum(['restoration', 'evaluation']).optional(),
+    attemptId: z.string().optional(),
+    attemptNumber: z.number().int().optional(),
+    restorationRequestId: z.string().optional(),
+    // §3 — optional lifecycle window
+    window: WindowSchema.optional(),
+    // §3 — typed task payload; dispatcher is top-level `solverType`.
+    spec: z.record(z.unknown()).optional(),
+    // §3 — pre-claim and post-hoc qualifying rules; shape governed by solverType
+    eligibility: z.record(z.unknown()).optional(),
+    // TaskCoordinator claim policy. Required on signed task.v1 documents, optional
+    // on loose runtime Tasks so tests/configured tasks can use creator defaults.
+    claimPolicy: TaskClaimPolicySchema.optional(),
+    signedTask: SignedTaskV1Schema.optional(),
+});
+export function parseTask(input) {
+    const parsed = TaskSchema.parse(input);
+    const signedTask = parsed.signedTask;
+    const signedRuntime = signedTask;
+    const description = parsed.description ?? signedTask?.description;
+    if (!description) {
+        throw new Error('Task requires description (loose field or signedTask.description)');
+    }
+    const parsedSpec = parsed.spec;
+    if (parsedSpec && Object.prototype.hasOwnProperty.call(parsedSpec, 'kind')) {
+        throw new Error('Task spec.kind is retired; use top-level solverType');
+    }
+    const solverType = parsed.solverType ?? signedTask?.solverType;
+    const contractId = parsed.contractId ?? signedTask?.contractId;
+    const contractVersion = parsed.contractVersion ?? signedTask?.contractVersion;
+    const solverNetManifestCid = parsed.solverNetManifestCid ?? signedTask?.solverNetManifestCid;
+    const spec = parsedSpec ?? signedTask?.spec;
+    const claimPolicy = parsed.claimPolicy ?? signedTask?.claimPolicy;
+    return {
+        id: parsed.id ?? signedTask?.id ?? randomUUID(),
+        description,
+        context: parsed.context ?? signedRuntime?.context,
+        solverType,
+        contractId,
+        contractVersion,
+        solverNetManifestCid,
+        role: parsed.role ?? signedTask?.role,
+        attemptId: parsed.attemptId ?? signedRuntime?.attemptId,
+        attemptNumber: parsed.attemptNumber ?? signedRuntime?.attemptNumber,
+        restorationRequestId: parsed.restorationRequestId ?? signedRuntime?.restorationRequestId,
+        window: parsed.window ?? signedTask?.window,
+        spec,
+        eligibility: parsed.eligibility ?? signedTask?.eligibility,
+        claimPolicy,
+        signedTask,
+    };
+}
+//# sourceMappingURL=task.js.map

package/dist/types/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/types/task.ts"],"names":[],"mappings":"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"}

package/dist/types/window.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const WindowSchema: z.ZodObject<{
+    startTs: z.ZodNumber;
+    endTs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    startTs: number;
+    endTs: number;
+}, {
+    startTs: number;
+    endTs: number;
+}>;
+export type Window = z.infer<typeof WindowSchema>;

package/dist/types/window.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const WindowSchema = z.object({
+    startTs: z.number().int(),
+    endTs: z.number().int(),
+});
+//# sourceMappingURL=window.js.map

package/dist/types/window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.js","sourceRoot":"","sources":["../../src/types/window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACzB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;CACxB,CAAC,CAAC"}

package/dist/util/path-safety.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Path containment helpers — defence against `..` traversal and
+ * absolute-path escapes when joining attacker-influenced relative
+ * paths into a daemon-owned base directory.
+ *
+ * Manifest-bearing packages honour the convention that manifest entries are
+ * package-relative paths; this helper enforces that contract at runtime as
+ * belt-and-suspenders for the schema regex.
+ */
+/**
+ * Returns true iff `candidate` resolves to a path strictly inside
+ * `baseDir`. Rejects:
+ *   - dotdot traversal (`./../etc/passwd`)
+ *   - absolute paths that point outside (`/etc/passwd`)
+ *   - paths equal to `baseDir` itself (the base is a directory, not a
+ *     file we'd expect to import)
+ *
+ * Symlink escapes are NOT resolved here — callers that hand untrusted
+ * symlink-bearing trees should additionally `fs.realpath` both sides.
+ */
+export declare function isInsidePackageDir(baseDir: string, candidate: string): boolean;

package/dist/util/path-safety.js

@@ -0,0 +1,28 @@
+/**
+ * Path containment helpers — defence against `..` traversal and
+ * absolute-path escapes when joining attacker-influenced relative
+ * paths into a daemon-owned base directory.
+ *
+ * Manifest-bearing packages honour the convention that manifest entries are
+ * package-relative paths; this helper enforces that contract at runtime as
+ * belt-and-suspenders for the schema regex.
+ */
+import { isAbsolute, relative, resolve } from 'node:path';
+/**
+ * Returns true iff `candidate` resolves to a path strictly inside
+ * `baseDir`. Rejects:
+ *   - dotdot traversal (`./../etc/passwd`)
+ *   - absolute paths that point outside (`/etc/passwd`)
+ *   - paths equal to `baseDir` itself (the base is a directory, not a
+ *     file we'd expect to import)
+ *
+ * Symlink escapes are NOT resolved here — callers that hand untrusted
+ * symlink-bearing trees should additionally `fs.realpath` both sides.
+ */
+export function isInsidePackageDir(baseDir, candidate) {
+    const base = resolve(baseDir);
+    const cand = resolve(candidate);
+    const rel = relative(base, cand);
+    return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
+//# sourceMappingURL=path-safety.js.map

package/dist/util/path-safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-safety.js","sourceRoot":"","sources":["../../src/util/path-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe,EAAE,SAAiB;IACnE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,OAAO,GAAG,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AACjE,CAAC"}

package/dist/util/redact-rpc-urls.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Strip URLs from arbitrary error messages before they hit logs / stdout.
+ * RPC endpoints often embed API keys; logging an `Error.message` verbatim leaks them.
+ */
+export declare function redactRpcUrls(input: unknown): string;

package/dist/util/redact-rpc-urls.js

@@ -0,0 +1,9 @@
+/**
+ * Strip URLs from arbitrary error messages before they hit logs / stdout.
+ * RPC endpoints often embed API keys; logging an `Error.message` verbatim leaks them.
+ */
+export function redactRpcUrls(input) {
+    const message = input instanceof Error ? input.message : String(input);
+    return message.replace(/https?:\/\/[^\s"]+/g, '<rpc-url>');
+}
+//# sourceMappingURL=redact-rpc-urls.js.map

package/dist/util/redact-rpc-urls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact-rpc-urls.js","sourceRoot":"","sources":["../../src/util/redact-rpc-urls.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,OAAO,OAAO,CAAC,OAAO,CAAC,qBAAqB,EAAE,WAAW,CAAC,CAAC;AAC7D,CAAC"}

package/dist/vendor/@jinn-network/sdk/README.md

@@ -0,0 +1,89 @@
+# @jinn-network/sdk
+
+Stable SDK surface for Jinn SolverNets, Harnesses, plugins, and typed
+payloads.
+
+Runtime internals live in `@jinn-network/client`. The SDK builds, validates,
+describes, and prepares; the client runs, stores, posts, claims, signs,
+submits, and watches.
+
+## Install
+
+```bash
+npm install @jinn-network/sdk
+```
+
+## Harness authoring
+
+```ts
+import type {
+  Harness,
+  ExternalHarnessEnv,
+  HarnessContext,
+  Solution,
+} from '@jinn-network/sdk/harness';
+import { buildSolutionOutput } from '@jinn-network/sdk/solvernets/prediction-v1';
+
+export default function createHarness(env: ExternalHarnessEnv): Harness {
+  return {
+    name: env.implName,
+    version: env.implVersion,
+    supports: ({ solverType, role }) =>
+      solverType === 'prediction.v1' && role !== 'evaluation',
+    async run(ctx: HarnessContext): Promise<Solution> {
+      return buildSolutionOutput({
+        solverType: 'prediction.v1',
+        venueName: 'polymarket',
+        payload: {
+          probabilityYes: '0.50',
+          submittedAt: new Date().toISOString(),
+          format: 'decimal',
+          modelId: 'example-harness',
+        },
+      });
+    },
+  };
+}
+```
+
+## Public subpaths
+
+- `@jinn-network/sdk/harness` — Harness interfaces, context, capability
+  handles, and signed Harness manifest types.
+- `@jinn-network/sdk/solvernets` — SolverNet contract registry, validation, and
+  generic typed output builders.
+- `@jinn-network/sdk/solvernets/prediction-v1` — first-party Prediction v1
+  schemas, payload types, validation, and output helpers.
+- `@jinn-network/sdk/plugins` — SolverPlugin manifest types and validation
+  helpers for normal AI tooling plugins.
+
+The daemon still performs final runtime validation, envelope assembly, signing,
+storage, and submission.
+
+## Frozen mode (the freeze contract)
+
+Every Harness implementation must respect `HarnessContext.mode`:
+
+- `'train'` (default): writes to `ctx.implStateDir` are allowed. Improve /
+  Memory / equivalent learning phases run.
+- `'frozen'`: writes to `ctx.implStateDir` are forbidden. The daemon
+  hashes the directory before and after each Task; mismatch rejects the
+  envelope and rolls back.
+
+Use `requireTrain(ctx, action)` at write call sites to fail fast in
+frozen mode rather than after the Task completes:
+
+```typescript
+import { requireTrain } from '@jinn-network/sdk/harness';
+
+async function updateConstitutionalState(ctx: HarnessContext, delta: StateDelta) {
+  requireTrain(ctx, 'update constitutional state');
+  await fs.writeFile(constitutionPath, serialize(delta));
+}
+```
+
+Frozen mode is the discipline that crystallises the flowing substrate
+into externally-comparable artifacts; see
+`docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md` §5–6
+for the full design (trust stack, daemon enforcement, verified vs
+unverified frozen credibility tier).

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

@@ -0,0 +1,52 @@
+import type { Address, Hex } from './types.js';
+export interface SignTypedDataArgs {
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: number;
+        verifyingContract?: Address;
+    };
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+/**
+ * The runtime gate on `ScopedSigner.signTypedData` is enforced
+ * daemon-side: the daemon constructs the signer with an allow-list
+ * derived from the manifest's `capabilities.signer.typedDataDomains`
+ * (see {@link TypedDataAllowEntry} on `manifest.ts`) and refuses any
+ * domain not on the list. An impl that ships no `typedDataDomains`
+ * entry cannot call `signTypedData` at all (default-deny). The
+ * `ScopedSigner` interface itself is unchanged — the gate lives in
+ * the construction args, not the contract surface.
+ */
+export interface SendAllowedCallArgs {
+    to: Address;
+    data: Hex;
+    value?: bigint;
+}
+export interface ScopedSigner {
+    readonly address: Address;
+    signTypedData(args: SignTypedDataArgs): Promise<Hex>;
+    sendAllowedCall(call: SendAllowedCallArgs): Promise<Hex>;
+}
+export interface ScopedRpc {
+    readContract(args: {
+        address: Address;
+        abi: readonly unknown[];
+        functionName: string;
+        args?: readonly unknown[];
+    }): Promise<unknown>;
+    getBlockNumber(): Promise<bigint>;
+    getBalance(args: {
+        address: Address;
+    }): Promise<bigint>;
+    getCode(args: {
+        address: Address;
+    }): Promise<Hex | undefined>;
+    getChainId(): Promise<number>;
+}
+export type ScopedSecrets = Readonly<Record<string, string>>;

package/dist/vendor/@jinn-network/sdk/dist/capabilities.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,120 @@
+/**
+ * HarnessCheckpoint — a published, frozen, forkable Harness state.
+ *
+ * A checkpoint is the artifact-level entity that bridges the substrate's
+ * flowing operator-harnesses and the frozen-artifact world that recruits,
+ * comparisons, and downstream integrations live in. Operators publish
+ * checkpoints via `jinn checkpoint publish`; other operators install them
+ * via `jinn checkpoint install`.
+ *
+ * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §7
+ */
+import { z } from 'zod';
+export declare const HarnessCheckpointManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"harness.checkpoint.v1">;
+    name: z.ZodString;
+    version: z.ZodString;
+    parentCheckpointCid: z.ZodNullable<z.ZodString>;
+    harnessPackage: z.ZodObject<{
+        implName: z.ZodString;
+        implVersion: z.ZodString;
+        clientGitSha: z.ZodString;
+        sourceBundleCid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        implName: string;
+        implVersion: string;
+        clientGitSha: string;
+        sourceBundleCid: string;
+    }, {
+        implName: string;
+        implVersion: string;
+        clientGitSha: string;
+        sourceBundleCid: string;
+    }>;
+    implStateDirCid: z.ZodString;
+    codeDigest: z.ZodString;
+    publisher: z.ZodObject<{
+        agentId: z.ZodString;
+        signingKey: z.ZodString;
+        safeAddress: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        agentId: string;
+        signingKey: string;
+        safeAddress: string;
+    }, {
+        agentId: string;
+        signingKey: string;
+        safeAddress: string;
+    }>;
+    publishedAt: z.ZodString;
+    registry: z.ZodObject<{
+        anchor: z.ZodLiteral<"IdentityRegistry.setMetadata">;
+        metadataKey: z.ZodString;
+        txHash: z.ZodString;
+        blockNumber: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        anchor: "IdentityRegistry.setMetadata";
+        metadataKey: string;
+        txHash: string;
+        blockNumber: number;
+    }, {
+        anchor: "IdentityRegistry.setMetadata";
+        metadataKey: string;
+        txHash: string;
+        blockNumber: number;
+    }>;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "harness.checkpoint.v1";
+    name: string;
+    version: string;
+    parentCheckpointCid: string | null;
+    harnessPackage: {
+        implName: string;
+        implVersion: string;
+        clientGitSha: string;
+        sourceBundleCid: string;
+    };
+    implStateDirCid: string;
+    codeDigest: string;
+    publisher: {
+        agentId: string;
+        signingKey: string;
+        safeAddress: string;
+    };
+    publishedAt: string;
+    registry: {
+        anchor: "IdentityRegistry.setMetadata";
+        metadataKey: string;
+        txHash: string;
+        blockNumber: number;
+    };
+    signature: string;
+}, {
+    schemaVersion: "harness.checkpoint.v1";
+    name: string;
+    version: string;
+    parentCheckpointCid: string | null;
+    harnessPackage: {
+        implName: string;
+        implVersion: string;
+        clientGitSha: string;
+        sourceBundleCid: string;
+    };
+    implStateDirCid: string;
+    codeDigest: string;
+    publisher: {
+        agentId: string;
+        signingKey: string;
+        safeAddress: string;
+    };
+    publishedAt: string;
+    registry: {
+        anchor: "IdentityRegistry.setMetadata";
+        metadataKey: string;
+        txHash: string;
+        blockNumber: number;
+    };
+    signature: string;
+}>;
+export type HarnessCheckpointManifest = z.infer<typeof HarnessCheckpointManifestSchema>;

package/dist/vendor/@jinn-network/sdk/dist/checkpoint.js

@@ -0,0 +1,39 @@
+/**
+ * HarnessCheckpoint — a published, frozen, forkable Harness state.
+ *
+ * A checkpoint is the artifact-level entity that bridges the substrate's
+ * flowing operator-harnesses and the frozen-artifact world that recruits,
+ * comparisons, and downstream integrations live in. Operators publish
+ * checkpoints via `jinn checkpoint publish`; other operators install them
+ * via `jinn checkpoint install`.
+ *
+ * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §7
+ */
+import { z } from 'zod';
+export const HarnessCheckpointManifestSchema = z.object({
+    schemaVersion: z.literal('harness.checkpoint.v1'),
+    name: z.string().regex(/^(@[^/]+\/)?[^/@]+$/),
+    version: z.string().regex(/^\d+\.\d+\.\d+/),
+    parentCheckpointCid: z.string().nullable(),
+    harnessPackage: z.object({
+        implName: z.string().min(1),
+        implVersion: z.string().min(1),
+        clientGitSha: z.string().regex(/^(0x)?[0-9a-f]+$/),
+        sourceBundleCid: z.string().min(1),
+    }),
+    implStateDirCid: z.string().min(1),
+    codeDigest: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+    publisher: z.object({
+        agentId: z.string().min(1),
+        signingKey: z.string().regex(/^ed25519:[0-9a-f]{64}$/),
+        safeAddress: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    }),
+    publishedAt: z.string().datetime(),
+    registry: z.object({
+        anchor: z.literal('IdentityRegistry.setMetadata'),
+        metadataKey: z.string().min(1),
+        txHash: z.string().regex(/^0x[0-9a-f]{64}$/),
+        blockNumber: z.number().int().positive(),
+    }),
+    signature: z.string().min(1),
+});

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

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import type { OutputArtifact, RationaleEntry, Solution } from './types.js';
+import { type PredictionV1Task } from './prediction-v1.js';
+import { type PredictionV1RestorationPayload, type PredictionV1VerdictPayload } from './payloads/prediction-v1.js';
+import { type JsonSchema } from './json-schema.js';
+export type SolverNetContractRole = 'creator' | 'solver' | 'evaluator';
+export type PayloadKind = 'task' | 'solution' | 'verdict';
+export type SupportedSolverType = 'prediction.v1' | 'swe-rebench-v2.v1' | 'session-derived.v1';
+export interface CredentialRequirement {
+    id: string;
+    kind: 'public-api' | 'client-owned' | 'operator-credential';
+    required: boolean;
+    description: string;
+}
+export interface SolverNetEvaluationFunction {
+    id: string;
+    deterministic: boolean;
+    inputs: readonly string[];
+    output: string;
+    implementation: string;
+}
+export interface SolverNetAggregationFunction {
+    id: string;
+    deterministic: boolean;
+    inputs: readonly string[];
+    output: string;
+    windowDays?: number;
+}
+export interface SolverNetClaimPolicyDefaults {
+    mode: 'parallel' | 'serial';
+    maxClaims: number;
+    maxClaimsPerOperator: number;
+    claimLeaseTtlSeconds: number;
+}
+/**
+ * A schema entry on a SolverNet contract. Carries both the canonical wire
+ * format (JSON Schema, embedded into manifests) and a Zod validator
+ * (daemon-side ergonomic check). See `spec/2026-05-05-solvernet-creation-and-launch.md` §8.
+ *
+ * The two forms are kept in sync at definition time via `zodToJsonSchema`.
+ */
+export interface SolverNetContractSchema {
+    zod: z.ZodTypeAny;
+    json: JsonSchema;
+}
+export interface SolverNetContract {
+    /** Stable contract identity (e.g. `'prediction'`). */
+    id: string;
+    /** Contract version label (e.g. `'v1'`). */
+    version: string;
+    name: string;
+    schemas: {
+        task: SolverNetContractSchema;
+        solution: SolverNetContractSchema;
+        verdict: SolverNetContractSchema;
+    };
+    claimPolicyDefaults: SolverNetClaimPolicyDefaults;
+    credentialRequirements: Record<SolverNetContractRole, CredentialRequirement[]>;
+    evaluationFunction: SolverNetEvaluationFunction;
+    aggregationFunction: SolverNetAggregationFunction;
+}
+export type SolverNetContractMap = Record<SupportedSolverType, SolverNetContract>;
+export declare const PREDICTION_V1_SOLVER_NET_CONTRACT: SolverNetContract;
+export declare const SWE_REBENCH_V2_V1_SOLVER_NET_CONTRACT: SolverNetContract;
+export declare const SESSION_DERIVED_V1_SOLVER_NET_CONTRACT: SolverNetContract;
+export declare const SOLVER_NET_CONTRACTS: SolverNetContractMap;
+/**
+ * Look up a SolverNet contract template by stable identity ({id, version}).
+ *
+ * The legacy string-keyed signature (`getSolverNetContract('prediction.v1')`)
+ * was removed in Task 30 of `spec/2026-05-05-solvernet-creation-and-launch.md`
+ * alongside `SolverNetContract.solverType`.
+ */
+export declare function getSolverNetContract(ref: {
+    id: string;
+    version: string;
+}): SolverNetContract | undefined;
+/**
+ * Internal helper: derives the legacy `solverType` string (`${id}.${version}`)
+ * from a contract id and version.
+ *
+ * @internal Used only by daemon-internal harness dispatch's compatibility
+ * layer (spec §15 non-goal: the internal `solverType` alias in harness
+ * dispatch is intentionally retained for one cycle past Task 30). NOT
+ * re-exported from the `@jinn-network/sdk/solvernets` barrel and not part
+ * of the SDK's public surface.
+ */
+export declare function solverTypeAlias(ref: {
+    id: string;
+    version: string;
+}): string;
+export interface PayloadValidationIssue {
+    path: string;
+    message: string;
+}
+export interface PayloadValidationFailure {
+    ok: false;
+    error: {
+        code: 'unsupported_solver_type' | 'invalid_payload';
+        message: string;
+        issues: PayloadValidationIssue[];
+    };
+}
+export interface PayloadValidationSuccess<T> {
+    ok: true;
+    value: T;
+}
+export type PayloadValidationResult<T> = PayloadValidationSuccess<T> | PayloadValidationFailure;
+export declare class PayloadValidationException extends Error {
+    readonly code: 'unsupported_solver_type' | 'invalid_payload';
+    readonly issues: PayloadValidationIssue[];
+    constructor(code: 'unsupported_solver_type' | 'invalid_payload', message: string, issues?: PayloadValidationIssue[]);
+}
+export declare function validateTask(solverType: 'prediction.v1', task: unknown): PayloadValidationResult<PredictionV1Task>;
+export declare function validateTask(solverType: string, task: unknown): PayloadValidationResult<unknown>;
+export declare function assertTask(solverType: 'prediction.v1', task: unknown): PredictionV1Task;
+export declare function assertTask(solverType: string, task: unknown): unknown;
+export declare function validateSolutionPayload(solverType: 'prediction.v1', payload: unknown): PayloadValidationResult<PredictionV1RestorationPayload>;
+export declare function validateSolutionPayload(solverType: string, payload: unknown): PayloadValidationResult<Record<string, unknown>>;
+export declare function assertSolutionPayload(solverType: 'prediction.v1', payload: unknown): PredictionV1RestorationPayload;
+export declare function assertSolutionPayload(solverType: string, payload: unknown): Record<string, unknown>;
+export declare function validateVerdictPayload(solverType: 'prediction.v1', payload: unknown): PayloadValidationResult<PredictionV1VerdictPayload>;
+export declare function validateVerdictPayload(solverType: string, payload: unknown): PayloadValidationResult<Record<string, unknown>>;
+export declare function assertVerdictPayload(solverType: 'prediction.v1', payload: unknown): PredictionV1VerdictPayload;
+export declare function assertVerdictPayload(solverType: string, payload: unknown): Record<string, unknown>;
+export interface BuildSolutionOutputArgs {
+    solverType: string;
+    venueName: string;
+    payload: Record<string, unknown>;
+    gating?: Record<string, unknown>;
+    informational?: Record<string, unknown>;
+    artifacts?: OutputArtifact[];
+    rationale?: RationaleEntry[];
+}
+export declare function buildSolutionOutput(args: BuildSolutionOutputArgs): Solution;
+export interface BuildVerdictOutputArgs {
+    solverType: string;
+    venueName?: string;
+    payload: Record<string, unknown>;
+    gating?: Record<string, unknown>;
+    informational?: Record<string, unknown>;
+    artifacts?: OutputArtifact[];
+    rationale?: RationaleEntry[];
+}
+export declare function buildVerdictOutput(args: BuildVerdictOutputArgs): Solution;