@jinn-network/client 0.1.7 → 0.1.8-canary.09a3b2f6

package/dist/config.js

@@ -18,15 +18,10 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { z } from 'zod';
 import { TaskSchema, parseTask } from './types/task.js';
-import { canonicalHarnessName, CLAUDE_CODE_HARNESS } from './harnesses/names.js';
-/**
- * Default `solverNets` is empty per Decision 5 of
- * spec/2026-05-05-solvernet-creation-and-launch.md — pre-release, no
- * migration burden. Fresh installs no longer seed the `prediction` entry;
- * the operator joins SolverNets through the registry (Task 21's
- * `joinedSolverNets` block).
- */
-export const DEFAULT_SOLVER_NETS = {};
+import { canonicalHarnessName } from './harnesses/names.js';
+import { parseRpcUrls } from './rpc/transport.js';
+import { canonicalLocalHttpBaseUrl } from './local-provider-url.js';
+// ── Schema ──────────────────────────────────────────────────────────────────
 const HarnessNameSchema = z.string().transform((name) => canonicalHarnessName(name));
 export const JinnConfigSchema = z.object({
     /**
@@ -38,19 +33,36 @@ export const JinnConfigSchema = z.object({
      */
     network: z.enum(['mainnet', 'testnet']).default('testnet'),
     /**
-     * Base RPC endpoint.
-     * Defaults to https://mainnet.base.org for 'mainnet' and
-     * https://sepolia.base.org for 'testnet'. Set explicitly to override.
+     * Base RPC endpoint(s). Accepts either a single URL string or an array of
+     * URLs. When an array (or a comma-separated env var) is supplied, the
+     * daemon builds a viem `fallback()` chain in slot order (primary first).
+     * See `client/src/rpc/transport.ts` for the wrapper. Defaults to the
+     * publicnode+sepolia.base.org two-provider chain on testnet and the public
+     * `mainnet.base.org` on mainnet. Set explicitly to override.
+     *
+     * Env: JINN_RPC_URL / BASE_SEPOLIA_RPC_URL / BASE_RPC_URL (comma-separated).
      */
-    rpcUrl: z.string().optional(),
-    archiveRpcUrl: z.string().optional(),
+    rpcUrl: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
+    archiveRpcUrl: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
     /**
-     * Optional L2 proof/archive RPC endpoint for canonical cross-chain canaries.
+     * Optional L2 proof/archive RPC endpoint(s) for canonical cross-chain canaries.
      * The daemon can use its normal rpcUrl for writes while proof construction
      * uses this endpoint for historical eth_getProof at OP dispute-game blocks.
-     * Env: JINN_L2_PROOF_RPC_URL.
+     * Accepts string or array form (see rpcUrl). Env: JINN_L2_PROOF_RPC_URL.
      */
-    l2ProofRpcUrl: z.string().url().optional(),
+    l2ProofRpcUrl: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
+    /**
+     * Single volume-aware durable-state root. When set (env JINN_STATE_DIR or
+     * this file field), `earningDir`, `dbPath`, `engine.implStateDirRoot`, and
+     * the swe-rebench-v2 pool dir derive from it as `<stateDir>/<subdir>` —
+     * UNLESS each is individually overridden, in which case the per-key value
+     * wins (derive-don't-collapse). With `stateDir` unset, every default is
+     * byte-identical to the legacy `~/.jinn-client/<subdir>` paths. Hosted
+     * deploys collapse four ENV lines to one `JINN_STATE_DIR=/data`.
+     * `engine.workingDirRoot` is deliberately NOT derived — it stays ephemeral
+     * (reaped per-task).
+     */
+    stateDir: z.string().optional(),
     /** Earning state directory */
     earningDir: z.string().default(join(homedir(), '.jinn-client', 'earning')),
     /** SQLite database path */
@@ -106,6 +118,22 @@ export const JinnConfigSchema = z.object({
     hermesModel: z.string().optional(),
     /** Hermes provider (e.g. 'anthropic'). */
     hermesProvider: z.string().optional(),
+    /** Local OpenAI-compatible Hermes base URL, e.g. http://127.0.0.1:11434/v1 for Ollama. */
+    hermesBaseUrl: z
+        .string()
+        .url()
+        .transform((value, ctx) => {
+        const canonical = canonicalLocalHttpBaseUrl(value);
+        if (!canonical) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'hermesBaseUrl must be a local HTTP(S) URL',
+            });
+            return z.NEVER;
+        }
+        return canonical;
+    })
+        .optional(),
     /**
      * Timeout in ms for `hermes doctor` health-check runs.
      * Default 30 000 ms. Env: JINN_HERMES_DOCTOR_TIMEOUT_MS.
@@ -164,6 +192,17 @@ export const JinnConfigSchema = z.object({
      * backlog while proving one fresh task path.
      */
     taskDiscoveryAllowedTaskIds: z.array(z.string()).optional(),
+    /**
+     * Explicit absolute lower bound (L2 block number) for the mech adapter's
+     * on-chain TaskCreated backlog scan. Unset → the scan defaults to a bounded
+     * rolling window (`head − DEFAULT_ONCHAIN_SCAN_WINDOW_BLOCKS`, ~28h on Base),
+     * so a restart no longer replays full chain history every boot (#801); the
+     * indexer (DiscoveryAPI.findClaimableTasks) is the primary discovery path and
+     * the on-chain scan is a bounded backstop. Set this to widen the backstop to a
+     * specific block (the value pins both the scan start and the gh #300 admission
+     * floor). Env: JINN_TASK_DISCOVERY_FROM_BLOCK.
+     */
+    taskDiscoveryOnchainFromBlock: z.number().int().min(0).optional(),
     /** This node's public HTTP endpoint (for 8004 registration) */
     nodeEndpoint: z.string().optional(),
     /** Tasks to create and solve. Empty by default; enabled SolverNet generators fill the loop. */
@@ -195,18 +234,19 @@ export const JinnConfigSchema = z.object({
     jinnMviL2DeploymentPath: z.string().optional(),
     // ── Cross-chain claim loop (Phase B / jinn-mono-7x5) ─────────────────────
     /**
-     * RPC endpoint for the L1 governance chain (Ethereum / Sepolia) where the
-     * JinnDistributor lives. Testnet defaults to a public Sepolia RPC; mainnet
-     * requires an operator override when L1 submit mode is configured.
-     * Env: JINN_ETHEREUM_RPC_URL.
+     * RPC endpoint(s) for the L1 governance chain (Ethereum / Sepolia) where
+     * the JinnDistributor lives. Accepts string or array form (see rpcUrl) and
+     * supports comma-separated env values. Testnet defaults to a public Sepolia
+     * RPC; mainnet requires an operator override when L1 submit mode is
+     * configured. Env: JINN_ETHEREUM_RPC_URL.
      */
-    ethereumRpcUrl: z.string().url().optional(),
+    ethereumRpcUrl: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
     /**
-     * Optional archive RPC endpoint for the L1 governance chain. Used for
-     * historical block lookups when constructing canonical-mode proofs.
-     * Env: JINN_ETHEREUM_ARCHIVE_RPC_URL.
+     * Optional archive RPC endpoint(s) for the L1 governance chain. Used for
+     * historical block lookups when constructing canonical-mode proofs. Accepts
+     * string or array form. Env: JINN_ETHEREUM_ARCHIVE_RPC_URL.
      */
-    ethereumArchiveRpcUrl: z.string().url().optional(),
+    ethereumArchiveRpcUrl: z.union([z.string(), z.array(z.string()).min(1)]).optional(),
     /**
      * L1 network used by the cross-chain claim loop. 'sepolia' tracks Base
      * Sepolia testnet; 'ethereum' tracks Base mainnet. Defaults to 'sepolia'
@@ -354,69 +394,7 @@ export const JinnConfigSchema = z.object({
     })
         .default({ mode: 'train' }),
     /**
-     * SolverNet activation, Harness selection, and operator-configured runtime plugins.
-     *
-     * Each entry's `roles` is a non-empty subset of `['solving', 'evaluating']`.
-     * Multiple roles can run concurrently for the same SolverNet; the
-     * protocol-level `disallowSolverSelfEvaluation` flag prevents the operator
-     * from evaluating its own Solutions and the on-chain
-     * TaskActivityCheckerV3 tracks Solution and Verdict counters independently
-     * (additive into `eligibleActivityWeight`).
-     *
-     * Launcher ownership lives in the launched-record subsystem
-     * (spec/2026-05-05-solvernet-creation-and-launch.md §11), not in operator
-     * config — there is no `'launching'` operator role. Legacy entries that
-     * include `'launching'` in `roles` have it stripped by the preprocessor so
-     * older config files keep loading.
-     *
-     * Backwards-compat: a legacy `role: 'solving' | 'evaluating'` field is
-     * auto-promoted to `roles: [<role>]` by the zod preprocessor below so
-     * existing `~/.jinn-client/config.json` files keep loading without an
-     * operator migration step.
-     */
-    solverNets: z.record(z.preprocess((raw) => {
-        if (typeof raw !== 'object' || raw === null)
-            return raw;
-        const obj = raw;
-        // Promote legacy `role: X` → `roles: [X]` when only the singular form
-        // is provided. If both are present (mid-migration third-party config),
-        // `roles` wins and `role` is dropped.
-        if (Array.isArray(obj['roles']) && obj['roles'].length > 0) {
-            // Drop legacy `'launching'` entries — operator config no longer
-            // carries the launcher role; ownership is via launched records.
-            const filteredRoles = obj['roles'].filter((r) => r !== 'launching');
-            const { role: _legacyRole, ...rest } = obj;
-            return { ...rest, roles: filteredRoles };
-        }
-        if (typeof obj['role'] === 'string' && (obj['role'] === 'solving' || obj['role'] === 'evaluating')) {
-            const { role, ...rest } = obj;
-            return { ...rest, roles: [role] };
-        }
-        return obj;
-    }, z.object({
-        enabled: z.boolean().default(true),
-        solverType: z.string(),
-        roles: z.array(z.enum(['solving', 'evaluating']))
-            .min(1, 'each SolverNet must enable at least one role')
-            .default(['solving'])
-            // Deduplicate to keep downstream consumers simple.
-            .transform((arr) => Array.from(new Set(arr))),
-        harness: HarnessNameSchema.default(CLAUDE_CODE_HARNESS),
-        model: z.string().optional(),
-        plugins: z.array(z.union([
-            z.string(),
-            z.object({
-                name: z.string().optional(),
-                source: z.string(),
-                version: z.string().optional(),
-            }),
-        ])).default([]),
-        taskGenerator: z.object({
-            enabled: z.boolean().default(true),
-        }).default({ enabled: true }),
-    }))).default(DEFAULT_SOLVER_NETS),
-    /**
-     * Manifest-keyed joined SolverNets (Task 21).
+     * Manifest-keyed joined SolverNets.
      *
      * Spec: spec/2026-05-05-solvernet-creation-and-launch.md §12.
      *
@@ -425,10 +403,10 @@ export const JinnConfigSchema = z.object({
      * (CIDv0 / CIDv1) — the only stable identifier that maps back to a
      * launched-instance authority across launchers.
      *
-     * Kept structurally separate from legacy `solverNets` for now. The daemon
-     * narrows this block into runtime SolverNet registry entries on restart, and
-     * Task 22 collapses both branches into a single manifest-keyed shape once
-     * the legacy block is fully drained.
+     * The daemon narrows this block into runtime SolverNet registry entries on
+     * restart. Legacy short-name-keyed `solverNets` blocks on operator config
+     * files are auto-migrated into synthetic `legacy:<short-name>`-keyed
+     * entries at load time (see `migrateLegacySolverNets`).
      */
     joinedSolverNets: z
         .record(z.string(), z.object({
@@ -572,6 +550,33 @@ export const JinnConfigSchema = z.object({
      * Env: JINN_REPUTATION_ENABLED
      */
     reputationEnabled: z.boolean().default(false),
+    /**
+     * Per-credential daily spend caps (USD). Keys are credential identifiers
+     * (e.g. `'anthropic:api-key'`); values are positive numbers representing
+     * the maximum USD spend per day for that credential.
+     *
+     * `JINN_SPEND_CAP_USD` (env-only, consumed directly by the spend-budget
+     * subsystem in Task 9) is tracked for provenance in TRACKED_ENV_VARS below
+     * but is NOT a config-file field and has no entry in this schema.
+     */
+    spendCaps: z.record(z.string(), z.number().positive()).optional(),
+    /**
+     * Operator-local SolverPlugin trust state.
+     *
+     * `blockedCids` is the list of plug-in CIDs the operator has chosen to
+     * refuse to load — populated by `jinn solver-plugins block <cid>` and read
+     * at daemon startup. The block list complements the on-chain
+     * `giveFeedback(score=0)` write (which is the public-trust signal); the
+     * local list is the operator's own refusal to execute, applied even when
+     * the network write fails. File-managed only — no env override.
+     *
+     * See spec/2026-05-26-117-design.md "Failure modes" and "Local-only effects".
+     */
+    solverPlugins: z
+        .object({
+        blockedCids: z.array(z.string()).default([]),
+    })
+        .default({ blockedCids: [] }),
 }).refine((cfg) => cfg.jinnClaimSubmissionMode !== 'submit' ||
     !cfg.jinnDistributorAddress ||
     !!cfg.ethereumRpcUrl, {
@@ -596,6 +601,20 @@ export const DEFAULT_CONFIG_PATH = join(DEFAULT_DIR, 'config.json');
  */
 export const DEFAULT_TESTNET_DISCOVERY_URL = 'https://jinn-indexer-production.up.railway.app';
 export const DEFAULT_TESTNET_ETHEREUM_RPC_URL = 'https://ethereum-sepolia-rpc.publicnode.com';
+/**
+ * Default fallback chain for the L2 measurement chain (Base Sepolia) on
+ * testnet. Per AC2 of issue #592:
+ *   slot 0 — `https://base-sepolia.publicnode.com` (no-auth, 50k-block
+ *     getLogs cap, no shared-quota cliff).
+ *   slot 1 — `https://sepolia.base.org` (free public Coinbase endpoint,
+ *     2k-block cap; last-resort backup).
+ * Operators are encouraged to prepend a paid primary key (Alchemy, Tenderly,
+ * etc.) via `rpcUrl` config or `JINN_RPC_URL` / `BASE_SEPOLIA_RPC_URL` env.
+ */
+export const DEFAULT_TESTNET_RPC_URLS = [
+    'https://base-sepolia.publicnode.com',
+    'https://sepolia.base.org',
+];
 export class ConfigLoadError extends Error {
     code;
     details;
@@ -606,7 +625,93 @@ export class ConfigLoadError extends Error {
         this.details = details;
     }
 }
-// ── Loader ──────────────────────────────────────────────────────────────────
+/**
+ * Parse a legacy `<id>.<version>` solverType string into `{id, version}`.
+ * Falls back to `{ id: fallbackId, version: 'v1' }` when the string lacks a
+ * dot or terminates in one — this happens only on hand-edited operator
+ * configs and keeps the migration loud-but-non-fatal.
+ */
+function parseSolverTypeRef(solverType, fallbackId) {
+    if (typeof solverType !== 'string') {
+        return { id: fallbackId, version: 'v1' };
+    }
+    const dot = solverType.lastIndexOf('.');
+    if (dot <= 0 || dot === solverType.length - 1) {
+        return { id: fallbackId, version: 'v1' };
+    }
+    return { id: solverType.slice(0, dot), version: solverType.slice(dot + 1) };
+}
+/**
+ * Translate any legacy short-name-keyed `solverNets` block on the raw parsed
+ * config into manifest-keyed `joinedSolverNets` entries with synthetic
+ * `legacy:<short-name>` keys.
+ *
+ * This is the auto-migration path for operators upgrading past issue #421.
+ * The runtime claim filter remains manifest-digest gated, so synthetic-keyed
+ * entries don't change task eligibility — they exist purely so the diagnostic
+ * surfaces (Overview SOLVING-ON eyebrow, prediction-operator-status) keep
+ * showing the operator's previous SolverNets until they re-join via the SPA.
+ *
+ * Returns the number of legacy entries migrated. Idempotent — calling on an
+ * already-migrated raw config is a no-op.
+ *
+ * @param raw — the JSON-parsed config file contents (mutated in place).
+ */
+export function migrateLegacySolverNets(raw) {
+    const legacy = raw['solverNets'];
+    if (!legacy || typeof legacy !== 'object' || Array.isArray(legacy)) {
+        return 0;
+    }
+    const entries = Object.entries(legacy);
+    if (entries.length === 0) {
+        delete raw['solverNets'];
+        return 0;
+    }
+    const joined = (typeof raw['joinedSolverNets'] === 'object' && raw['joinedSolverNets'] !== null && !Array.isArray(raw['joinedSolverNets']))
+        ? raw['joinedSolverNets']
+        : {};
+    let migrated = 0;
+    for (const [name, entryRaw] of entries) {
+        if (!entryRaw || typeof entryRaw !== 'object')
+            continue;
+        const entry = entryRaw;
+        const syntheticKey = `legacy:${name}`;
+        // Do not overwrite a pre-existing joinedSolverNets entry under the same key.
+        if (joined[syntheticKey] !== undefined)
+            continue;
+        const contract = parseSolverTypeRef(entry.solverType, name);
+        const rolesIn = Array.isArray(entry.roles) && entry.roles.length > 0
+            ? entry.roles
+            : ['solving'];
+        const roles = [];
+        for (const r of rolesIn) {
+            if (r === 'solving')
+                roles.push('solver');
+            else if (r === 'evaluating')
+                roles.push('evaluator');
+            // 'launching' (and any other unknown role) is dropped — operator config
+            // no longer carries the launcher role per spec §11.
+        }
+        if (roles.length === 0)
+            roles.push('solver');
+        joined[syntheticKey] = {
+            manifestCid: syntheticKey,
+            name,
+            contract,
+            roles: Array.from(new Set(roles)),
+            ...(typeof entry.harness === 'string' ? { harness: entry.harness } : {}),
+            ...(typeof entry.model === 'string' ? { model: entry.model } : {}),
+            plugins: Array.isArray(entry.plugins) ? entry.plugins : [],
+            disabledDefaultPlugins: [],
+        };
+        migrated += 1;
+    }
+    if (Object.keys(joined).length > 0) {
+        raw['joinedSolverNets'] = joined;
+    }
+    delete raw['solverNets'];
+    return migrated;
+}
 /**
  * Load config with resolution: env > config file > defaults.
  *
@@ -658,6 +763,9 @@ export function loadConfig(configPath) {
     if (env['JINN_CHECKPOINT_INTERVAL_MS'] !== undefined) {
         merged.checkpointIntervalMs = Number.parseInt(env['JINN_CHECKPOINT_INTERVAL_MS'], 10);
     }
+    if (env['JINN_TASK_DISCOVERY_FROM_BLOCK'] !== undefined) {
+        merged.taskDiscoveryOnchainFromBlock = Number.parseInt(env['JINN_TASK_DISCOVERY_FROM_BLOCK'], 10);
+    }
     if (env['JINN_API_PORT'])
         merged.apiPort = parseInt(env['JINN_API_PORT'], 10);
     if (env['JINN_API_BIND_HOST'])
@@ -672,6 +780,8 @@ export function loadConfig(configPath) {
         merged.hermesModel = env['JINN_HERMES_MODEL'];
     if (env['JINN_HERMES_PROVIDER'])
         merged.hermesProvider = env['JINN_HERMES_PROVIDER'];
+    if (env['JINN_HERMES_BASE_URL'])
+        merged.hermesBaseUrl = env['JINN_HERMES_BASE_URL'];
     if (env['JINN_HERMES_DOCTOR_TIMEOUT_MS']) {
         merged.hermesDoctorTimeoutMs = parseInt(env['JINN_HERMES_DOCTOR_TIMEOUT_MS'], 10);
     }
@@ -842,6 +952,28 @@ export function loadConfig(configPath) {
             ...(env['JINN_ENGINE_IMPL_STATE_DIR_ROOT'] ? { implStateDirRoot: env['JINN_ENGINE_IMPL_STATE_DIR_ROOT'] } : {}),
         };
     }
+    // JINN_STATE_DIR: single volume-aware root. Runs AFTER all per-key env
+    // overrides above are applied into `merged` and BEFORE safeParse — so a
+    // still-`undefined` per-key value means neither file nor env set it. Per-key
+    // precedence: explicit (file or env, already in `merged`) > <stateDir>/<subdir>
+    // > legacy default (filled by the schema / engine assembly when still absent).
+    // workingDirRoot is deliberately NOT derived — it stays ephemeral.
+    const stateDir = env['JINN_STATE_DIR']
+        ?? (typeof merged['stateDir'] === 'string' ? merged['stateDir'] : undefined);
+    if (stateDir) {
+        merged['stateDir'] = stateDir;
+        if (merged['earningDir'] === undefined)
+            merged['earningDir'] = join(stateDir, 'earning');
+        if (merged['dbPath'] === undefined)
+            merged['dbPath'] = join(stateDir, 'jinn.db');
+        const engineObj = (typeof merged['engine'] === 'object' && merged['engine'] !== null)
+            ? merged['engine']
+            : {};
+        if (engineObj['implStateDirRoot'] === undefined) {
+            engineObj['implStateDirRoot'] = join(stateDir, 'engine', 'impl-state');
+            merged['engine'] = engineObj;
+        }
+    }
     const resolvedNetwork = merged.network === 'testnet' ? 'testnet' : 'mainnet';
     // Testnet default: point discovery at the privately-operated Ponder indexer
     // (jinn-mono-280n.4), unless the operator has set their own `discovery` block.
@@ -911,6 +1043,17 @@ export function loadConfig(configPath) {
             });
         }
     }
+    // Auto-migrate any legacy short-name-keyed `solverNets` block into
+    // `joinedSolverNets` with synthetic `legacy:<name>` keys. Operators upgrade
+    // without an explicit action; the warning surfaces the migration so they
+    // know to re-join via the SPA when they want a real manifest CID. See
+    // spec/2026-05-25-retire-legacy-solvernets-config.md and issue #421.
+    const migratedCount = migrateLegacySolverNets(merged);
+    if (migratedCount > 0) {
+        console.warn(`[config] Migrated ${migratedCount} legacy solverNets ${migratedCount === 1 ? 'entry' : 'entries'} to joinedSolverNets. ` +
+            'Open Operator > SolverNets in the dashboard to re-join via the registry ' +
+            '(replaces the synthetic legacy:* keys with real manifest CIDs).');
+    }
     // 3. Validate
     const result = JinnConfigSchema.safeParse(merged);
     if (!result.success) {
@@ -922,21 +1065,56 @@ export function loadConfig(configPath) {
         });
     }
     // 4. Resolve rpcUrl default based on network (if not explicitly set).
-    // Testnet default is publicnode — no-auth, no shared-key quota cliff. The
-    // previous default was a Tenderly gateway with a shared project key; when
-    // aggregate operator traffic hit the plan quota every default-config daemon
-    // got HTTP 403 simultaneously (dashboard "Runway 0d", faucet 500s, daemon
-    // hot-loops on every eth_*). See #554 + the panel's "shared RPC" warning in
-    // NetworkSection.tsx for the operator-facing pitch to bring their own key.
-    // The sibling Ethereum L1 default (DEFAULT_TESTNET_ETHEREUM_RPC_URL above)
-    // is already publicnode — this keeps the two L1/L2 defaults symmetric.
+    // Testnet default per AC2 (issue #592) is a two-provider fallback chain:
+    //   slot 0 — base-sepolia.publicnode.com (50k-block getLogs cap, no quota)
+    //   slot 1 — sepolia.base.org (free, 2k-block cap; last-resort backup)
+    // Publicnode is no-auth, no shared-key quota cliff (avoids the Tenderly
+    // shared-quota cliff of 2026-05-24 that took out every default-config
+    // daemon at once). See #554 + the NetworkSection.tsx "shared RPC" panel for
+    // the operator-facing pitch to bring their own key. The sibling Ethereum L1
+    // default (DEFAULT_TESTNET_ETHEREUM_RPC_URL above) is already publicnode —
+    // this keeps the two L1/L2 defaults symmetric.
     const parsed = result.data;
-    const defaultRpcUrl = parsed.network === 'testnet'
-        ? 'https://base-sepolia-rpc.publicnode.com'
-        : 'https://mainnet.base.org';
+    const defaultRpcUrls = parsed.network === 'testnet'
+        ? DEFAULT_TESTNET_RPC_URLS
+        : ['https://mainnet.base.org'];
+    const rpcUrlsResolved = parsed.rpcUrl !== undefined
+        ? parseRpcUrls(parsed.rpcUrl)
+        : [...defaultRpcUrls];
+    const archiveRpcUrlsResolved = parsed.archiveRpcUrl !== undefined
+        ? parseRpcUrls(parsed.archiveRpcUrl)
+        : undefined;
+    const l2ProofRpcUrlsResolved = parsed.l2ProofRpcUrl !== undefined
+        ? parseRpcUrls(parsed.l2ProofRpcUrl)
+        : undefined;
+    const ethereumRpcUrlsResolved = parsed.ethereumRpcUrl !== undefined
+        ? parseRpcUrls(parsed.ethereumRpcUrl)
+        : undefined;
+    const ethereumArchiveRpcUrlsResolved = parsed.ethereumArchiveRpcUrl !== undefined
+        ? parseRpcUrls(parsed.ethereumArchiveRpcUrl)
+        : undefined;
+    // Strip the union-typed (string | string[]) RPC fields from `parsed` — the
+    // returned shape carries the resolved head URL plus a `*Urls` array instead.
+    const { rpcUrl: _rpcUrl, archiveRpcUrl: _archiveRpcUrl, l2ProofRpcUrl: _l2ProofRpcUrl, ethereumRpcUrl: _ethereumRpcUrl, ethereumArchiveRpcUrl: _ethereumArchiveRpcUrl, ...rest } = parsed;
     return {
-        ...parsed,
-        rpcUrl: parsed.rpcUrl ?? defaultRpcUrl,
+        ...rest,
+        rpcUrl: rpcUrlsResolved[0],
+        rpcUrls: rpcUrlsResolved,
+        ...(archiveRpcUrlsResolved
+            ? { archiveRpcUrl: archiveRpcUrlsResolved[0], archiveRpcUrls: archiveRpcUrlsResolved }
+            : {}),
+        ...(l2ProofRpcUrlsResolved
+            ? { l2ProofRpcUrl: l2ProofRpcUrlsResolved[0], l2ProofRpcUrls: l2ProofRpcUrlsResolved }
+            : {}),
+        ...(ethereumRpcUrlsResolved
+            ? { ethereumRpcUrl: ethereumRpcUrlsResolved[0], ethereumRpcUrls: ethereumRpcUrlsResolved }
+            : {}),
+        ...(ethereumArchiveRpcUrlsResolved
+            ? {
+                ethereumArchiveRpcUrl: ethereumArchiveRpcUrlsResolved[0],
+                ethereumArchiveRpcUrls: ethereumArchiveRpcUrlsResolved,
+            }
+            : {}),
         // parseTask assigns a UUID to any entry missing an id
         tasks: parsed.tasks.map(parseTask),
         engine: {
@@ -979,6 +1157,7 @@ export function persistTopLevelConfigValue(key, value, configPath) {
  */
 const TRACKED_ENV_VARS = [
     'JINN_NETWORK',
+    'JINN_STATE_DIR',
     'JINN_EARNING_DIR',
     'JINN_DB_PATH',
     'JINN_POLL_INTERVAL_MS',
@@ -992,6 +1171,7 @@ const TRACKED_ENV_VARS = [
     'JINN_HERMES_PATH',
     'JINN_HERMES_MODEL',
     'JINN_HERMES_PROVIDER',
+    'JINN_HERMES_BASE_URL',
     'JINN_HERMES_DOCTOR_TIMEOUT_MS',
     'JINN_RUNTIME_MODE',
     'JINN_PEERS',
@@ -1034,12 +1214,14 @@ const TRACKED_ENV_VARS = [
     'JINN_TASKS',
     'JINN_ENGINE_WORKING_DIR_ROOT',
     'JINN_ENGINE_IMPL_STATE_DIR_ROOT',
+    'JINN_SWE_REBENCH_V2_STATE_DIR',
     'JINN_OPERATOR_PUBLIC_ENDPOINT',
     'JINN_OPERATOR_DEFAULT_PRICE_USDC',
     'JINN_OPERATOR_DONATION_ENABLED',
     'JINN_CAPTURES_LLM_PROXY_ENABLED',
     'JINN_CAPTURES_LLM_PROXY_PORT',
     'JINN_BUILD_COMMIT',
+    'JINN_SPEND_CAP_USD',
 ];
 /**
  * Build a structured provenance block describing how the config was resolved.