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

package/dist/main.js

@@ -26,7 +26,8 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadConfig, getConfigPathFromArgs, DEFAULT_CONFIG_PATH } from './config.js';
 import { Store } from './store/store.js';
-import { startApiServer } from './api/server.js';
+import { startApiServer, isEmbeddedAgentEnabled } from './api/server.js';
+import { setDefaultTxSubmissionLedger } from './tx-retry.js';
 // addHarnessReadinessRoutes is wired through startApiServer's holder ref now
 // (jinn-mono-u34i). No direct import needed.
 import { CapturePublishUnavailableError } from './api/captures.js';
@@ -36,10 +37,12 @@ import { hashImplStateDir } from './harnesses/freeze.js';
 import { readModeState } from './harnesses/mode-state.js';
 import { attachAgentWs, updateAgentClaudePath } from './agent/agent-ws.js';
 import { createSetupModeController } from './setup-mode.js';
+import { requestDaemonRestart } from './restart-daemon.js';
 import { buildEnvelope, emitEnvelope } from './errors/envelope.js';
 import { clearBootstrapError, persistBootstrapError, } from './errors/persisted-bootstrap-error.js';
 import { emitStructured } from './events/emitter.js';
-import { FleetBootstrapper } from './earning/bootstrap.js';
+import { applyPidfileLivenessGate } from './preflight/pidfile-liveness.js';
+import { FleetBootstrapper, recoverEvictedService as recoverEvictedServiceFn } from './earning/bootstrap.js';
 import { DEFAULT_TESTNET_ARTIFACTS, applyChainGasOverrides, getChainConfig, loadJinnMviConfig } from './earning/contracts.js';
 import { runLegacyAgentIdMigration } from './earning/migrate-agent-id.js';
 import { FleetStateStore } from './earning/store.js';
@@ -48,6 +51,8 @@ import { decryptMnemonic, deriveMasterSigner, walletPrivateKeyAtIndex } from './
 import { MechAdapter } from './adapters/mech/adapter.js';
 import { ClaudeRunner } from './runner/claude.js';
 import { Daemon } from './daemon/daemon.js';
+import { buildSpendCapConfig } from './spend/daemon-config.js';
+import { buildJinnClaimLoopConfig, shouldWireJinnClaimL1Signer, } from './daemon/jinn-claim-loop-wiring.js';
 import { createJinnPublicClient, createJinnWalletClient, createJinnL1PublicClient, createJinnL1WalletClient } from './earning/viem-clients.js';
 import { privateKeyToAccount } from 'viem/accounts';
 import { getAddress } from 'viem';
@@ -56,9 +61,10 @@ import { joinedSolverNetsViewFromConfig } from './harnesses/engine/engine.js';
 import { buildHarnesses } from './harnesses/impls/index.js';
 import { loadExternalImpl } from './harnesses/external-impls/index.js';
 import { CLAUDE_CODE_HARNESS, CODEX_HARNESS, HERMES_AGENT_HARNESS, harnessStateDirName } from './harnesses/names.js';
+import { resolveContractFromSolverNetId } from './solvernets/launched-record-dispatcher.js';
 import { HarnessReadinessRegistry } from './harnesses/readiness-registry.js';
 import { createClients } from './adapters/mech/safe.js';
-import { loadSolverNets } from './solver-nets/registry.js';
+import { findJoinedByName, loadSolverNets, solverTypeFromJoinedContract, } from './solver-nets/registry.js';
 import { createCorpus } from './corpus/index.js';
 import { DEFAULT_EXECUTION_DISCOVERY_FROM_BLOCK } from './corpus/onchain-query.js';
 import { CapturesStore } from './store/captures.js';
@@ -74,12 +80,15 @@ import { ClaudeCodeJsonlParser } from './trajectory/transcript-parsers/claude-co
 import { CodexSessionParser } from './trajectory/transcript-parsers/codex-session.js';
 import { GeminiSessionParser } from './trajectory/transcript-parsers/gemini-session.js';
 import { CursorSqliteParser } from './trajectory/transcript-parsers/cursor-sqlite.js';
+import { startTranscriptWatcher, } from './trajectory/transcript-watcher.js';
+import { defaultTranscriptWatchDirectories } from './trajectory/transcript-session-dirs.js';
 import { buildInfo } from './build-info.js';
 import { BASE_FEEDS } from './venues/chainlink/feeds.js';
-import { GeneratedTaskSource, StaticConfiguredTaskSource } from './tasks/sources.js';
-import { checkRpcNetwork, logRpcLocalDevToStderr, rpcNetworkFailureHint } from './preflight/rpc-network.js';
+import { GeneratedTaskSource, StaticConfiguredTaskSource, filterBindableTasks } from './tasks/sources.js';
+import { checkRpcNetwork, logRpcLocalDevToStderr, probeFallbackChain, rpcNetworkFailureHint, summarizeFallbackChain, } from './preflight/rpc-network.js';
 import { apiPortFailureMessage, checkApiPortAvailable } from './preflight/api-port.js';
 import { openBrowser } from './cli/open-browser.js';
+import { keepSetupUiOnBootstrapError } from './setup/halt-mode.js';
 if (process.env['JINN_LOAD_DEV_ENV'] === '1' || process.env['NODE_ENV'] === 'development') {
     dotenvConfig({ path: join(dirname(fileURLToPath(import.meta.url)), '..', '.env') });
 }
@@ -132,8 +141,19 @@ const config = loadConfig(CONFIG_PATH);
 if (config.network === 'mainnet' && process.env['JINN_ENABLE_MAINNET'] !== '1') {
     console.warn('[main] Mainnet is disabled before launch; using testnet defaults.');
     config.network = 'testnet';
-    config.rpcUrl = 'https://base-sepolia.gateway.tenderly.co/75tyLMQuD8EHpXxMwINIKu';
+    config.rpcUrl = 'https://base-sepolia-rpc.publicnode.com';
 }
+// Issue #326: the embedded Claude agent chat surface (right rail + onboarding
+// "Ask Claude" panel + /api/agent/ws bridge) is hidden by default while its
+// action-authority / plugin-scope shape is still in design. Set
+// `JINN_ENABLE_EMBEDDED_AGENT=1` to re-enable it for development. This does
+// NOT affect Claude-Code-as-a-solver-harness — that path is independent.
+//
+// Issue #367: the SPA reads this flag via the injected `window.__JINN_FEATURES__`
+// (`resolveFeatureFlags` in api/server.ts) like every other operator-app flag.
+// This `embeddedAgentEnabled` const is the daemon-side consumer only — it gates
+// whether the `/api/agent/ws` bridge is mounted below.
+const embeddedAgentEnabled = isEmbeddedAgentEnabled();
 let activeClaudePath = config.claudePath ?? 'claude';
 const selectClaudePath = (claudePath) => {
     activeClaudePath = claudePath;
@@ -187,25 +207,15 @@ class EnsurePendingCaptureProcessor {
     onStart() { }
     onEnd(span) {
         const sessionId = stringAttribute(span.attributes['jinn.session.id']);
-        if (!sessionId || this.captures.getBySession(sessionId))
+        if (!sessionId)
             return;
-        try {
-            this.captures.savePending({
-                sessionId,
-                capturedAt: hrTimeToIso(span.startTime),
-                originatingTool: { name: inferCaptureTool(span) },
-                capturePath: 'A',
-                status: 'pending',
-                spanCount: 0,
-                durationMs: 0,
-                redactedSpanCount: 0,
-                ...repoMetadataFromSpan(span),
-            });
-        }
-        catch (err) {
-            if (!this.captures.getBySession(sessionId))
-                throw err;
-        }
+        ensurePendingCapture(this.captures, {
+            sessionId,
+            capturedAt: hrTimeToIso(span.startTime),
+            tool: inferCaptureTool(span),
+            capturePath: inferCapturePath(span),
+            ...repoMetadataFromSpan(span),
+        });
     }
 }
 function stringAttribute(value) {
@@ -220,6 +230,11 @@ function inferCaptureTool(span) {
         ?? stringAttribute(span.resource.attributes['service.name'])
         ?? 'otel';
 }
+function inferCapturePath(span) {
+    if (stringAttribute(span.attributes['transcript.tool']))
+        return 'B';
+    return 'A';
+}
 function repoMetadataFromSpan(span) {
     const attrs = span.attributes;
     const repoRemoteUrl = stringAttribute(attrs['repo.remote_url'])
@@ -249,28 +264,35 @@ function parserForStopHookTool(tool) {
         }
     }
 }
-function ensurePendingStopHookCapture(captures, payload) {
-    if (captures.getBySession(payload.sessionId))
+function ensurePendingCapture(captures, params) {
+    if (captures.getBySession(params.sessionId))
         return;
     try {
         captures.savePending({
-            sessionId: payload.sessionId,
-            capturedAt: payload.stoppedAt,
-            originatingTool: { name: payload.tool },
-            capturePath: 'D',
+            sessionId: params.sessionId,
+            capturedAt: params.capturedAt,
+            originatingTool: { name: params.tool },
+            capturePath: params.capturePath,
             status: 'pending',
             spanCount: 0,
             durationMs: 0,
             redactedSpanCount: 0,
+            ...(params.repoRemoteUrl ? { repoRemoteUrl: params.repoRemoteUrl } : {}),
+            ...(params.repoCommitHash ? { repoCommitHash: params.repoCommitHash } : {}),
         });
     }
     catch (err) {
-        if (!captures.getBySession(payload.sessionId))
+        if (!captures.getBySession(params.sessionId))
             throw err;
     }
 }
 async function ingestStopHookCapture(captures, receiver, payload) {
-    ensurePendingStopHookCapture(captures, payload);
+    ensurePendingCapture(captures, {
+        sessionId: payload.sessionId,
+        capturedAt: payload.stoppedAt,
+        tool: payload.tool,
+        capturePath: 'D',
+    });
     if (!payload.transcriptPath)
         return;
     if (!receiver) {
@@ -484,11 +506,17 @@ async function bootstrap() {
                 hint: 'Fund the listed address and re-run this command.',
                 exampleCli: 'jinn fund-requirements --json',
                 details: {
-                    role: 'master',
+                    // jinn-mono-hjex.6: structured envelope so SPA can render the
+                    // specific address + amount instead of a prose disjunction.
+                    category: 'insufficient_funds',
+                    step: 'awaiting_funding',
                     address: result.funding.master_address,
+                    requiredWei: result.funding.eth_required,
+                    haveWei: result.funding.eth_balance,
+                    // Legacy aliases kept for any external consumers that read these.
+                    role: 'master',
                     asset: 'native',
                     needWei: result.funding.eth_required,
-                    haveWei: result.funding.eth_balance,
                 },
             });
         }
@@ -503,11 +531,17 @@ async function bootstrap() {
             hint: 'Bootstrap failed before the fleet reached a runnable state.',
             details: {
                 cause: result.message,
+                // jinn-mono-hjex.6: propagate structured category from the bootstrapper
+                // so the SPA can render category-specific UI (e.g. funding shortfall).
+                ...(result.errorCategory !== undefined ? { category: result.errorCategory } : {}),
                 // Preserve the raw underlying error so a misclassified summary can
                 // be diagnosed without re-running with JINN_DEBUG. See jinn-mono-jz9f.
                 ...(result.rawErrorMessage && result.rawErrorMessage !== result.message
                     ? { rawErrorMessage: result.rawErrorMessage }
                     : {}),
+                // jinn-mono-hjex reviewer fix: propagate tx hash so the SPA can render
+                // a block-explorer link for failed on-chain revert transactions.
+                ...(result.txHash != null ? { txHash: result.txHash } : {}),
             },
         });
     }
@@ -592,7 +626,9 @@ class SetupBootstrapHalted extends Error {
         this.name = 'SetupBootstrapHalted';
     }
 }
-const keepSetupUiOnBootstrapError = () => process.env['JINN_NO_UI'] !== '1' && process.env['JINN_NO_DAEMON'] !== '1';
+// hjex.6: gate for the halt-and-resume loop. Lives in ./setup/halt-mode.ts
+// so it can be unit-tested without dragging main.ts's top-level side
+// effects (password resolution, config load) into the test.
 // ── Main ────────────────────────────────────────────────────────────────────
 /**
  * --json-progress: emit NDJSON progress envelopes on stdout during long
@@ -651,6 +687,15 @@ export async function main() {
     else {
         logRpcLocalDevToStderr(rpcPreflight);
     }
+    // Boot-time RPC fallback-chain probe (issue #592, AC7 + AC9). Log-only —
+    // per-slot 429s/5xx never gate startup. checkRpcNetwork above already
+    // fail-loud on chain-id mismatch against the head provider.
+    await probeFallbackChain(config.rpcUrls, config.network, 'L2');
+    console.error(summarizeFallbackChain('L2', config.rpcUrls));
+    if (config.jinnClaimLoopEnabled && config.ethereumRpcUrls) {
+        await probeFallbackChain(config.ethereumRpcUrls, config.network, 'L1');
+        console.error(summarizeFallbackChain('L1', config.ethereumRpcUrls));
+    }
     const portPreflight = await checkApiPortAvailable(config.apiPort);
     if (!portPreflight.ok) {
         emitEnvelope({
@@ -679,6 +724,7 @@ export async function main() {
     // /v1/bootstrap + /v1/events + /v1/status here. The same Store instance is
     // later passed into Daemon so we don't double-open the SQLite file.
     const sharedStore = new Store(config.dbPath);
+    setDefaultTxSubmissionLedger(sharedStore);
     const capturesStore = new CapturesStore(sharedStore);
     let captureReceiver;
     try {
@@ -703,11 +749,56 @@ export async function main() {
         console.warn('[main] Capture OTLP receiver disabled; path-A telemetry capture unavailable: ' +
             `${err instanceof Error ? err.message : String(err)}`);
     }
+    let transcriptWatcher;
+    let pathBSyntheticSpanProvider;
+    const closePathBTranscriptWatcher = async () => {
+        const watcher = transcriptWatcher;
+        const provider = pathBSyntheticSpanProvider;
+        transcriptWatcher = undefined;
+        pathBSyntheticSpanProvider = undefined;
+        await Promise.all([
+            watcher?.shutdown().catch(() => undefined),
+            provider?.shutdown().catch(() => undefined),
+        ]);
+    };
     const closeCaptureReceiver = async () => {
+        await closePathBTranscriptWatcher();
         const receiver = captureReceiver;
         captureReceiver = undefined;
         await receiver?.shutdown().catch(() => undefined);
     };
+    if (captureReceiver) {
+        try {
+            const watchDirectories = defaultTranscriptWatchDirectories();
+            if (watchDirectories.length > 0) {
+                pathBSyntheticSpanProvider = startSyntheticSpanProvider({
+                    otlpHttpEndpoint: `http://127.0.0.1:${captureReceiver.httpPort}/v1/traces`,
+                });
+                transcriptWatcher = await startTranscriptWatcher({
+                    directories: watchDirectories,
+                    onEvent: (envelope) => {
+                        ensurePendingCapture(capturesStore, {
+                            sessionId: envelope.sessionId,
+                            capturedAt: new Date().toISOString(),
+                            tool: envelope.tool,
+                            capturePath: 'B',
+                        });
+                        emitSyntheticSpan(pathBSyntheticSpanProvider, envelope);
+                    },
+                });
+                console.log('[main] Path-B transcript watcher started for ' +
+                    watchDirectories.map((d) => `${d.tool}@${d.directory}`).join(', '));
+            }
+            else {
+                console.log('[main] Path-B transcript watcher skipped — no Codex/Claude session directories on disk yet');
+            }
+        }
+        catch (err) {
+            await closePathBTranscriptWatcher();
+            console.warn('[main] Path-B transcript watcher disabled: ' +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     const capturePublishRef = { current: undefined };
     const earningStateStore = new FleetStateStore(config.earningDir);
     const initialFleet = await earningStateStore.tryLoadExisting();
@@ -759,6 +850,13 @@ export async function main() {
     // builder-artifacts. Holder ref lets the routes register eagerly and
     // start returning real data the moment main.ts assigns holder.current.
     const discoveryApiHolder = { current: undefined };
+    // hjex.6: retry signal for the bootstrap halt-and-resume loop.
+    // When a SetupBootstrapHalted is caught (fatal non-funding error or funding
+    // timeout), main() waits on this promise instead of returning, so the setup
+    // API stays alive and the operator can click Retry in the SPA.
+    // The retry endpoint resolves this promise to trigger a re-run.
+    let retryBootstrapResolve = null;
+    let retryBootstrapReject = null;
     let setupApiServer;
     try {
         setupApiServer = await startApiServer({
@@ -772,11 +870,30 @@ export async function main() {
                 hermesPath: config.hermesPath,
                 hermesDoctorTimeoutMs: config.hermesDoctorTimeoutMs,
             },
+            codexDoctor: {
+                codexPath: config.codexPath,
+                codexDoctorTimeoutMs: config.codexDoctorTimeoutMs,
+            },
             admin: {
-                onRestartRequested: () => {
-                    console.log('[main] Restart requested via operator MCP. Exiting...');
-                    process.exit(0);
-                },
+                // jinn-mono #289: in interactive mode (the dashboard SPA case),
+                // spawn a detached replacement before exiting so the panel reconnects
+                // to a live daemon instead of seeing a 502 + terminal prompt. In
+                // headless mode (`JINN_NO_UI=1`), exit without respawning so the
+                // supervisor / systemd / docker entrypoint decides what to do.
+                // Stop: pure exit, never respawn. The operator clicked Stop; they
+                // want the daemon down until they explicitly start it again.
+                onStopRequested: () => process.exit(0),
+                onRestartRequested: (opts) => requestDaemonRestart({
+                    forceRespawn: opts.forceRespawn,
+                    // jinn-mono #561: close the API + OTLP listeners before the
+                    // replacement spawns, so the child binds without an
+                    // EADDRINUSE race. Errors are swallowed inside
+                    // requestDaemonRestart so the operator is never stranded.
+                    preSpawnCleanup: async () => {
+                        await setupApiServer.close().catch(() => undefined);
+                        await closeCaptureReceiver();
+                    },
+                }),
             },
             harnessStatus: {
                 getStatus: async () => {
@@ -830,7 +947,6 @@ export async function main() {
                 configReader: () => ({
                     rpcUrl: config.rpcUrl,
                     defaultRpcUrl: CHAIN_CONFIG.rpcUrl,
-                    solverNets: config.solverNets,
                     joinedSolverNets: config.joinedSolverNets,
                 }),
             },
@@ -953,19 +1069,42 @@ export async function main() {
                 configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
                 defaultRpcUrlForChain: () => CHAIN_CONFIG.rpcUrl,
                 onClaudePathSelected: selectClaudePath,
-                onSolverNetsUpdated: (solverNets) => {
-                    config.solverNets = solverNets;
-                    // The prediction operator status is memoised per-`JinnConfig`
-                    // reference; mutating in place leaves the cache pointing at the
-                    // pre-edit snapshot. Drop the entry so the next /v1/status read
-                    // (and thus Overview's `solverNet.enabled` gating) reflects the
-                    // toggle immediately. (jinn-mono-l2zl.15.4.12)
+                // Issue #421 retired the legacy `solverNets` write target. Setup
+                // endpoints no longer call back into the daemon to mutate operator
+                // SolverNet config; the canonical join flow is
+                // `POST /v1/operator/join/:cid`, which mutates
+                // `config.joinedSolverNets` directly via its own write path.
+                // The cache-invalidation hook is no longer needed here.
+                onSolverNetsUpdated: () => {
                     invalidatePredictionOperatorStatusCache(config);
                 },
+                // hjex.6: re-trigger the bootstrap state machine from the SPA Retry button.
+                // Resolves the halt-and-resume promise; main() will loop back and call
+                // bootstrap() again. Rejects if the daemon is not currently halted.
+                retryBootstrap: () => {
+                    return new Promise((resolve, reject) => {
+                        if (!retryBootstrapResolve) {
+                            reject(new Error('daemon_not_halted'));
+                            return;
+                        }
+                        const prevResolve = retryBootstrapResolve;
+                        // The resolve will unblock the main loop's await. When bootstrap
+                        // completes (success or new halt), the caller receives the result
+                        // via the /v1/bootstrap polling endpoint.
+                        prevResolve();
+                        resolve();
+                    });
+                },
             },
             status: {
                 earningDir: config.earningDir,
                 rpcUrl: config.rpcUrl,
+                // tJINN identity comes from the bundled JINN MVI L1 artifact
+                // (`JINN_MVI_CONFIG`) — one source of truth. The Sepolia RPC endpoint
+                // is read from `config.ethereumRpcUrl` via the threaded `config`.
+                tjinnTokenAddress: JINN_MVI_CONFIG.jinn,
+                tjinnChainId: JINN_MVI_CONFIG.l1ChainId,
+                tjinnDistributorAddress: JINN_MVI_CONFIG.distributor,
                 network: config.network,
                 pollIntervalMs: config.pollIntervalMs,
                 masterEthDailyEstimateWei: config.masterEthDailyEstimateWei,
@@ -1000,29 +1139,30 @@ export async function main() {
             // TODO(jinn-mono launcher Task 8): real `getReservedBudgetWei`
             // (sum of unconsumed claim payments across open Tasks).
             launcher: {
-                getConfig: () => ({ solverNets: config.solverNets }),
+                getConfig: () => ({ joinedSolverNets: config.joinedSolverNets }),
                 configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
-                // Cache-invalidation hook retained for the operator-mode
-                // setup-endpoints flow; the launcher-mode PATCH route was retired
-                // by Task 22, so this currently fires only when operator mode
-                // mutates `solverNets`.
-                onSolverNetsUpdated: (solverNets) => {
-                    config.solverNets = solverNets;
+                // Issue #421 retired the legacy `solverNets` write target. The hook
+                // only needs to invalidate the prediction-operator status cache when
+                // operator mode mutates joinedSolverNets via setup endpoints.
+                onSolverNetsUpdated: () => {
                     invalidatePredictionOperatorStatusCache(config);
                 },
                 getGeneratorState: (netName) => {
                     if (netName === 'prediction') {
                         return predictionGeneratorRef?.getState();
                     }
-                    const solverType = config.solverNets?.[netName]?.solverType;
+                    const joined = findJoinedByName(config.joinedSolverNets, netName);
+                    const solverType = joined ? solverTypeFromJoinedContract(joined) : undefined;
                     if (!solverType)
                         return undefined;
                     return launchedGeneratorStateBySolverType.get(solverType)?.();
                 },
                 getOpenTaskCount: (netName) => {
-                    const net = config.solverNets?.[netName];
-                    const solverType = net?.solverType;
-                    if (!solverType || !safeAddressForLauncher)
+                    if (!safeAddressForLauncher)
+                        return 0;
+                    const joined = findJoinedByName(config.joinedSolverNets, netName);
+                    const solverType = joined ? solverTypeFromJoinedContract(joined) : undefined;
+                    if (!solverType)
                         return 0;
                     return sharedStore.countPostedTasksByCreatorAndSolverType({
                         creatorSafeAddress: safeAddressForLauncher,
@@ -1114,30 +1254,41 @@ export async function main() {
     // can attach to a long-lived embedded `claude` subprocess. The embedded
     // session reads MCP config we materialise to disk so it can reach the
     // operator MCP server (`jinn mcp`) for tool calls.
-    const operatorMcpConfigPath = join(homedir(), '.jinn-client', 'operator-mcp-config.json');
-    try {
-        mkdirSync(dirname(operatorMcpConfigPath), { recursive: true });
-        writeFileSyncMain(operatorMcpConfigPath, JSON.stringify({
-            mcpServers: {
-                'jinn-operator': {
-                    command: 'jinn',
-                    args: ['mcp'],
+    //
+    // Issue #326: the embedded agent chat surface is hidden by default. The WS
+    // bridge mounts only when `JINN_ENABLE_EMBEDDED_AGENT=1` so the dev-time
+    // path stays end-to-end; with the flag off there is no /api/agent/ws route
+    // and the SPA never renders the chat panel. Claude-Code-as-solver-harness
+    // is independent of this bridge and unaffected.
+    if (embeddedAgentEnabled) {
+        const operatorMcpConfigPath = join(homedir(), '.jinn-client', 'operator-mcp-config.json');
+        try {
+            mkdirSync(dirname(operatorMcpConfigPath), { recursive: true });
+            writeFileSyncMain(operatorMcpConfigPath, JSON.stringify({
+                mcpServers: {
+                    'jinn-operator': {
+                        command: 'jinn',
+                        args: ['mcp'],
+                    },
                 },
-            },
-        }, null, 2));
+            }, null, 2));
+        }
+        catch (err) {
+            console.warn(`[main] Failed to write operator MCP config at ${operatorMcpConfigPath}: ` +
+                (err instanceof Error ? err.message : String(err)));
+        }
+        attachAgentWs({
+            httpServer: setupApiServer.server,
+            uiToken,
+            claudePath: activeClaudePath,
+            cwd: process.cwd(),
+            mcpConfigPath: operatorMcpConfigPath,
+        });
+        console.log(`[main] Agent WS bridge mounted at ws://127.0.0.1:${setupApiServer.port}/api/agent/ws`);
     }
-    catch (err) {
-        console.warn(`[main] Failed to write operator MCP config at ${operatorMcpConfigPath}: ` +
-            (err instanceof Error ? err.message : String(err)));
+    else {
+        console.log('[main] Embedded agent surface disabled (set JINN_ENABLE_EMBEDDED_AGENT=1 to enable).');
     }
-    attachAgentWs({
-        httpServer: setupApiServer.server,
-        uiToken,
-        claudePath: activeClaudePath,
-        cwd: process.cwd(),
-        mcpConfigPath: operatorMcpConfigPath,
-    });
-    console.log(`[main] Agent WS bridge mounted at ws://127.0.0.1:${setupApiServer.port}/api/agent/ws`);
     // ── Init-if-missing ──────────────────────────────────────────────────────
     // If the keystore is missing but we have a password, run `jinn init` now so
     // bootstrap has something to decrypt. Idempotent: init is a no-op when the
@@ -1178,30 +1329,96 @@ export async function main() {
         // keystore is on disk and we're transitioning into bootstrap.
         setupController.refresh({ keystoreExists: true, allComplete: false });
     }
+    // hjex.6: halt-and-resume loop for bootstrap retries.
+    // When failBootstrap() throws SetupBootstrapHalted, we wait for the operator
+    // to click Retry in the SPA (which resolves retryBootstrapResolve) rather
+    // than returning and exiting. On each retry, we loop back and call bootstrap()
+    // again. bootstrap() is idempotent — completed steps are no-ops.
     let bootstrapResult;
-    try {
-        bootstrapResult = await bootstrap();
-    }
-    catch (err) {
-        if (err instanceof SetupBootstrapHalted) {
-            return {
-                schemaVersion: 1,
-                generatedAt: new Date().toISOString(),
-                kind: 'setup_halted',
-                pid: process.pid,
-                network: config.network,
-                phase: config.network === 'testnet' ? 'phase-1b' : 'phase-0',
-                apiPort: setupApiServer.port,
-                dashboardUrl: `http://127.0.0.1:${setupApiServer.port}`,
-                error: err.envelope,
-            };
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            bootstrapResult = await bootstrap();
+            break; // success — exit the retry loop
+        }
+        catch (err) {
+            if (err instanceof SetupBootstrapHalted) {
+                // Install the retry signal so the endpoint can unblock us.
+                const retrySignal = new Promise((resolve, reject) => {
+                    retryBootstrapResolve = resolve;
+                    retryBootstrapReject = reject;
+                });
+                console.log('[main] Bootstrap halted. Waiting for retry signal from the dashboard...');
+                // hjex.6: Auto-resume funding poller.
+                // When the halt is a funding shortfall, poll the master EOA balance
+                // every JINN_FUNDING_POLL_INTERVAL_MS (default 15s). When the balance
+                // meets or exceeds the required amount, auto-signal the retry loop.
+                // Only runs while the halt signal is pending; stops on any signal.
+                let fundingPollHandle = null;
+                const isHaltedOnFunding = err.envelope.code === 'funding_required';
+                const haltDetails = err.envelope.details;
+                const haltAddress = typeof haltDetails?.['address'] === 'string'
+                    ? haltDetails['address']
+                    : null;
+                const haltRequired = typeof haltDetails?.['requiredWei'] === 'string'
+                    ? BigInt(haltDetails['requiredWei'])
+                    : typeof haltDetails?.['needWei'] === 'string'
+                        ? BigInt(haltDetails['needWei'])
+                        : null;
+                const fundingPollIntervalMs = (() => {
+                    const raw = process.env['JINN_FUNDING_POLL_INTERVAL_MS'];
+                    if (!raw)
+                        return 15_000;
+                    const n = Number.parseInt(raw, 10);
+                    return Number.isFinite(n) && n > 0 ? n : 15_000;
+                })();
+                if (isHaltedOnFunding && haltAddress && haltRequired !== null) {
+                    const publicClient = createJinnPublicClient(config.rpcUrls, NETWORK_CHAIN);
+                    const schedulePoll = () => {
+                        fundingPollHandle = setTimeout(async () => {
+                            // Guard: if the signal was already fired, stop polling.
+                            if (!retryBootstrapResolve)
+                                return;
+                            try {
+                                const balance = await publicClient.getBalance({ address: haltAddress });
+                                if (balance >= haltRequired) {
+                                    console.log(`[main] Funding shortfall cleared (have ${balance}, required ${haltRequired}). ` +
+                                        `Auto-resuming bootstrap...`);
+                                    retryBootstrapResolve?.();
+                                    return; // don't schedule the next poll
+                                }
+                            }
+                            catch (pollErr) {
+                                // Balance read failed — not fatal, just skip this tick.
+                                const msg = pollErr instanceof Error ? pollErr.message : String(pollErr);
+                                console.log(`[main] Funding poller balance read failed (will retry): ${msg}`);
+                            }
+                            schedulePoll(); // reschedule
+                        }, fundingPollIntervalMs);
+                    };
+                    schedulePoll();
+                }
+                try {
+                    await retrySignal;
+                }
+                finally {
+                    retryBootstrapResolve = null;
+                    retryBootstrapReject = null;
+                    if (fundingPollHandle !== null) {
+                        clearTimeout(fundingPollHandle);
+                        fundingPollHandle = null;
+                    }
+                }
+                console.log('[main] Retry triggered — re-running bootstrap...');
+                continue; // loop back to the bootstrap() call
+            }
+            // If bootstrap throws an unexpected error (vs. SetupBootstrapHalted),
+            // tear down the API we just started so we don't leave a dangling listener.
+            await setupApiServer.close().catch(() => undefined);
+            await closeCaptureReceiver();
+            sharedStore.close();
+            throw err;
         }
-        // If bootstrap throws (vs. emitEnvelope-exits), tear down the API we
-        // just started so we don't leave a dangling listener on the port.
-        await setupApiServer.close().catch(() => undefined);
-        await closeCaptureReceiver();
-        sharedStore.close();
-        throw err;
     }
     // Bootstrap completed — flip the controller into 'running' so any waiters
     // (future loops gated on this) unblock.
@@ -1254,9 +1471,9 @@ export async function main() {
     const earningStore = new FleetStateStore(config.earningDir);
     const mnemonicForMaster = await decryptMnemonic(await earningStore.loadMnemonicKeystore(), PASSWORD);
     const masterAccount = deriveMasterSigner(mnemonicForMaster);
-    const publicClient = createJinnPublicClient(config.rpcUrl, NETWORK_CHAIN);
+    const publicClient = createJinnPublicClient(config.rpcUrls, NETWORK_CHAIN);
     publicClientForLauncher = publicClient;
-    const masterWallet = createJinnWalletClient(config.rpcUrl, NETWORK_CHAIN, masterAccount);
+    const masterWallet = createJinnWalletClient(config.rpcUrls, NETWORK_CHAIN, masterAccount);
     const evictionRecovery = config.stakingMode === 'standard' &&
         serviceId !== null &&
         stakingAddress &&
@@ -1315,7 +1532,7 @@ export async function main() {
     // the /build page rendered "Discovery unavailable" permanently.
     discoveryApiHolder.current = sharedDiscoveryApi;
     const adapter = new MechAdapter({
-        rpcUrl: config.rpcUrl,
+        rpcUrl: config.rpcUrls,
         mechMarketplaceAddress: MARKETPLACE_ADDRESS,
         routerAddress: ROUTER_ADDRESS,
         mechContractAddress: mechAddress,
@@ -1331,12 +1548,18 @@ export async function main() {
             ? {
                 discoveryApi: sharedDiscoveryApi,
                 solverNetManifestCids: taskDiscoveryManifestCids,
-                // No explicit `onchainFromBlock` — let `MechAdapter`'s
+                // No explicit `onchainFromBlock` by default — let `MechAdapter`'s
                 // `DEFAULT_TASK_DISCOVERY_FROM_BLOCK` per-chain default flow
                 // through. Hardcoding here shadowed the adapter's default and
                 // re-introduced the ghost-task floor every release; removing the
                 // shadow makes `adapter.ts` the single source of truth. See gh
-                // #300.
+                // #300. An operator MAY opt in to a recent floor via
+                // `taskDiscoveryOnchainFromBlock` to bound the canonical getLogs
+                // scan (which otherwise parses a large history on the main thread
+                // and can stall the loop) and lean on the indexer DiscoveryAPI.
+                ...(config.taskDiscoveryOnchainFromBlock !== undefined
+                    ? { onchainFromBlock: config.taskDiscoveryOnchainFromBlock }
+                    : {}),
                 ...(config.taskDiscoveryAllowedTaskIds?.length
                     ? { allowedTaskIds: config.taskDiscoveryAllowedTaskIds }
                     : {}),
@@ -1353,26 +1576,52 @@ export async function main() {
     const agentChainContracts = agentChain.contracts;
     const optimismPortalAddress = agentChainContracts?.portal?.[l1Chain.id]?.address;
     const disputeGameFactoryAddress = agentChainContracts?.disputeGameFactory?.[l1Chain.id]?.address;
-    const l2ProofClient = config.l2ProofRpcUrl
-        ? createJinnPublicClient(config.l2ProofRpcUrl, NETWORK_CHAIN)
+    const l2ProofClient = config.l2ProofRpcUrls
+        ? createJinnPublicClient(config.l2ProofRpcUrls, NETWORK_CHAIN)
         : undefined;
-    const agentClients = createClients(config.rpcUrl, agentPrivateKey, agentChain);
+    const agentClients = createClients(config.rpcUrls, agentPrivateKey, agentChain);
     // ── L1 (Sepolia / Ethereum mainnet) clients for cross-chain JINN claim loop ──
     // Uses the agent EOA because MockMessenger.owner is the agent on testnet.
     // Same key as L2; only the chain differs.
-    const l1ClientsForJinnClaim = JINN_MVI_CONFIG.distributor && config.ethereumRpcUrl
+    const shouldWireJinnClaimL1 = shouldWireJinnClaimL1Signer({
+        enabled: config.jinnClaimLoopEnabled,
+        intervalMs: config.jinnClaimLoopIntervalMs,
+        submissionMode: config.jinnClaimSubmissionMode,
+        distributorAddress: JINN_MVI_CONFIG.distributor,
+        ethereumRpcUrl: config.ethereumRpcUrl,
+    });
+    const l1ClientsForJinnClaim = shouldWireJinnClaimL1 && config.ethereumRpcUrls
         ? {
-            public: createJinnL1PublicClient(config.ethereumRpcUrl, config.jinnL1Network),
-            wallet: createJinnL1WalletClient(config.ethereumRpcUrl, config.jinnL1Network, privateKeyToAccount(agentPrivateKey)),
+            public: createJinnL1PublicClient(config.ethereumRpcUrls, config.jinnL1Network),
+            wallet: createJinnL1WalletClient(config.ethereumRpcUrls, config.jinnL1Network, privateKeyToAccount(agentPrivateKey)),
         }
         : undefined;
-    if (l1ClientsForJinnClaim) {
-        console.log(`[main] JinnClaimLoop: enabled (mode=${JINN_CLAIM_MESSENGER_MODE}, ` +
+    const jinnClaimLoopConfig = buildJinnClaimLoopConfig({
+        enabled: config.jinnClaimLoopEnabled,
+        intervalMs: config.jinnClaimLoopIntervalMs,
+        submissionMode: config.jinnClaimSubmissionMode,
+        messengerMode: JINN_CLAIM_MESSENGER_MODE,
+        mvi: JINN_MVI_CONFIG,
+        l2Client: agentClients.publicClient,
+        l2ProofClient,
+        l2Wallet: agentClients.walletClient,
+        l1Clients: l1ClientsForJinnClaim,
+        store: earningStore,
+        chain: NETWORK_CHAIN,
+        optimismPortalAddress,
+        disputeGameFactoryAddress,
+    });
+    if (jinnClaimLoopConfig) {
+        console.log(`[main] JinnClaimLoop: enabled (submission=${config.jinnClaimSubmissionMode}, ` +
+            `mode=${JINN_CLAIM_MESSENGER_MODE}, ` +
             `interval=${config.jinnClaimLoopIntervalMs}ms, distributor=${JINN_MVI_CONFIG.distributor}, ` +
             `emitter=${JINN_MVI_CONFIG.claimEmitter})`);
     }
+    else if (!config.jinnClaimLoopEnabled) {
+        console.log('[main] JinnClaimLoop: disabled (jinnClaimLoopEnabled=false)');
+    }
     else {
-        console.log(`[main] JinnClaimLoop: disabled (JinnDistributor artifact/override or JINN_ETHEREUM_RPC_URL not set)`);
+        console.log(`[main] JinnClaimLoop: disabled (missing claim-loop artifacts, interval disabled, or L1 submit wiring)`);
     }
     // ── Harness registry ─────────────────────────────────────────────────────────
     const solverNetRegistry = await loadSolverNets(config);
@@ -1464,6 +1713,9 @@ export async function main() {
         hermesPath: config.hermesPath,
         hermesModel: config.hermesModel,
         hermesProvider: config.hermesProvider,
+        hermesDoctorTimeoutMs: config.hermesDoctorTimeoutMs,
+        codexPath: config.codexPath,
+        codexDoctorTimeoutMs: config.codexDoctorTimeoutMs,
     })) {
         implRegistry.register(impl);
     }
@@ -1733,11 +1985,19 @@ export async function main() {
                 if (!safeAddressForLauncher) {
                     throw new Error('[main] safeAddressForLauncher missing at SolverNet endpoints registration');
                 }
+                const getGeneratorState = (solverNetId) => {
+                    const entry = pendingGeneratorsRef.current.find((g) => g.recordRef.current.solverNetId === solverNetId);
+                    const resolved = resolveContractFromSolverNetId(entry?.recordRef.current.solverNetId ?? solverNetId);
+                    if (!resolved)
+                        return undefined;
+                    return launchedGeneratorStateBySolverType.get(resolved.solverType)?.();
+                };
                 solverNetEndpointsDepsHolder.current = {
                     store: solverNetStore,
                     launch: {
                         launchAction,
                         lifecycleTransition,
+                        getGeneratorState,
                         pendingGenerators: pendingGeneratorsRef,
                         signer: launcherSigner,
                         network: 'base-sepolia',
@@ -1794,6 +2054,7 @@ export async function main() {
                 agentEoa: agentEoaAddress,
                 safeAddress,
                 agentPrivateKey,
+                ...(sharedDiscoveryApi ? { discoveryApi: sharedDiscoveryApi } : {}),
             },
             logger: {
                 info: (message) => console.log(message),
@@ -1812,9 +2073,23 @@ export async function main() {
     if (config.network === 'mainnet' && !autoTasksDisabled && BASE_FEEDS['ETH / USD']) {
         // Mainnet auto-task opt-in only; default is OFF. Reserved for a future flag.
     }
+    // filterBindableTasks (issue #415): drop config-level tasks[] entries without
+    // solverNetManifestCid before they enter the creator loop. Such entries would
+    // throw a PermanentError on every attempt and retry every 30 min indefinitely.
+    const bindableConfigTasks = filterBindableTasks(config.tasks);
     const taskSources = [
-        new StaticConfiguredTaskSource(config.tasks),
-        ...launchedRecordGenerators.map(({ solverType, generator }, idx) => new GeneratedTaskSource(`launched:${solverType}:${idx}`, generator)),
+        new StaticConfiguredTaskSource(bindableConfigTasks),
+        ...launchedRecordGenerators.map(({ solverType, generator }, idx) => new GeneratedTaskSource(`launched:${solverType}:${idx}`, generator, {
+            bucketKeyForTask: (task) => {
+                if (task.solverType !== 'swe-rebench-v2.v1')
+                    return undefined;
+                const instanceId = task.spec?.['instance_id'];
+                const postedCount = task.eligibility?.['posted_count_after_record'];
+                if (typeof instanceId !== 'string' || typeof postedCount !== 'number')
+                    return undefined;
+                return `swe-rebench-v2:${instanceId}:${postedCount}`;
+            },
+        })),
     ];
     // ── Corpus (daemon-side, jinn-mono-vy37.1.6) ─────────────────────────────
     //
@@ -1847,6 +2122,7 @@ export async function main() {
         console.warn('[main] Corpus disabled (no DiscoveryAPI or on-chain identity registry); ' +
             'MCP record lookup and artifact acquisition network branches will be unavailable.');
     }
+    const spendCap = buildSpendCapConfig(config, process.env);
     const daemon = new Daemon({
         adapter,
         runner,
@@ -1863,9 +2139,21 @@ export async function main() {
         creatorSafeAddress: safeAddress,
         corpusFactory,
         harnessReadinessRegistry,
+        spendCap,
         status: {
             earningDir: config.earningDir,
             rpcUrl: config.rpcUrl,
+            // tJINN identity comes from the bundled JINN MVI L1 artifact
+            // (`JINN_MVI_CONFIG`) — one source of truth. The Sepolia RPC endpoint
+            // is read from `config.ethereumRpcUrl` via the threaded `config`.
+            tjinnTokenAddress: JINN_MVI_CONFIG.jinn,
+            tjinnChainId: JINN_MVI_CONFIG.l1ChainId,
+            tjinnDistributorAddress: JINN_MVI_CONFIG.distributor,
+            // stOLAS L2 distributor — mirrors `CHAIN_CONFIG.distributorAddress`
+            // used to gate the EvictionLoop (issue #651). Threaded through so the
+            // SPA's autoRestake predicate keys off the same on-chain artifact as
+            // the daemon's `evictionCheck` predicate (~line 2520 below).
+            stOlasDistributorAddress: CHAIN_CONFIG.distributorAddress,
             network: config.network,
             pollIntervalMs: config.pollIntervalMs,
             masterEthDailyEstimateWei: config.masterEthDailyEstimateWei,
@@ -1877,6 +2165,7 @@ export async function main() {
             engine: config.engine,
             config,
             configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
+            spendCaps: spendCap?.caps,
         },
         rewardClaim: config.rewardClaimIntervalMs > 0
             ? {
@@ -1888,28 +2177,7 @@ export async function main() {
                 distributorAddress: CHAIN_CONFIG.distributorAddress,
             }
             : undefined,
-        jinnClaim: l1ClientsForJinnClaim &&
-            JINN_MVI_CONFIG.claimEmitter &&
-            JINN_MVI_CONFIG.messenger &&
-            JINN_MVI_CONFIG.distributor &&
-            config.jinnClaimLoopIntervalMs > 0
-            ? {
-                intervalMs: config.jinnClaimLoopIntervalMs,
-                l2Client: agentClients.publicClient,
-                l2ProofClient,
-                l2Wallet: agentClients.walletClient,
-                l1Client: l1ClientsForJinnClaim.public,
-                l1Wallet: l1ClientsForJinnClaim.wallet,
-                store: earningStore,
-                chain: NETWORK_CHAIN,
-                claimEmitterAddress: JINN_MVI_CONFIG.claimEmitter,
-                distributorAddress: JINN_MVI_CONFIG.distributor,
-                messengerAddress: JINN_MVI_CONFIG.messenger,
-                messengerMode: JINN_CLAIM_MESSENGER_MODE,
-                optimismPortalAddress,
-                disputeGameFactoryAddress,
-            }
-            : undefined,
+        jinnClaim: jinnClaimLoopConfig,
         restorationEngine: {
             paths: {
                 workingDirRoot: config.engine.workingDirRoot,
@@ -1954,11 +2222,71 @@ export async function main() {
                 safeTopupTarget: CHAIN_CONFIG.minSafeEth,
             }
             : undefined,
+        // Eviction-check loop — only in standard staking mode (requires distributorAddress).
+        // Running mode only: setup-halted daemons must not try to restake services that
+        // haven't been staked yet (hjex.3).
+        evictionCheck: config.evictionCheckIntervalMs > 0 &&
+            config.stakingMode === 'standard' &&
+            CHAIN_CONFIG.distributorAddress
+            ? {
+                intervalMs: config.evictionCheckIntervalMs,
+                store: earningStore,
+                chain: NETWORK_CHAIN,
+                readContract: (opts) => publicClient.readContract(opts),
+                recoverEvictedService: async (svc) => {
+                    if (!svc.service_id || !svc.staking_address)
+                        return;
+                    await recoverEvictedServiceFn({
+                        serviceDisplayIndex: Math.max(0, svc.index - 1),
+                        serviceId: svc.service_id,
+                        stakingAddress: svc.staking_address,
+                        distributorAddress: CHAIN_CONFIG.distributorAddress,
+                        rpcUrl: config.rpcUrl,
+                        chain: NETWORK_CHAIN,
+                        mnemonic: mnemonicForMaster,
+                    });
+                },
+            }
+            : undefined,
+        // Checkpoint loop — proactively advances `tsCheckpoint` on each staked
+        // proxy so the activity-rate window stays narrow (issue #505).
+        // `checkpoint()` is permissionless; master EOA pays gas. No-op for
+        // non-standard staking modes.
+        checkpoint: config.checkpointIntervalMs > 0 && config.stakingMode === 'standard'
+            ? {
+                intervalMs: config.checkpointIntervalMs,
+                store: earningStore,
+                chain: NETWORK_CHAIN,
+                writeCheckpoint: async ({ stakingProxy }) => {
+                    const txHash = await masterWallet.writeContract({
+                        address: stakingProxy,
+                        abi: [
+                            {
+                                type: 'function',
+                                name: 'checkpoint',
+                                stateMutability: 'nonpayable',
+                                inputs: [],
+                                outputs: [],
+                            },
+                        ],
+                        functionName: 'checkpoint',
+                        account: masterAccount,
+                        chain: null,
+                    });
+                    return { txHash };
+                },
+            }
+            : undefined,
     });
-    // Write pidfile so `jinn stop` can find us.
+    // Write pidfile so `jinn stop` can find us. First, refuse the run if another
+    // daemon already owns this earning directory — see issue #649. The gate
+    // handles all three branches (refuse-and-exit, unlink-stale-and-continue,
+    // proceed); the writeFileSync below MUST stay outside the helper so the
+    // "// DO NOT add store mutations above this line — see #649" invariant is
+    // visible right here at the call site.
     const pidPath = join(config.earningDir, 'daemon.pid');
-    const { writeFileSync, unlinkSync } = await import('node:fs');
-    writeFileSync(pidPath, String(process.pid) + '\n', 'utf-8');
+    applyPidfileLivenessGate(pidPath);
+    writeFileSyncMain(pidPath, String(process.pid) + '\n', 'utf-8');
     const removePidfile = () => {
         try {
             unlinkSync(pidPath);