@jinn-network/client 0.1.6 → 0.1.7-canary.0a586ca9

package/dist/solver-types/swe-rebench-v2.js

@@ -1,27 +1,32 @@
 /**
  * SolverTypeDefinition for swe-rebench-v2.v1.
  *
- * Wires the pool builder, state store, and selectNextPostingCandidate
+ * Wires the pool builder, state store, and selectNextPostingCandidates
  * policy from the supporting modules (_swe-rebench-v2-pool, _swe-rebench-v2-state,
  * swe-rebench-v2-auto) into the SolverTypeDefinition interface consumed by
  * collectTestnetAutoTaskGenerators.
  *
  * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.6
  */
+import { stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { getSolverNetContract } from '../vendor/@jinn-network/sdk/dist/solvernets/index.js';
 import { SweRebenchV2TaskSchema } from '../vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2.js';
 import { signTaskV1 } from '../tasks/signing.js';
-import { selectNextPostingCandidate, DEFAULT_GENERATOR_CONFIG, } from './swe-rebench-v2-auto.js';
+import { uploadToIpfs } from '../adapters/mech/ipfs.js';
+import { selectNextPostingCandidates, summarizePoolState, DEFAULT_GENERATOR_CONFIG, } from './swe-rebench-v2-auto.js';
 import { GeneratorStateStore } from './_swe-rebench-v2-state.js';
-import { ValidatedPoolStore, filterToScorablePool, EVAL_SEMANTICS_VERSION, } from './_swe-rebench-v2-validated-pool.js';
+import { ValidatedPoolStore, filterToScorablePool, EVAL_SEMANTICS_VERSION, VETTED_POOL_REF_ELIGIBILITY_KEY, createVettedPoolArtifactRef, exportScorableVettedPoolArtifact, hashVettedPoolArtifact, loadVettedPoolArtifactScorableEntries, readVettedPoolArtifactPublication, writeVettedPoolArtifactPublication, } from './_swe-rebench-v2-validated-pool.js';
 import { buildHistoricalPool, fetchHfSplit, listMonthlyPartitions, } from './_swe-rebench-v2-pool.js';
+import { fetchHfWithRetry } from '../harnesses/impls/swe-rebench-v2-evaluator/hf-fetcher.js';
+import { PoolCacheStore, loadPoolWithCacheFallback } from './_swe-rebench-v2-pool-cache.js';
 export const HF_DATASET = 'nebius/SWE-rebench-leaderboard';
 const SOLVER_TYPE = 'swe-rebench-v2.v1';
 const CONTRACT_ID = 'swe-rebench-v2';
 const CONTRACT_VERSION = 'v1';
+const DEFAULT_IPFS_REGISTRY_URL = 'https://registry.autonolas.tech';
 /** How long the pool is cached before a full refresh (24 h). */
 const POOL_REFRESH_MS = 24 * 60 * 60 * 1000;
 export function defaultStateDir() {
@@ -34,7 +39,9 @@ export function defaultStateDir() {
  */
 export async function loadSweRebenchV2Pool() {
     const splitsUrl = `https://datasets-server.huggingface.co/splits?dataset=${encodeURIComponent(HF_DATASET)}`;
-    const response = await fetch(splitsUrl);
+    // Route through the shared HF retry helper so the /splits endpoint gets the
+    // same jittered 429-backoff treatment as /rows (issue #578).
+    const response = await fetchHfWithRetry(splitsUrl, {});
     if (!response.ok)
         throw new Error(`HF splits fetch failed: ${response.status}`);
     const json = (await response.json());
@@ -54,22 +61,24 @@ export function getSweRebenchV2ValidatedPoolStore(stateDir) {
 function positiveInt(value, fallback) {
     return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : fallback;
 }
-function nonNegativeInt(value, fallback) {
-    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : fallback;
-}
 const DEFAULT_ADMISSION_MODE = 'required';
 function normalizeGeneratorConfig(raw) {
     const cfg = typeof raw === 'object' && raw !== null
         ? raw
         : {};
+    const legacyPolicy = typeof cfg['claimPolicy'] === 'object' && cfg['claimPolicy'] !== null
+        ? cfg['claimPolicy']
+        : {};
     const N_target_successes = positiveInt(cfg['N_target_successes'], DEFAULT_GENERATOR_CONFIG.N_target_successes);
-    const N_max_postings_per_task = Math.max(N_target_successes, positiveInt(cfg['N_max_postings_per_task'], DEFAULT_GENERATOR_CONFIG.N_max_postings_per_task));
     const rawMode = cfg['admissionMode'];
     const admissionMode = rawMode === 'python-floor' ? 'python-floor' : DEFAULT_ADMISSION_MODE;
+    const maxClaimsPerOperator = positiveInt(cfg['maxClaimsPerOperator'] ?? legacyPolicy['maxClaimsPerOperator'], 0);
     return {
         N_target_successes,
-        N_max_postings_per_task,
-        cooldown_ms: nonNegativeInt(cfg['cooldown_ms'], DEFAULT_GENERATOR_CONFIG.cooldown_ms),
+        posting_window_ms: positiveInt(cfg['posting_window_ms'], DEFAULT_GENERATOR_CONFIG.posting_window_ms),
+        post_batch_size: positiveInt(cfg['post_batch_size'], DEFAULT_GENERATOR_CONFIG.post_batch_size),
+        ...(maxClaimsPerOperator > 0 ? { maxClaimsPerOperator } : {}),
+        claimLeaseTtlSeconds: positiveInt(cfg['claimLeaseTtlSeconds'] ?? legacyPolicy['claimLeaseTtlSeconds'], DEFAULT_GENERATOR_CONFIG.claimLeaseTtlSeconds),
         admissionMode,
     };
 }
@@ -119,26 +128,77 @@ function sweRebenchDefaultClaimPolicy() {
     const defaults = contract?.claimPolicyDefaults;
     return {
         mode: defaults?.mode === 'serial' ? 'exclusive' : 'parallel',
-        maxClaims: defaults?.maxClaims ?? 50,
-        maxClaimsPerOperator: defaults?.maxClaimsPerOperator ?? 5,
+        maxClaims: defaults?.maxClaims ?? DEFAULT_GENERATOR_CONFIG.N_target_successes,
+        maxClaimsPerOperator: defaults?.maxClaimsPerOperator ?? DEFAULT_GENERATOR_CONFIG.N_target_successes,
         claimLeaseTtlSeconds: defaults?.claimLeaseTtlSeconds ?? 60 * 60,
     };
 }
-function normalizeClaimPolicy(raw) {
+function claimPolicyForPosting(genConfig, remainingTargetSuccesses) {
     const defaults = sweRebenchDefaultClaimPolicy();
-    const cfg = typeof raw === 'object' && raw !== null
-        ? raw
-        : {};
-    const policy = typeof cfg.claimPolicy === 'object' && cfg.claimPolicy !== null
-        ? cfg.claimPolicy
-        : {};
-    const maxClaims = positiveInt(policy.maxClaims, defaults.maxClaims);
-    const maxClaimsPerOperator = Math.min(maxClaims, positiveInt(policy.maxClaimsPerOperator, defaults.maxClaimsPerOperator));
+    const maxClaims = Math.max(1, remainingTargetSuccesses);
+    const maxClaimsPerOperator = Math.min(maxClaims, genConfig.maxClaimsPerOperator ?? maxClaims);
     return {
         ...defaults,
         maxClaims,
         maxClaimsPerOperator,
-        claimLeaseTtlSeconds: positiveInt(policy.claimLeaseTtlSeconds, defaults.claimLeaseTtlSeconds),
+        claimLeaseTtlSeconds: genConfig.claimLeaseTtlSeconds,
+    };
+}
+async function resolvePublishedVettedPool(args) {
+    if (!args.manifestCid) {
+        return { scorableIds: null, artifactRef: null, mode: 'no-manifest' };
+    }
+    const existing = await readVettedPoolArtifactPublication({
+        stateDir: args.stateDir,
+        manifestCid: args.manifestCid,
+        evalSemanticsVersion: EVAL_SEMANTICS_VERSION,
+    });
+    let priorSize;
+    if (existing) {
+        const scorable = await args.store.getScorableEntries(EVAL_SEMANTICS_VERSION);
+        const validatedNewer = scorable !== null && scorable.updatedAt > existing.updatedAt;
+        if (!validatedNewer) {
+            return {
+                scorableIds: loadVettedPoolArtifactScorableEntries(existing.artifact).ids,
+                artifactRef: existing.ref,
+                mode: 'published',
+            };
+        }
+        priorSize = existing.artifact.entries.length;
+    }
+    const artifact = await exportScorableVettedPoolArtifact(args.store, EVAL_SEMANTICS_VERSION, {
+        generatedAt: args.nowIso,
+    });
+    if (!artifact || artifact.entries.length === 0) {
+        return { scorableIds: null, artifactRef: null, mode: 'no-publication' };
+    }
+    const artifactCid = await args.upload(args.ipfsRegistryUrl, artifact);
+    const artifactRef = createVettedPoolArtifactRef({
+        manifestCid: args.manifestCid,
+        artifactCid,
+        artifactHash: hashVettedPoolArtifact(artifact),
+        evalSemanticsVersion: EVAL_SEMANTICS_VERSION,
+        publishedAt: args.nowIso,
+    });
+    await writeVettedPoolArtifactPublication({
+        stateDir: args.stateDir,
+        ref: artifactRef,
+        artifact,
+        updatedAt: args.nowIso,
+    });
+    return {
+        scorableIds: loadVettedPoolArtifactScorableEntries(artifact).ids,
+        artifactRef,
+        mode: 'published-from-local',
+        ...(priorSize !== undefined
+            ? {
+                republication: {
+                    priorSize,
+                    currentSize: artifact.entries.length,
+                    publishedAt: args.nowIso,
+                },
+            }
+            : {}),
     };
 }
 async function maybeSignTask(task, opts) {
@@ -160,7 +220,7 @@ async function maybeSignTask(task, opts) {
         window: task.window,
         spec: task.spec ?? {},
         eligibility: task.eligibility ?? {},
-        claimPolicy: task.claimPolicy ?? normalizeClaimPolicy(undefined),
+        claimPolicy: task.claimPolicy ?? sweRebenchDefaultClaimPolicy(),
         creator: {
             safeAddress: opts.creator.safeAddress,
             agentEoa: opts.creator.agentEoa,
@@ -179,51 +239,132 @@ async function maybeSignTask(task, opts) {
 function makeSweRebenchV2Generator(config) {
     const stateStore = new GeneratorStateStore({ stateDir: config.stateDir });
     const validatedPoolStore = new ValidatedPoolStore({ stateDir: config.stateDir });
+    const poolCache = new PoolCacheStore({ stateDir: config.stateDir });
     let pool = [];
     let poolLoadedAt = 0;
+    let poolFromCache = false;
     let floorWarned = false;
+    let publicationWarned = false;
     let lastPostedLanguage;
     let lastPollAt;
     let lastPollSummary;
     let lastError;
     let totalPosted = 0;
     let lastPostedInstanceId;
+    let publishedPoolCache = null;
+    let lastValidatedPoolMtimeMs = -1;
+    let lastRepublication;
     async function refreshPool() {
-        try {
-            pool = await loadSweRebenchV2Pool();
+        const result = await loadPoolWithCacheFallback({
+            loadPool: loadSweRebenchV2Pool,
+            cache: poolCache,
+            currentPool: pool,
+        });
+        pool = result.pool;
+        poolFromCache = result.fromCache;
+        lastError = result.error;
+        if (!result.error) {
+            // Fresh HF load — hold it for the full POOL_REFRESH_MS window.
             poolLoadedAt = Date.now();
         }
-        catch (err) {
-            // Non-fatal: keep the existing pool if already loaded
-            lastError = {
-                message: err instanceof Error ? err.message : String(err),
-                at: new Date().toISOString(),
-            };
-            console.warn(`[swe-rebench-v2-gen] pool refresh failed (using ${pool.length} cached tasks):`, err instanceof Error ? err.message : String(err));
+        if (result.fromCache) {
+            console.warn(`[swe-rebench-v2-gen] HF pool refresh failed; serving ${pool.length} tasks from disk cache — ` +
+                `generator stays live, will retry HF next poll: ${result.error?.message}`);
+        }
+        else if (result.error) {
+            console.warn(`[swe-rebench-v2-gen] pool refresh failed (pool size ${pool.length}): ${result.error.message}`);
         }
     }
     const tick = async () => {
         const now = Date.now();
+        // #802: re-read counters from disk at the start of every tick. last_task_id
+        // (and successful) are written by other loops (CreatorLoop.recordLastTaskId,
+        // delivery-watcher.recordSuccess) through separate store instances against
+        // the same file; without invalidating the long-lived cache here the
+        // generator never observes those writes and reposts every tick.
+        stateStore.invalidate();
         const runtimeConfig = config.getGeneratorConfig
             ? config.getGeneratorConfig()
             : config.generatorConfig;
         const genConfig = normalizeGeneratorConfig(runtimeConfig);
-        const claimPolicy = normalizeClaimPolicy(runtimeConfig);
-        // Refresh pool if stale or empty
-        if (pool.length === 0 || now - poolLoadedAt > POOL_REFRESH_MS) {
+        // Refresh pool if stale, empty, or currently served from the disk cache
+        // (a cache-served pool retries HF every poll so the generator self-heals
+        // as soon as HF recovers — #466).
+        if (pool.length === 0 || poolFromCache || now - poolLoadedAt > POOL_REFRESH_MS) {
             await refreshPool();
         }
         if (pool.length === 0) {
-            lastPollSummary = { poolSize: 0, posted: 0, skipped: 0 };
+            lastPollSummary = {
+                poolSize: 0,
+                posted: 0,
+                unposted: 0,
+                live: 0,
+                repostable: 0,
+                saturated: 0,
+            };
             return null;
         }
         lastPollAt = new Date(now).toISOString();
-        // Restrict to instances we can actually score (validated gold-patch pool).
-        // In required mode (default): absent or stale admission data → empty pool,
-        // emit a startup warning. In python-floor mode (local/dev opt-in): fall
-        // back to Python-only instances when no validation data exists.
-        // See jinn-mono-uy6v.9.
-        const scorableIds = await validatedPoolStore.getScorableIds(EVAL_SEMANTICS_VERSION);
+        const validatedPoolMtimeMs = await stat(join(config.stateDir, 'validated-pool.json'))
+            .then((s) => s.mtimeMs)
+            .catch(() => -1);
+        if (validatedPoolMtimeMs > lastValidatedPoolMtimeMs) {
+            publishedPoolCache = null;
+            lastValidatedPoolMtimeMs = validatedPoolMtimeMs;
+        }
+        let publishedPool = publishedPoolCache;
+        if (!publishedPool) {
+            publishedPool = await resolvePublishedVettedPool({
+                stateDir: config.stateDir,
+                manifestCid: config.solverNetManifestCid,
+                store: validatedPoolStore,
+                nowIso: lastPollAt,
+                ipfsRegistryUrl: config.ipfsRegistryUrl ??
+                    process.env['JINN_IPFS_REGISTRY_URL'] ??
+                    DEFAULT_IPFS_REGISTRY_URL,
+                upload: uploadToIpfs,
+            }).catch((err) => {
+                const message = err instanceof Error ? err.message : String(err);
+                lastError = {
+                    message: `vetted pool publication failed: ${message}`,
+                    at: new Date().toISOString(),
+                };
+                console.warn(`[swe-rebench-v2-gen] ${lastError.message}`);
+                return null;
+            });
+            if (publishedPool?.artifactRef) {
+                publishedPoolCache = publishedPool;
+                if (publishedPool.republication) {
+                    lastRepublication = publishedPool.republication;
+                }
+            }
+        }
+        if (publishedPool === null) {
+            lastPollSummary = {
+                poolSize: 0,
+                posted: 0,
+                unposted: 0,
+                live: 0,
+                repostable: 0,
+                saturated: 0,
+            };
+            return null;
+        }
+        if (genConfig.admissionMode === 'required' &&
+            publishedPool.mode === 'no-manifest' &&
+            !publicationWarned) {
+            publicationWarned = true;
+            console.warn(`[swe-rebench-v2-gen] no solverNetManifestCid is available, so the launcher cannot stamp a vetted pool artifact ref; admissionMode='required' is fail-closed.`);
+        }
+        // Restrict to instances in the launcher's published pool artifact. If the
+        // launcher has no publication yet but local scorable data exists, the
+        // helper above publishes it once before this filter runs. Python-floor is
+        // preserved only for local/dev generators.
+        const scorableIds = publishedPool.artifactRef
+            ? publishedPool.scorableIds
+            : genConfig.admissionMode === 'python-floor'
+                ? await validatedPoolStore.getScorableIds(EVAL_SEMANTICS_VERSION)
+                : null;
         const { pool: eligiblePool, mode: poolMode } = filterToScorablePool(pool, scorableIds, genConfig.admissionMode);
         if (poolMode === 'admission-required-no-data' && !floorWarned) {
             floorWarned = true;
@@ -237,7 +378,14 @@ function makeSweRebenchV2Generator(config) {
             console.warn(`[swe-rebench-v2-gen] admissionMode='python-floor' (local/dev): restricting to ${eligiblePool.length} Python instance(s) of ${pool.length}; run \`jinn solver-nets validate-pool swe-rebench-v2 --seed-positive\` to advance to required mode.`);
         }
         if (eligiblePool.length === 0) {
-            lastPollSummary = { poolSize: 0, posted: 0, skipped: 0 };
+            lastPollSummary = {
+                poolSize: 0,
+                posted: 0,
+                unposted: 0,
+                live: 0,
+                repostable: 0,
+                saturated: 0,
+            };
             lastError = undefined;
             return null;
         }
@@ -246,73 +394,171 @@ function makeSweRebenchV2Generator(config) {
         for (const task of eligiblePool) {
             counters.set(task.instance_id, await stateStore.getCounters(task.instance_id));
         }
-        const mostRecentPostedAt = Math.max(0, ...Array.from(counters.values(), (c) => c.last_posted_at));
-        if (mostRecentPostedAt > 0 && now - mostRecentPostedAt < genConfig.cooldown_ms) {
-            lastPollSummary = { poolSize: eligiblePool.length, posted: 0, skipped: eligiblePool.length };
-            lastError = undefined;
-            return null;
+        // Reconcile each instance's `successful` against network truth (#669):
+        // take max(local, network). On indexer outage the tick aborts — silently
+        // falling through to local-only counters is exactly the bug being fixed.
+        // The discoveryApi/manifestCid pair is optional so test paths can skip.
+        if (config.discoveryApi && config.solverNetManifestCid) {
+            try {
+                const networkSuccesses = await config.discoveryApi.getInstanceSuccessCounts({
+                    manifestCid: config.solverNetManifestCid,
+                });
+                for (const task of eligiblePool) {
+                    const local = counters.get(task.instance_id);
+                    if (!local)
+                        continue;
+                    const networkSuccess = networkSuccesses.get(task.instance_id) ?? 0;
+                    if (networkSuccess > local.successful) {
+                        counters.set(task.instance_id, { ...local, successful: networkSuccess });
+                    }
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                lastError = {
+                    message: `network-truth reconciliation failed: ${message}`,
+                    at: new Date().toISOString(),
+                };
+                console.warn(`[swe-rebench-v2-gen] ${lastError.message} — skipping this tick`);
+                lastPollSummary = {
+                    poolSize: eligiblePool.length,
+                    posted: 0,
+                    unposted: 0,
+                    live: 0,
+                    repostable: 0,
+                    saturated: 0,
+                };
+                return null;
+            }
         }
-        const candidate = selectNextPostingCandidate({
+        // Reconcile claim-budget exhaustion against network truth (#802): a posting
+        // is exhausted when its on-chain consumed slots reach maxClaims. Keyed by
+        // taskId; the classifier joins via each instance's last_task_id. On a
+        // genuine indexer outage (throw) the tick aborts — silently continuing with
+        // no claim snapshot would mask real exhaustion (exhausted postings classify
+        // `live`), suppress legitimate reposts, and under-serve N. A *successful*
+        // empty map (e.g. onchain-floor mode) is NOT an outage and is allowed
+        // through: it makes every posting inert (post-once), which is the safe
+        // degradation, not a storm.
+        let claimCounts;
+        if (config.discoveryApi && config.solverNetManifestCid) {
+            try {
+                // getInstanceClaimCounts is keyed by taskId; its values are a structural
+                // superset of InstanceClaimSnapshot, so the map is used directly.
+                claimCounts = await config.discoveryApi.getInstanceClaimCounts({
+                    manifestCid: config.solverNetManifestCid,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                lastError = {
+                    message: `claim-budget reconciliation failed: ${message}`,
+                    at: new Date().toISOString(),
+                };
+                console.warn(`[swe-rebench-v2-gen] ${lastError.message} — skipping this tick`);
+                lastPollSummary = {
+                    poolSize: eligiblePool.length,
+                    posted: 0,
+                    unposted: 0,
+                    live: 0,
+                    repostable: 0,
+                    saturated: 0,
+                };
+                return null;
+            }
+        }
+        const candidates = selectNextPostingCandidates({
             pool: eligiblePool,
             counters,
             config: genConfig,
             now,
+            claimCounts,
             lastPostedLanguage,
         });
-        if (!candidate) {
-            lastPollSummary = { poolSize: eligiblePool.length, posted: 0, skipped: eligiblePool.length };
+        if (candidates.length === 0) {
+            lastPollSummary = summarizePoolState({
+                pool: eligiblePool,
+                counters,
+                config: genConfig,
+                now,
+                claimCounts,
+                lastPostedLanguage,
+            });
             lastError = undefined;
             return null;
         }
-        // Record the posting
-        await stateStore.recordPosted(candidate.instance_id, now);
-        lastPostedLanguage = candidate.language;
-        totalPosted += 1;
-        lastPostedInstanceId = candidate.instance_id;
-        // Build the Task
-        const deadlineUnix = Math.floor((now + 7 * 24 * 60 * 60 * 1000) / 1000); // 7-day window
-        const roundMonth = candidate.hf_split.replace('_', '-');
-        const windowEndTs = deadlineUnix * 1000;
-        const spec = SweRebenchV2TaskSchema.parse({
-            schemaVersion: 'swe-rebench-v2.v1',
-            instance_id: candidate.instance_id,
-            repo: candidate.repo ?? repoFromInstanceId(candidate.instance_id),
-            base_commit: candidate.base_commit ?? '0000000000000000000000000000000000000000',
-            language: normalizeLanguage(candidate),
-            problem_statement: candidate.problem_statement ?? `SWE-rebench v2 instance: ${candidate.instance_id}`,
-            interface: candidate.interface ?? '',
-            hf_dataset: candidate.hf_dataset,
-            hf_split: candidate.hf_split,
-            deadline_unix: deadlineUnix,
-            round_month: roundMonth,
-        });
-        const task = {
-            id: randomUUID(),
-            description: `SWE-rebench v2: ${candidate.instance_id}`,
-            solverType: SOLVER_TYPE,
-            contractId: CONTRACT_ID,
-            contractVersion: CONTRACT_VERSION,
-            ...(config.solverNetManifestCid
-                ? { solverNetManifestCid: config.solverNetManifestCid }
-                : {}),
-            role: 'restoration',
-            window: {
-                startTs: now,
-                endTs: windowEndTs,
-            },
-            claimPolicy,
-            spec,
-            eligibility: {
+        const tasks = [];
+        for (const candidate of candidates) {
+            await stateStore.recordPosted(candidate.instance_id, now);
+            const afterRecord = await stateStore.getCounters(candidate.instance_id);
+            counters.set(candidate.instance_id, afterRecord);
+            lastPostedLanguage = candidate.language;
+            totalPosted += 1;
+            lastPostedInstanceId = candidate.instance_id;
+            const remainingTargetSuccesses = genConfig.N_target_successes - afterRecord.successful;
+            const deadlineUnix = Math.floor((now + genConfig.posting_window_ms) / 1000);
+            const roundMonth = candidate.hf_split.replace('_', '-');
+            const windowEndTs = deadlineUnix * 1000;
+            const spec = SweRebenchV2TaskSchema.parse({
+                schemaVersion: 'swe-rebench-v2.v1',
+                instance_id: candidate.instance_id,
+                repo: candidate.repo ?? repoFromInstanceId(candidate.instance_id),
+                base_commit: candidate.base_commit ?? '0000000000000000000000000000000000000000',
+                language: normalizeLanguage(candidate),
+                problem_statement: candidate.problem_statement ?? `SWE-rebench v2 instance: ${candidate.instance_id}`,
+                interface: candidate.interface ?? '',
                 hf_dataset: candidate.hf_dataset,
                 hf_split: candidate.hf_split,
-                instance_id: candidate.instance_id,
-                generatorConfig: genConfig,
-            },
+                deadline_unix: deadlineUnix,
+                round_month: roundMonth,
+            });
+            tasks.push({
+                id: randomUUID(),
+                description: `SWE-rebench v2: ${candidate.instance_id}`,
+                solverType: SOLVER_TYPE,
+                contractId: CONTRACT_ID,
+                contractVersion: CONTRACT_VERSION,
+                ...(config.solverNetManifestCid
+                    ? { solverNetManifestCid: config.solverNetManifestCid }
+                    : {}),
+                role: 'restoration',
+                window: {
+                    startTs: now,
+                    endTs: windowEndTs,
+                },
+                claimPolicy: claimPolicyForPosting(genConfig, remainingTargetSuccesses),
+                spec,
+                eligibility: {
+                    hf_dataset: candidate.hf_dataset,
+                    hf_split: candidate.hf_split,
+                    instance_id: candidate.instance_id,
+                    posted_count_after_record: afterRecord.posted,
+                    generatorConfig: genConfig,
+                    ...(publishedPool.artifactRef
+                        ? { [VETTED_POOL_REF_ELIGIBILITY_KEY]: publishedPool.artifactRef }
+                        : {}),
+                },
+            });
+        }
+        console.log(`[swe-rebench-v2-gen] posting ${candidates.length} instance(s): ` +
+            candidates.map((candidate) => candidate.instance_id).join(', '));
+        lastPollSummary = {
+            ...summarizePoolState({
+                pool: eligiblePool,
+                counters,
+                config: genConfig,
+                now,
+                claimCounts,
+                lastPostedLanguage,
+            }),
+            posted: tasks.length,
         };
-        console.log(`[swe-rebench-v2-gen] posting ${candidate.instance_id}`);
-        lastPollSummary = { poolSize: eligiblePool.length, posted: 1, skipped: 0 };
         lastError = undefined;
-        return maybeSignTask(task, { creator: config.creator, createdAt: now });
+        const signed = [];
+        for (const task of tasks) {
+            signed.push(await maybeSignTask(task, { creator: config.creator, createdAt: now }));
+        }
+        return signed.length > 0 ? signed : null;
     };
     return Object.assign(tick, {
         getState() {
@@ -325,6 +571,13 @@ function makeSweRebenchV2Generator(config) {
                 totalPosted,
                 lastPostedInstanceId,
                 config: liveConfig,
+                ...(lastRepublication
+                    ? {
+                        poolPublicationUpdatedAt: lastRepublication.publishedAt,
+                        poolPublicationPriorSize: lastRepublication.priorSize,
+                        poolPublicationCurrentSize: lastRepublication.currentSize,
+                    }
+                    : {}),
             };
         },
     });
@@ -364,6 +617,8 @@ export function makeSweRebenchV2GeneratorForLaunchedRecord(opts) {
         stateDir,
         getGeneratorConfig: () => configRef.current,
         solverNetManifestCid: recordRef.current.manifestCid,
+        ipfsRegistryUrl: staticConfig.ipfsRegistryUrl,
+        discoveryApi: staticConfig.discoveryApi,
         creator: {
             agentEoa: staticConfig.agentEoa,
             safeAddress: staticConfig.safeAddress,