@jinn-network/client 0.1.9 → 0.2.0

package/dist/vendor/@jinn-network/plugin/dist/visibility.js

@@ -0,0 +1,9 @@
+/** Retrieval-visibility mark (issue #1824, corpus-supply-design §5 W2): a
+ *  reserved, deterministic distribution tag carried inside the signed
+ *  jinn.trace-envelope.v0 content (task.distributionTags). Presence is the
+ *  sole allowlist signal pickup enforcement keys on — absence excludes,
+ *  fail-closed (opposite of the fail-open skill-detection guards). */
+export const RETRIEVAL_VISIBLE_TAG = 'retrieval:visible.v1';
+export function hasRetrievalMark(tags) {
+    return tags.includes(RETRIEVAL_VISIBLE_TAG);
+}

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

@@ -0,0 +1,22 @@
+{
+  "name": "@jinn-network/plugin",
+  "version": "0.1.0",
+  "description": "Product core for the Jinn Plugin — ports, product schemas, and the createJinnPlugin factory. Stage 1 foundation package (contracts + in-memory kit only).",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./testing": {
+      "import": "./dist/testing.js",
+      "types": "./dist/testing.d.ts"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  }
+}

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

@@ -9,7 +9,7 @@
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §7
  */
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const HarnessCheckpointManifestSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"harness.checkpoint.v1">;
     name: z.ZodString;

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

@@ -9,7 +9,7 @@
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §7
  */
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export const HarnessCheckpointManifestSchema = z.object({
     schemaVersion: z.literal('harness.checkpoint.v1'),
     name: z.string().regex(/^(@[^/]+\/)?[^/@]+$/),

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

@@ -1,11 +1,11 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 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 type SupportedSolverType = 'prediction.v1' | 'swe-rebench-v2.v1' | 'jinn-repo.v1' | 'session-derived.v1';
 export interface CredentialRequirement {
     id: string;
     kind: 'public-api' | 'client-owned' | 'operator-credential';
@@ -62,6 +62,7 @@ export interface SolverNetContract {
 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 JINN_REPO_V1_SOLVER_NET_CONTRACT: SolverNetContract;
 export declare const SESSION_DERIVED_V1_SOLVER_NET_CONTRACT: SolverNetContract;
 export declare const SOLVER_NET_CONTRACTS: SolverNetContractMap;
 /**

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

@@ -2,6 +2,8 @@ import { PredictionV1TaskSchema } from './prediction-v1.js';
 import { PredictionV1RestorationPayloadSchema, PredictionV1VerdictPayloadSchema, } from './payloads/prediction-v1.js';
 import { SweRebenchV2TaskSchema } from './swe-rebench-v2.js';
 import { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, } from './payloads/swe-rebench-v2.js';
+import { JinnRepoTaskSchema } from './jinn-repo.js';
+import { JinnRepoSolutionPayloadSchema, JinnRepoVerdictPayloadSchema, } from './payloads/jinn-repo.js';
 import { SessionDerivedSolutionSchema, SessionDerivedTaskSchema, SessionDerivedVerdictSchema, } from './payloads/session-derived.js';
 import { zodToJsonSchema } from './json-schema.js';
 export const PREDICTION_V1_SOLVER_NET_CONTRACT = {
@@ -120,6 +122,52 @@ export const SWE_REBENCH_V2_V1_SOLVER_NET_CONTRACT = {
         windowDays: 30,
     },
 };
+export const JINN_REPO_V1_SOLVER_NET_CONTRACT = {
+    id: 'jinn-repo',
+    version: 'v1',
+    name: 'Jinn repo',
+    schemas: {
+        task: {
+            zod: JinnRepoTaskSchema,
+            json: zodToJsonSchema(JinnRepoTaskSchema),
+        },
+        solution: {
+            zod: JinnRepoSolutionPayloadSchema,
+            json: zodToJsonSchema(JinnRepoSolutionPayloadSchema),
+        },
+        verdict: {
+            zod: JinnRepoVerdictPayloadSchema,
+            json: zodToJsonSchema(JinnRepoVerdictPayloadSchema),
+        },
+    },
+    claimPolicyDefaults: {
+        mode: 'parallel',
+        maxClaims: 5,
+        maxClaimsPerOperator: 5,
+        claimLeaseTtlSeconds: 60 * 60, // 1 hour per Task — coding tasks need more time than predictions
+    },
+    credentialRequirements: {
+        creator: [],
+        // Solver needs only public git/GitHub read; represented as no declared credential.
+        solver: [],
+        // Repo-native runner (no Docker) — unlike swe-rebench-v2, no Docker credential.
+        evaluator: [],
+    },
+    evaluationFunction: {
+        id: 'jinn-repo.repo-native-test.v1',
+        deterministic: true,
+        inputs: ['Jinn repo Task', 'Jinn repo Solution', 'gold tests from corpus'],
+        output: 'Jinn repo Verdict',
+        implementation: 'client/src/harnesses/impls/jinn-repo-evaluator',
+    },
+    aggregationFunction: {
+        id: 'jinn-repo.multi-winrate.v1',
+        deterministic: true,
+        inputs: ['SCORED jinn-repo.v1 Verdicts'],
+        output: 'structured network-result',
+        windowDays: 30,
+    },
+};
 // ─────────────────────────────────────────────────────────────────────────────
 // SESSION_DERIVED_V1_SOLVER_NET_CONTRACT — Phase 0 / Task 0.4 scaffold.
 //
@@ -190,6 +238,7 @@ export const SESSION_DERIVED_V1_SOLVER_NET_CONTRACT = {
 export const SOLVER_NET_CONTRACTS = {
     'prediction.v1': PREDICTION_V1_SOLVER_NET_CONTRACT,
     'swe-rebench-v2.v1': SWE_REBENCH_V2_V1_SOLVER_NET_CONTRACT,
+    'jinn-repo.v1': JINN_REPO_V1_SOLVER_NET_CONTRACT,
     'session-derived.v1': SESSION_DERIVED_V1_SOLVER_NET_CONTRACT,
 };
 /**

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

@@ -0,0 +1,214 @@
+/**
+ * jinn-repo Task schema. A discriminated union on `source`:
+ *   - `merged-pr` (retrospective): a real merged GitHub PR from the
+ *     Jinn-Network/mono repo — the instance is defined by the PR that
+ *     introduced the fix, and the FAIL_TO_PASS gold is the PR's own test
+ *     files.
+ *   - `live-issue` (prospective): an open GitHub issue on Jinn-Network/mono,
+ *     posted before a fix exists — no gold tests. See
+ *     spec/2026-07-20-autopilot-marketplace-execution.md
+ *     §"No new SolverType: a live variant of jinn-repo".
+ *
+ * `schemaVersion` stays `'jinn-repo.v1'` on both branches so corpus
+ * knowledge autoload (keyed on solverType) keeps working across both.
+ * Backward compatibility: a raw document with no `source` field is legacy
+ * data and is treated as `source: 'merged-pr'`.
+ *
+ * Mirrors the daemon-side schema at `client/src/solver-types/jinn-repo.ts`;
+ * the SDK keeps its own copy so SolverNet contract definitions can reference
+ * it without the SDK importing from the client.
+ */
+import { z } from 'zod/v3';
+export declare const JINN_REPO_SCHEMA_VERSION: "jinn-repo.v1";
+export declare const JinnRepoMergedPrTaskSchema: z.ZodObject<{
+    source: z.ZodDefault<z.ZodLiteral<"merged-pr">>;
+    merged_pr: z.ZodNumber;
+    test_files: z.ZodArray<z.ZodString, "many">;
+    test_cmd: z.ZodString;
+    issue_number: z.ZodOptional<z.ZodNever>;
+    effort: z.ZodOptional<z.ZodNever>;
+    schemaVersion: z.ZodLiteral<"jinn-repo.v1">;
+    instance_id: z.ZodString;
+    repo: z.ZodLiteral<"Jinn-Network/mono">;
+    base_commit: z.ZodString;
+    language: z.ZodLiteral<"typescript">;
+    problem_statement: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo.v1";
+    source: "merged-pr";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    merged_pr: number;
+    test_files: string[];
+    test_cmd: string;
+    issue_number?: undefined;
+    effort?: undefined;
+}, {
+    schemaVersion: "jinn-repo.v1";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    merged_pr: number;
+    test_files: string[];
+    test_cmd: string;
+    source?: "merged-pr" | undefined;
+    issue_number?: undefined;
+    effort?: undefined;
+}>;
+export declare const JinnRepoLiveIssueTaskSchema: z.ZodObject<{
+    source: z.ZodLiteral<"live-issue">;
+    issue_number: z.ZodNumber;
+    effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+    merged_pr: z.ZodOptional<z.ZodNever>;
+    test_files: z.ZodOptional<z.ZodNever>;
+    test_cmd: z.ZodOptional<z.ZodNever>;
+    schemaVersion: z.ZodLiteral<"jinn-repo.v1">;
+    instance_id: z.ZodString;
+    repo: z.ZodLiteral<"Jinn-Network/mono">;
+    base_commit: z.ZodString;
+    language: z.ZodLiteral<"typescript">;
+    problem_statement: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo.v1";
+    source: "live-issue";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    issue_number: number;
+    merged_pr?: undefined;
+    test_files?: undefined;
+    test_cmd?: undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}, {
+    schemaVersion: "jinn-repo.v1";
+    source: "live-issue";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    issue_number: number;
+    merged_pr?: undefined;
+    test_files?: undefined;
+    test_cmd?: undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}>;
+export declare const JinnRepoTaskSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"source", [z.ZodObject<{
+    source: z.ZodDefault<z.ZodLiteral<"merged-pr">>;
+    merged_pr: z.ZodNumber;
+    test_files: z.ZodArray<z.ZodString, "many">;
+    test_cmd: z.ZodString;
+    issue_number: z.ZodOptional<z.ZodNever>;
+    effort: z.ZodOptional<z.ZodNever>;
+    schemaVersion: z.ZodLiteral<"jinn-repo.v1">;
+    instance_id: z.ZodString;
+    repo: z.ZodLiteral<"Jinn-Network/mono">;
+    base_commit: z.ZodString;
+    language: z.ZodLiteral<"typescript">;
+    problem_statement: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo.v1";
+    source: "merged-pr";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    merged_pr: number;
+    test_files: string[];
+    test_cmd: string;
+    issue_number?: undefined;
+    effort?: undefined;
+}, {
+    schemaVersion: "jinn-repo.v1";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    merged_pr: number;
+    test_files: string[];
+    test_cmd: string;
+    source?: "merged-pr" | undefined;
+    issue_number?: undefined;
+    effort?: undefined;
+}>, z.ZodObject<{
+    source: z.ZodLiteral<"live-issue">;
+    issue_number: z.ZodNumber;
+    effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+    merged_pr: z.ZodOptional<z.ZodNever>;
+    test_files: z.ZodOptional<z.ZodNever>;
+    test_cmd: z.ZodOptional<z.ZodNever>;
+    schemaVersion: z.ZodLiteral<"jinn-repo.v1">;
+    instance_id: z.ZodString;
+    repo: z.ZodLiteral<"Jinn-Network/mono">;
+    base_commit: z.ZodString;
+    language: z.ZodLiteral<"typescript">;
+    problem_statement: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo.v1";
+    source: "live-issue";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    issue_number: number;
+    merged_pr?: undefined;
+    test_files?: undefined;
+    test_cmd?: undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}, {
+    schemaVersion: "jinn-repo.v1";
+    source: "live-issue";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    issue_number: number;
+    merged_pr?: undefined;
+    test_files?: undefined;
+    test_cmd?: undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}>]>, {
+    schemaVersion: "jinn-repo.v1";
+    source: "merged-pr";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    merged_pr: number;
+    test_files: string[];
+    test_cmd: string;
+    issue_number?: undefined;
+    effort?: undefined;
+} | {
+    schemaVersion: "jinn-repo.v1";
+    source: "live-issue";
+    instance_id: string;
+    repo: "Jinn-Network/mono";
+    base_commit: string;
+    language: "typescript";
+    problem_statement: string;
+    issue_number: number;
+    merged_pr?: undefined;
+    test_files?: undefined;
+    test_cmd?: undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}, unknown>;
+export type JinnRepoMergedPrTask = z.infer<typeof JinnRepoMergedPrTaskSchema>;
+export type JinnRepoLiveIssueTask = z.infer<typeof JinnRepoLiveIssueTaskSchema>;
+export type JinnRepoTask = JinnRepoMergedPrTask | JinnRepoLiveIssueTask;
+/** Narrows a `JinnRepoTask` to the retrospective (merged-PR, gold-tested) branch. */
+export declare function isMergedPrTask(task: JinnRepoTask): task is JinnRepoMergedPrTask;
+/** Narrows a `JinnRepoTask` to the prospective (live-issue, no-gold) branch. */
+export declare function isLiveIssueTask(task: JinnRepoTask): task is JinnRepoLiveIssueTask;

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

@@ -0,0 +1,75 @@
+/**
+ * jinn-repo Task schema. A discriminated union on `source`:
+ *   - `merged-pr` (retrospective): a real merged GitHub PR from the
+ *     Jinn-Network/mono repo — the instance is defined by the PR that
+ *     introduced the fix, and the FAIL_TO_PASS gold is the PR's own test
+ *     files.
+ *   - `live-issue` (prospective): an open GitHub issue on Jinn-Network/mono,
+ *     posted before a fix exists — no gold tests. See
+ *     spec/2026-07-20-autopilot-marketplace-execution.md
+ *     §"No new SolverType: a live variant of jinn-repo".
+ *
+ * `schemaVersion` stays `'jinn-repo.v1'` on both branches so corpus
+ * knowledge autoload (keyed on solverType) keeps working across both.
+ * Backward compatibility: a raw document with no `source` field is legacy
+ * data and is treated as `source: 'merged-pr'`.
+ *
+ * Mirrors the daemon-side schema at `client/src/solver-types/jinn-repo.ts`;
+ * the SDK keeps its own copy so SolverNet contract definitions can reference
+ * it without the SDK importing from the client.
+ */
+import { z } from 'zod/v3';
+export const JINN_REPO_SCHEMA_VERSION = 'jinn-repo.v1';
+const commonFields = {
+    schemaVersion: z.literal(JINN_REPO_SCHEMA_VERSION),
+    instance_id: z.string().min(1),
+    repo: z.literal('Jinn-Network/mono'),
+    base_commit: z.string().regex(/^[0-9a-f]{40}$/),
+    language: z.literal('typescript'),
+    problem_statement: z.string().min(1),
+};
+// NOTE on strictness: these schemas deliberately do NOT call `.strict()` —
+// mirrors the daemon-side schema, which tolerates the CLI submit wrapper's
+// unrelated keys (`id`, `description`, `solverType`, `spec`) via zod's
+// default "strip" mode. The two oracle-field groups are instead declared as
+// `z.never().optional()` on the branch they must never appear on, so a
+// genuine cross-branch leak (e.g. `merged_pr` on a live-issue task) is a
+// hard validation error rather than silent stripping.
+export const JinnRepoMergedPrTaskSchema = z.object({
+    ...commonFields,
+    source: z.literal('merged-pr').default('merged-pr'),
+    merged_pr: z.number().int().positive(),
+    // The PR's own test files — the FAIL_TO_PASS gold. A task with none is ungradeable.
+    test_files: z.array(z.string().min(1)).min(1),
+    // The exact command the evaluator runs (scoped to test_files).
+    test_cmd: z.string().min(1),
+    // Live-issue-only fields — never valid on a merged-pr task.
+    issue_number: z.never().optional(),
+    effort: z.never().optional(),
+});
+export const JinnRepoLiveIssueTaskSchema = z.object({
+    ...commonFields,
+    source: z.literal('live-issue'),
+    // The open GitHub issue this task snapshots.
+    issue_number: z.number().int().positive(),
+    // The board's Effort field (reasoning-depth signal).
+    effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+    // Merged-pr-only gold-oracle fields — never valid on a live-issue task.
+    merged_pr: z.never().optional(),
+    test_files: z.never().optional(),
+    test_cmd: z.never().optional(),
+});
+export const JinnRepoTaskSchema = z.preprocess((val) => {
+    if (val !== null && typeof val === 'object' && !('source' in val)) {
+        return { ...val, source: 'merged-pr' };
+    }
+    return val;
+}, z.discriminatedUnion('source', [JinnRepoMergedPrTaskSchema, JinnRepoLiveIssueTaskSchema]));
+/** Narrows a `JinnRepoTask` to the retrospective (merged-PR, gold-tested) branch. */
+export function isMergedPrTask(task) {
+    return task.source === 'merged-pr';
+}
+/** Narrows a `JinnRepoTask` to the prospective (live-issue, no-gold) branch. */
+export function isLiveIssueTask(task) {
+    return task.source === 'live-issue';
+}

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 /**
  * Canonical JSON Schema body. We use a permissive object alias rather than a
  * strict type because manifests carry arbitrary user-authored schemas and the

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

@@ -8,7 +8,7 @@
 // externally-launched SolverNet manifest into a runnable validator).
 //
 // See `spec/2026-05-05-solvernet-creation-and-launch.md` §7 and §8.
-import { z } from 'zod';
+import { z } from 'zod/v3';
 import { zodToJsonSchema as zodToJsonSchemaImpl } from 'zod-to-json-schema';
 /**
  * Serialize a Zod schema to canonical JSON Schema (draft-07).

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

@@ -0,0 +1,140 @@
+/**
+ * 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, or a prospective
+ * live GitHub issue — see `source` on the Task schema). Mirrors the
+ * swe-rebench-v2 Solution shape; trajectory provenance is pinned via the
+ * envelope, not the payload.
+ *
+ * Verdict: two schema versions, keyed to the Task's `source`:
+ *   - v1: merged-pr grading — the repo-native gold FAIL_TO_PASS test runner's
+ *     pass/fail, with an optional log excerpt for human inspection.
+ *   - v2 (issue #1891): live-issue grading — no gold tests exist
+ *     prospectively, so the mechanical evaluator grades three gates (patch
+ *     applies, typecheck, policy-scoped tests) instead. Additive over v1:
+ *     keeps `passed`/`test_log_excerpt` and adds `gates`. Mirrors the
+ *     swe-rebench-v2-verdict.v1 → .v2 additive precedent in
+ *     `./swe-rebench-v2.ts`.
+ *
+ * The full test log is surfaced via the envelope's `artifacts[]` rather than
+ * as a typed payload field on either version.
+ */
+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 JinnRepoVerdictV1PayloadSchema: 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 JinnRepoVerdictV1Payload = z.infer<typeof JinnRepoVerdictV1PayloadSchema>;
+/**
+ * v2 — mechanical evaluator for live-issue (no-gold) tasks (issue #1891).
+ * `gates` records the three-stage grade the live-eval-runner computes
+ * (applies → typecheck → tests, each AND-gated into `passed`).
+ */
+export declare const JinnRepoVerdictV2PayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn-repo-verdict.v2">;
+    passed: z.ZodBoolean;
+    test_log_excerpt: z.ZodOptional<z.ZodString>;
+    gates: z.ZodObject<{
+        applies: z.ZodBoolean;
+        typecheck: z.ZodBoolean;
+        tests: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    }, {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo-verdict.v2";
+    passed: boolean;
+    gates: {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    };
+    test_log_excerpt?: string | undefined;
+}, {
+    schemaVersion: "jinn-repo-verdict.v2";
+    passed: boolean;
+    gates: {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    };
+    test_log_excerpt?: string | undefined;
+}>;
+export type JinnRepoVerdictV2Payload = z.infer<typeof JinnRepoVerdictV2PayloadSchema>;
+/** Accept either schema version on the read path. */
+export declare const JinnRepoVerdictPayloadSchema: z.ZodUnion<[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;
+}>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn-repo-verdict.v2">;
+    passed: z.ZodBoolean;
+    test_log_excerpt: z.ZodOptional<z.ZodString>;
+    gates: z.ZodObject<{
+        applies: z.ZodBoolean;
+        typecheck: z.ZodBoolean;
+        tests: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    }, {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn-repo-verdict.v2";
+    passed: boolean;
+    gates: {
+        applies: boolean;
+        typecheck: boolean;
+        tests: boolean;
+    };
+    test_log_excerpt?: string | undefined;
+}, {
+    schemaVersion: "jinn-repo-verdict.v2";
+    passed: boolean;
+    gates: {
+        applies: boolean;
+        typecheck: boolean;
+        tests: 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,52 @@
+/**
+ * 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, or a prospective
+ * live GitHub issue — see `source` on the Task schema). Mirrors the
+ * swe-rebench-v2 Solution shape; trajectory provenance is pinned via the
+ * envelope, not the payload.
+ *
+ * Verdict: two schema versions, keyed to the Task's `source`:
+ *   - v1: merged-pr grading — the repo-native gold FAIL_TO_PASS test runner's
+ *     pass/fail, with an optional log excerpt for human inspection.
+ *   - v2 (issue #1891): live-issue grading — no gold tests exist
+ *     prospectively, so the mechanical evaluator grades three gates (patch
+ *     applies, typecheck, policy-scoped tests) instead. Additive over v1:
+ *     keeps `passed`/`test_log_excerpt` and adds `gates`. Mirrors the
+ *     swe-rebench-v2-verdict.v1 → .v2 additive precedent in
+ *     `./swe-rebench-v2.ts`.
+ *
+ * The full test log is surfaced via the envelope's `artifacts[]` rather than
+ * as a typed payload field on either version.
+ */
+import { z } from 'zod/v3';
+export const JinnRepoSolutionPayloadSchema = z.object({
+    schemaVersion: z.literal('jinn-repo-solution.v1'),
+    patch: z.string().min(1),
+});
+export const JinnRepoVerdictV1PayloadSchema = z.object({
+    schemaVersion: z.literal('jinn-repo-verdict.v1'),
+    passed: z.boolean(),
+    test_log_excerpt: z.string().optional(),
+});
+/**
+ * v2 — mechanical evaluator for live-issue (no-gold) tasks (issue #1891).
+ * `gates` records the three-stage grade the live-eval-runner computes
+ * (applies → typecheck → tests, each AND-gated into `passed`).
+ */
+export const JinnRepoVerdictV2PayloadSchema = z.object({
+    schemaVersion: z.literal('jinn-repo-verdict.v2'),
+    passed: z.boolean(),
+    test_log_excerpt: z.string().optional(),
+    gates: z.object({
+        applies: z.boolean(),
+        typecheck: z.boolean(),
+        tests: z.boolean(),
+    }),
+});
+/** Accept either schema version on the read path. */
+export const JinnRepoVerdictPayloadSchema = z.union([
+    JinnRepoVerdictV1PayloadSchema,
+    JinnRepoVerdictV2PayloadSchema,
+]);

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(),