@jinn-network/client 0.1.9 → 0.2.0-canary.0b79cd5d

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

@@ -0,0 +1,285 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod/v3';
+const Sha256DigestZ = z
+    .string()
+    .regex(/^sha256:[0-9a-f]{64}$/u, { message: 'must be sha256:<64 hex chars>' });
+const NumericStringZ = z
+    .string()
+    .regex(/^\d+$/u, { message: 'must be a non-negative integer string (wei)' });
+const HexStringZ = z
+    .string()
+    .regex(/^0x[0-9a-fA-F]+$/u, {
+    message: 'must be 0x-prefixed hex with at least one hex digit',
+});
+const SolveProfileZ = z
+    .object({
+    harness: z.string().min(1),
+    harnessVersionOrDigest: z.string().min(1),
+    model: z.string().min(1),
+})
+    .strict();
+const LoadoutZ = z.discriminatedUnion('kind', [
+    z
+        .object({
+        kind: z.literal('artifact'),
+        ref: z.string().min(1),
+        sha256: Sha256DigestZ,
+    })
+        .strict(),
+    z.object({ kind: z.literal('none') }).strict(),
+]);
+export const ConfigV1Schema = z
+    .object({
+    configId: z.string().min(1),
+    solveProfile: SolveProfileZ,
+    loadout: LoadoutZ,
+    envOverrides: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+function issuesFromZod(error) {
+    return error.issues.map((issue) => ({
+        path: issue.path.length > 0 ? issue.path.join('.') : '<root>',
+        message: issue.message,
+    }));
+}
+export function validateConfigV1(value) {
+    const parsed = ConfigV1Schema.safeParse(value);
+    if (parsed.success)
+        return { ok: true, value: parsed.data };
+    return { ok: false, issues: issuesFromZod(parsed.error) };
+}
+/** Minimal RFC 8785 JCS — identical algorithm to swe-rebench-v2-held-out-slate.ts */
+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);
+}
+function sha256Digest(canonical) {
+    return `sha256:${createHash('sha256').update(canonical).digest('hex')}`;
+}
+export function hashCapsuleSet(input) {
+    return sha256Digest(canonicalJson({
+        capsuleDigests: input.capsuleDigests,
+        admissionReceiptRefs: input.admissionReceiptRefs,
+    }));
+}
+const CapsuleSetZ = z
+    .object({
+    capsuleDigests: z.array(z.string().min(1)).min(1),
+    admissionReceiptRefs: z.array(z.string().min(1)).min(1),
+    setHash: Sha256DigestZ,
+})
+    .strict();
+const PolicyZ = z
+    .object({
+    completenessFloor: z.number().finite().gt(0).lte(1),
+    replacementPolicy: z.string().min(1),
+    eligibilityExclusions: z.array(z.string()),
+    cellWindow: z.string().min(1),
+    selfEvaluation: z.literal(false),
+})
+    .strict();
+const BudgetZ = z
+    .object({
+    perCellFees: z
+        .object({
+        solveWei: NumericStringZ,
+        verdictWei: NumericStringZ,
+    })
+        .strict(),
+    hardCapWei: NumericStringZ,
+})
+    .strict();
+export const BenchmarkRunV1Schema = z
+    .object({
+    runId: z.string().min(1),
+    consumer: z.string().min(1),
+    capsuleSet: CapsuleSetZ,
+    configs: z.array(ConfigV1Schema).min(1),
+    replicates: z.number().int().gte(1),
+    policy: PolicyZ,
+    budget: BudgetZ,
+    preRegistrationHash: Sha256DigestZ,
+})
+    .strict()
+    .superRefine((run, ctx) => {
+    const seen = new Set();
+    for (let i = 0; i < run.configs.length; i++) {
+        const id = run.configs[i].configId;
+        if (seen.has(id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `duplicate configId: ${id}`,
+                path: ['configs', i, 'configId'],
+            });
+        }
+        seen.add(id);
+    }
+});
+export function hashBenchmarkRunV1(run) {
+    const { preRegistrationHash: _omit, ...rest } = run;
+    return sha256Digest(canonicalJson(rest));
+}
+/** Documented alias — identical projection/result as preRegistrationHash computation (AC2). */
+export const computeRunHash = hashBenchmarkRunV1;
+export function validateBenchmarkRunV1(value) {
+    const parsed = BenchmarkRunV1Schema.safeParse(value);
+    if (!parsed.success)
+        return { ok: false, issues: issuesFromZod(parsed.error) };
+    const run = parsed.data;
+    const issues = [];
+    const expectedSet = hashCapsuleSet({
+        capsuleDigests: run.capsuleSet.capsuleDigests,
+        admissionReceiptRefs: run.capsuleSet.admissionReceiptRefs,
+    });
+    if (run.capsuleSet.setHash !== expectedSet) {
+        issues.push({ path: 'capsuleSet.setHash', message: 'hash mismatch' });
+    }
+    const expectedPre = hashBenchmarkRunV1(run);
+    if (run.preRegistrationHash !== expectedPre) {
+        issues.push({ path: 'preRegistrationHash', message: 'hash mismatch' });
+    }
+    if (issues.length > 0)
+        return { ok: false, issues };
+    return { ok: true, value: run };
+}
+const SignatureZ = z
+    .object({
+    alg: z.literal('eip-191'),
+    signer: HexStringZ,
+    value: HexStringZ,
+})
+    .strict();
+export const BenchPreregistrationV1Schema = z
+    .object({
+    schemaVersion: z.literal('jinn.bench-preregistration.v1'),
+    run: BenchmarkRunV1Schema,
+    signature: SignatureZ,
+})
+    .strict();
+export function validateBenchPreregistrationV1(value) {
+    const parsed = BenchPreregistrationV1Schema.safeParse(value);
+    if (!parsed.success)
+        return { ok: false, issues: issuesFromZod(parsed.error) };
+    const runCheck = validateBenchmarkRunV1(parsed.data.run);
+    if (!runCheck.ok) {
+        return {
+            ok: false,
+            issues: runCheck.issues.map((i) => ({
+                path: i.path === '<root>' ? 'run' : `run.${i.path}`,
+                message: i.message,
+            })),
+        };
+    }
+    return { ok: true, value: parsed.data };
+}
+const VerificationZ = z
+    .object({
+    loadout: z.enum(['match', 'mismatch', 'unverifiable']),
+    profile: z.enum(['match', 'mismatch', 'unverifiable']),
+    isolation: z.string().min(1),
+})
+    .strict();
+const CostZ = z
+    .object({
+    reported: z.union([NumericStringZ, z.number().finite().nonnegative()]),
+    source: z.string().min(1),
+})
+    .strict();
+export const CellV1Schema = z
+    .object({
+    cellKey: z.string().min(1),
+    capsuleDigest: z.string().min(1),
+    configId: z.string().min(1),
+    replicate: z.number().int().nonnegative(),
+    attemptEnvelopeCid: z.string().min(1).optional(),
+    verdictEnvelopeRef: z.string().min(1).optional(),
+    outcome: z.enum(['judged', 'unscorable', 'expired', 'invalidated']),
+    verification: VerificationZ,
+    judgeIntegrityTier: z.enum(['re-derivable', 'attested-only']),
+    solverId: z.string().min(1),
+    evaluatorId: z.string().min(1),
+    cost: CostZ,
+    latencyMs: z.number().finite().nonnegative(),
+})
+    .strict();
+const CloseBoundaryZ = z
+    .object({
+    blockNumber: z.number().int().positive().optional(),
+    timestamp: z.string().min(1),
+})
+    .strict();
+export const BenchMatrixV1Schema = z
+    .object({
+    schemaVersion: z.literal('jinn.bench-matrix.v1'),
+    runId: z.string().min(1),
+    preRegistration: BenchmarkRunV1Schema,
+    closeBoundary: CloseBoundaryZ,
+    cells: z.array(CellV1Schema),
+    exclusions: z.array(z.object({ cellKey: z.string().min(1), reason: z.string().min(1) }).strict()),
+    attrition: z
+        .object({
+        perConfig: z.record(z.string(), z.number().finite().nonnegative()),
+        perCapsule: z.record(z.string(), z.number().finite().nonnegative()),
+        asymmetryFlags: z.array(z.string()),
+    })
+        .strict(),
+    completeness: z
+        .object({
+        achieved: z.number().finite().nonnegative(),
+        floor: z.number().finite().nonnegative(),
+        runOutcome: z.enum(['complete', 'partial', 'cancelled']),
+    })
+        .strict(),
+    matrixHash: Sha256DigestZ,
+})
+    .strict()
+    .superRefine((matrix, ctx) => {
+    const seen = new Set();
+    for (let i = 0; i < matrix.cells.length; i++) {
+        const key = matrix.cells[i].cellKey;
+        if (seen.has(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `duplicate cellKey: ${key}`,
+                path: ['cells', i, 'cellKey'],
+            });
+        }
+        seen.add(key);
+    }
+});
+export function hashBenchMatrixV1(matrix) {
+    const { matrixHash: _omit, ...rest } = matrix;
+    return sha256Digest(canonicalJson(rest));
+}
+export function validateBenchMatrixV1(value) {
+    const parsed = BenchMatrixV1Schema.safeParse(value);
+    if (!parsed.success)
+        return { ok: false, issues: issuesFromZod(parsed.error) };
+    const matrix = parsed.data;
+    const issues = [];
+    const runCheck = validateBenchmarkRunV1(matrix.preRegistration);
+    if (!runCheck.ok) {
+        for (const i of runCheck.issues) {
+            issues.push({
+                path: i.path === '<root>' ? 'preRegistration' : `preRegistration.${i.path}`,
+                message: i.message,
+            });
+        }
+    }
+    const expected = hashBenchMatrixV1(matrix);
+    if (matrix.matrixHash !== expected) {
+        issues.push({ path: 'matrixHash', message: 'hash mismatch' });
+    }
+    if (issues.length > 0)
+        return { ok: false, issues };
+    return { ok: true, value: matrix };
+}

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;
@@ -53,19 +53,20 @@ export declare const HarnessCheckpointManifestSchema: z.ZodObject<{
         txHash: z.ZodString;
         blockNumber: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
+        blockNumber: number;
         anchor: "IdentityRegistry.setMetadata";
         metadataKey: string;
         txHash: string;
-        blockNumber: number;
     }, {
+        blockNumber: number;
         anchor: "IdentityRegistry.setMetadata";
         metadataKey: string;
         txHash: string;
-        blockNumber: number;
     }>;
     signature: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     schemaVersion: "harness.checkpoint.v1";
+    signature: string;
     name: string;
     version: string;
     parentCheckpointCid: string | null;
@@ -84,14 +85,14 @@ export declare const HarnessCheckpointManifestSchema: z.ZodObject<{
     };
     publishedAt: string;
     registry: {
+        blockNumber: number;
         anchor: "IdentityRegistry.setMetadata";
         metadataKey: string;
         txHash: string;
-        blockNumber: number;
     };
-    signature: string;
 }, {
     schemaVersion: "harness.checkpoint.v1";
+    signature: string;
     name: string;
     version: string;
     parentCheckpointCid: string | null;
@@ -110,11 +111,10 @@ export declare const HarnessCheckpointManifestSchema: z.ZodObject<{
     };
     publishedAt: string;
     registry: {
+        blockNumber: number;
         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

@@ -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?: "max" | "low" | "medium" | "high" | "xhigh" | 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?: "max" | "low" | "medium" | "high" | "xhigh" | 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?: "max" | "low" | "medium" | "high" | "xhigh" | 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?: "max" | "low" | "medium" | "high" | "xhigh" | 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?: "max" | "low" | "medium" | "high" | "xhigh" | 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;