@jinn-network/client 0.1.5 → 0.1.6-canary.092089a9

package/dist/main.js

@@ -26,7 +26,9 @@ 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';
+// addHarnessReadinessRoutes is wired through startApiServer's holder ref now
+// (jinn-mono-u34i). No direct import needed.
 import { CapturePublishUnavailableError } from './api/captures.js';
 import { invalidatePredictionOperatorStatusCache } from './api/gather-status.js';
 import { ensureUiToken } from './api/ui-token.js';
@@ -34,14 +36,11 @@ 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 { checkClaudeBinary } from './preflight/claude-binary.js';
-import { emitClaudeBinaryPreflightFailure } from './preflight/claude-invocation-envelope.js';
-import { detectAuthContext, probeClaudeAuth } from './preflight/claude-auth.js';
-import { configRequiresClaudeAuth } from './preflight/claude-required.js';
-import { FleetBootstrapper } from './earning/bootstrap.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';
@@ -50,6 +49,7 @@ 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 { 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';
@@ -57,7 +57,8 @@ import { DEFAULT_DISABLED_HARNESSES, DEFAULT_HARNESS, HarnessRegistry, } from '.
 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, harnessStateDirName } from './harnesses/names.js';
+import { CLAUDE_CODE_HARNESS, CODEX_HARNESS, HERMES_AGENT_HARNESS, harnessStateDirName } from './harnesses/names.js';
+import { HarnessReadinessRegistry } from './harnesses/readiness-registry.js';
 import { createClients } from './adapters/mech/safe.js';
 import { loadSolverNets } from './solver-nets/registry.js';
 import { createCorpus } from './corpus/index.js';
@@ -81,6 +82,7 @@ import { GeneratedTaskSource, StaticConfiguredTaskSource } from './tasks/sources
 import { checkRpcNetwork, logRpcLocalDevToStderr, rpcNetworkFailureHint } 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') });
 }
@@ -133,8 +135,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://sepolia.base.org';
+    config.rpcUrl = 'https://base-sepolia.gateway.tenderly.co/75tyLMQuD8EHpXxMwINIKu';
 }
+// 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;
@@ -442,7 +455,7 @@ async function bootstrap() {
     };
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        result = await bootstrapper.bootstrap(PASSWORD);
+        result = await bootstrapper.ensureStage1And2(PASSWORD);
         if (!result.funding) {
             clearFundingGate();
             break;
@@ -485,11 +498,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,
                 },
             });
         }
@@ -504,11 +523,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 } : {}),
             },
         });
     }
@@ -593,7 +618,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
@@ -744,6 +771,34 @@ export async function main() {
     // on first request); subsystem init below populates `holder.current` and
     // the route handlers dereference it per-request.
     const solverNetEndpointsDepsHolder = { current: undefined };
+    // jinn-mono-u34i: same pattern for the harness readiness registry. The
+    // registry is built post-bootstrap (depends on the keystore being
+    // available), but the routes must be registered at server start to land in
+    // Hono's matcher before the panel's first poll. Late-mounting via
+    // `addHarnessReadinessRoutes(setupApiServer.app, ...)` after the panel had
+    // been polling for minutes threw "Can not add a route since the matcher is
+    // already built" and crashed the daemon on the running-mode transition.
+    const harnessReadinessRegistryHolder = { current: undefined };
+    // jinn-mono-u34i: same eager-register / late-populate pattern for the
+    // DiscoveryAPI. Pre-fix, /v1/discovery/* routes only mounted when
+    // `config.discovery` was set at startApiServer time — but main.ts builds
+    // `sharedDiscoveryApi` post-bootstrap, so the routes were never registered
+    // and the panel's /build page got a permanent 404 on plugin-publications +
+    // 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.3: holder for the restake callback. Populated in running mode after
+    // bootstrap completes (when mnemonic + distributorAddress are available).
+    const restakeCallbackRef = {
+        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({
@@ -753,11 +808,24 @@ export async function main() {
             bindHost: apiBindHost,
             corpus: () => corpusForApi,
             ui: { token: uiToken, handshakeKey },
+            hermesDoctor: {
+                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 }),
             },
             harnessStatus: {
                 getStatus: async () => {
@@ -840,7 +908,12 @@ export async function main() {
                             contract: { id: 'swe-rebench-v2', version: 'v1' },
                             state: 'live',
                             supportedRoles: ['solving', 'evaluating'],
+                            // Order matters: the dashboard pre-selects compatibleHarnesses[0]
+                            // as the default solver harness. Hermes Agent is the SWE-rebench v2
+                            // default per the 2026-05-12 decision (jinn-mono-8psp.2 / spec §10);
+                            // operators may switch to Claude Code or Codex.
                             compatibleHarnesses: [
+                                { name: HERMES_AGENT_HARNESS, version: '0.1.0', supportsRoles: ['solving'] },
                                 { name: CLAUDE_CODE_HARNESS, version: '0.1.0', supportsRoles: ['solving'] },
                                 { name: CODEX_HARNESS, version: '0.1.0', supportsRoles: ['solving'] },
                                 { name: 'swe-rebench-v2-evaluator', version: '0.1.0', supportsRoles: ['evaluating'] },
@@ -856,6 +929,12 @@ export async function main() {
             // eagerly here; deps are populated by main.ts post-bootstrap via the
             // holder, and each route handler reads `holder.current` per-request.
             solverNetsLauncher: { holder: solverNetEndpointsDepsHolder },
+            // jinn-mono-u34i: same eager-register / late-populate pattern for the
+            // harness readiness routes. Until main.ts sets the holder, requests
+            // return 503 subsystem_not_ready (the panel handles that gracefully).
+            harnessReadinessRegistry: { holder: harnessReadinessRegistryHolder },
+            // jinn-mono-u34i: see discoveryApiHolder comment above.
+            discovery: { holder: discoveryApiHolder },
             // Agent-binding retry: re-run the ERC-1271 bind step from the SPA
             // without forcing a daemon restart. Constructs a fresh bootstrapper
             // per call so we don't tangle lifecycle with the long-running one.
@@ -907,7 +986,17 @@ export async function main() {
                 earningDir: config.earningDir,
                 chain: NETWORK_CHAIN,
                 rpcUrl: config.rpcUrl,
-                minEoaGasWei: (CHAIN_CONFIG.minEoaGasEth * 2n).toString(),
+                // Note: do NOT pass minEoaGasWei here. setup-endpoints.ts derives
+                // its faucet target from stage1MinMasterEth(getChainConfig(chain),
+                // targetServices) — the same helper the daemon's ensureStage1 gate
+                // uses. Passing a computed value from here would re-introduce the
+                // drift seam that hit operators in the 2026-05-18 canary
+                // (jinn-mono-u34i): faucet dripped to one target while the daemon
+                // waited for a different one. The override field remains for tests
+                // that want a custom target.
+                // targetServices DOES need to flow through so the faucet drips enough
+                // ETH to cover ALL services for the operator's chosen targetServices.
+                targetServices: config.targetServices,
                 claudePath: activeClaudePath,
                 getClaudePath: () => activeClaudePath,
                 configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
@@ -922,10 +1011,39 @@ export async function main() {
                     // toggle immediately. (jinn-mono-l2zl.15.4.12)
                     invalidatePredictionOperatorStatusCache(config);
                 },
+                // hjex.3: delegate to the live callback populated once running mode starts.
+                restake: (serviceId) => {
+                    if (!restakeCallbackRef.current) {
+                        return Promise.resolve({ ok: false, error: 'restake_not_available_in_setup_mode' });
+                    }
+                    return restakeCallbackRef.current(serviceId);
+                },
+                // 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,
                 network: config.network,
                 pollIntervalMs: config.pollIntervalMs,
                 masterEthDailyEstimateWei: config.masterEthDailyEstimateWei,
@@ -1074,30 +1192,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
@@ -1138,30 +1267,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.rpcUrl, 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.
@@ -1207,35 +1402,6 @@ export async function main() {
             },
         });
     }
-    const claudeAuthRequired = configRequiresClaudeAuth(config);
-    if (claudeAuthRequired) {
-        const preflight = await checkClaudeBinary(activeClaudePath);
-        if (!preflight.ok) {
-            emitClaudeBinaryPreflightFailure(preflight.detail, activeClaudePath);
-        }
-        const authContext = detectAuthContext({ cwd: process.cwd(), configuredMode: config.runtimeMode });
-        const authProbe = probeClaudeAuth({
-            context: authContext,
-            cwd: process.cwd(),
-            claudePath: activeClaudePath,
-        });
-        if (!authProbe.authenticated) {
-            emitEnvelope({
-                code: 'invalid_invocation',
-                message: 'Claude is not authenticated. Complete Claude setup in the operator app, then restart the daemon.',
-                hint: `Detected context: ${authContext}. Run \`jinn run\` to open the app-guided setup flow.`,
-                exampleCli: 'jinn run',
-                details: {
-                    field: 'claude_auth',
-                    context: authContext,
-                    authenticated: false,
-                },
-            });
-        }
-    }
-    else {
-        console.log('[main] Claude auth preflight skipped; Claude-backed harnesses are disabled.');
-    }
     const runner = new ClaudeRunner({
         claudePath: activeClaudePath,
         model: config.claudeModel,
@@ -1246,6 +1412,33 @@ export async function main() {
     const publicClient = createJinnPublicClient(config.rpcUrl, NETWORK_CHAIN);
     publicClientForLauncher = publicClient;
     const masterWallet = createJinnWalletClient(config.rpcUrl, NETWORK_CHAIN, masterAccount);
+    // hjex.3: populate the restake callback now that mnemonic is available.
+    if (config.stakingMode === 'standard' && CHAIN_CONFIG.distributorAddress) {
+        const fleetStore = earningStore;
+        restakeCallbackRef.current = async (serviceId) => {
+            try {
+                const state = await fleetStore.load(NETWORK_CHAIN);
+                const svc = state.services.find(s => s.service_id === serviceId);
+                if (!svc)
+                    return { ok: false, error: `service_not_found:${serviceId}` };
+                if (!svc.staking_address)
+                    return { ok: false, error: 'staking_address_missing' };
+                await recoverEvictedServiceFn({
+                    serviceDisplayIndex: Math.max(0, svc.index - 1),
+                    serviceId,
+                    stakingAddress: svc.staking_address,
+                    distributorAddress: CHAIN_CONFIG.distributorAddress,
+                    rpcUrl: config.rpcUrl,
+                    chain: NETWORK_CHAIN,
+                    mnemonic: mnemonicForMaster,
+                });
+                return { ok: true };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        };
+    }
     const evictionRecovery = config.stakingMode === 'standard' &&
         serviceId !== null &&
         stakingAddress &&
@@ -1298,6 +1491,11 @@ export async function main() {
             sharedDiscoveryApi = await buildOnchainFloor();
         }
     }
+    // jinn-mono-u34i: populate the holder so the /v1/discovery/* routes
+    // registered eagerly at server-start time start returning real data on
+    // the panel's next refetch. Before this, the routes 404'd forever and
+    // the /build page rendered "Discovery unavailable" permanently.
+    discoveryApiHolder.current = sharedDiscoveryApi;
     const adapter = new MechAdapter({
         rpcUrl: config.rpcUrl,
         mechMarketplaceAddress: MARKETPLACE_ADDRESS,
@@ -1315,7 +1513,12 @@ export async function main() {
             ? {
                 discoveryApi: sharedDiscoveryApi,
                 solverNetManifestCids: taskDiscoveryManifestCids,
-                onchainFromBlock: config.network === 'testnet' ? 41_153_291 : 25_000_000,
+                // No explicit `onchainFromBlock` — 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.
                 ...(config.taskDiscoveryAllowedTaskIds?.length
                     ? { allowedTaskIds: config.taskDiscoveryAllowedTaskIds }
                     : {}),
@@ -1339,19 +1542,45 @@ export async function main() {
     // ── 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.ethereumRpcUrl
         ? {
             public: createJinnL1PublicClient(config.ethereumRpcUrl, config.jinnL1Network),
             wallet: createJinnL1WalletClient(config.ethereumRpcUrl, 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);
@@ -1440,10 +1669,42 @@ export async function main() {
         externalImpls,
         disabledNames: config.harnesses?.disabled,
         corpusEnv,
+        hermesPath: config.hermesPath,
+        hermesModel: config.hermesModel,
+        hermesProvider: config.hermesProvider,
+        hermesDoctorTimeoutMs: config.hermesDoctorTimeoutMs,
+        codexPath: config.codexPath,
+        codexDoctorTimeoutMs: config.codexDoctorTimeoutMs,
     })) {
         implRegistry.register(impl);
     }
     console.log(`[main] HarnessRegistry: ${implRegistry.list().map(i => i.name).join(', ')}`);
+    // ── Harness readiness registry ─────────────────────────────────────────────
+    // Composes per-harness isReady() probes into a cached snapshot consumed by
+    // claim loops (A5) and /v1/harnesses/readiness (A3).
+    //
+    // The registry is constructed here, after buildHarnesses() has run, which
+    // is necessarily after bootstrap (bootstrap needs the keystore). The HTTP
+    // server was started before bootstrap so it could show setup progress — we
+    // mount the readiness routes on the already-running app via setupApiServer.app
+    // (same pattern used by registerSolverNetsEndpoints). Routes are registered
+    // before the first operator request that cares about harness readiness.
+    //
+    // A2 carry-over: start() only schedules the 4s tick; refreshNow() is called
+    // immediately so the snapshot is populated before the first claim-loop tick.
+    const harnessReadinessRegistry = buildHarnessReadinessRegistry({
+        harnesses: implRegistry.list(),
+        config,
+    });
+    harnessReadinessRegistry.start();
+    await harnessReadinessRegistry.refreshNow();
+    // Routes were registered eagerly at startApiServer time via the holder
+    // ref pattern (jinn-mono-u34i). Populate the holder now and the already-
+    // mounted /v1/harnesses/readiness routes start returning real data.
+    // Late-mounting via addHarnessReadinessRoutes(setupApiServer.app, ...)
+    // is no longer needed and would throw on Hono's locked matcher.
+    harnessReadinessRegistryHolder.current = harnessReadinessRegistry;
+    console.log('[main] HarnessReadinessRegistry started; /v1/harnesses/readiness routes active.');
     // ── Engine deps ───────────────────────────────────────────────────────────────
     // Packaging deps: artifacts are always written to served_artifacts
     // (operator-local SQLite). In public-testnet donation mode, scrubbed artifact
@@ -1812,9 +2073,15 @@ export async function main() {
         nodeEndpoint: config.nodeEndpoint,
         creatorSafeAddress: safeAddress,
         corpusFactory,
+        harnessReadinessRegistry,
         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,
             network: config.network,
             pollIntervalMs: config.pollIntervalMs,
             masterEthDailyEstimateWei: config.masterEthDailyEstimateWei,
@@ -1837,28 +2104,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,
@@ -1903,6 +2149,32 @@ 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,
     });
     // Write pidfile so `jinn stop` can find us.
     const pidPath = join(config.earningDir, 'daemon.pid');
@@ -1928,6 +2200,7 @@ export async function main() {
             let exitCode = 0;
             console.log(`\n[main] Received ${signal}, shutting down...`);
             try {
+                harnessReadinessRegistry.stop();
                 await daemon.stop();
                 await setupApiServer.close().catch(() => undefined);
                 await closeCaptureReceiver();
@@ -1994,4 +2267,32 @@ export async function main() {
         serviceId,
     };
 }
+// ── Harness readiness registry factory ───────────────────────────────────────
+// Exported so tests can construct a registry without booting the full daemon.
+/**
+ * Builds a HarnessReadinessRegistry from the harness list returned by
+ * buildHarnesses() and the operator's joinedSolverNets config block.
+ *
+ * Per A2 carry-over: start() only schedules the background tick; callers that
+ * need the snapshot populated immediately must call refreshNow() after start().
+ */
+export function buildHarnessReadinessRegistry(args) {
+    const harnessesByName = {};
+    for (const h of args.harnesses) {
+        harnessesByName[h.name] = h;
+    }
+    const joinedHarnessesByCid = {};
+    for (const [cid, entry] of Object.entries(args.config.joinedSolverNets ?? {})) {
+        if (entry.harness) {
+            joinedHarnessesByCid[cid] = {
+                harnessName: entry.harness,
+                roles: entry.roles,
+            };
+        }
+    }
+    return new HarnessReadinessRegistry({
+        harnessesByName,
+        joinedHarnessesByCid,
+    });
+}
 //# sourceMappingURL=main.js.map