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

package/dist/main.js

@@ -33,6 +33,7 @@ import { setDefaultTxSubmissionLedger } from './tx-retry.js';
 import { CapturePublishUnavailableError } from './api/captures.js';
 import { invalidatePredictionOperatorStatusCache } from './api/gather-status.js';
 import { ensureUiToken } from './api/ui-token.js';
+import { getFileLogger, closeFileLogger } from './observability/file-logger.js';
 import { hashImplStateDir } from './harnesses/freeze.js';
 import { readModeState } from './harnesses/mode-state.js';
 import { attachAgentWs, updateAgentClaudePath } from './agent/agent-ws.js';
@@ -41,6 +42,9 @@ 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 { applyPidfileLivenessGate } from './preflight/pidfile-liveness.js';
+import { applyDeploymentReadinessGate } from './preflight/deployment-readiness.js';
+import { detectAuthContext } from './preflight/claude-auth.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';
@@ -50,6 +54,9 @@ 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 { buildAiUnitsConfig } from './spend/ai-units-config.js';
+import { REFERENCE_CEILING } from './spend/ai-units.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';
@@ -62,7 +69,7 @@ import { CLAUDE_CODE_HARNESS, CODEX_HARNESS, HERMES_AGENT_HARNESS, harnessStateD
 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';
@@ -78,10 +85,12 @@ 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, filterBindableTasks } from './tasks/sources.js';
-import { checkRpcNetwork, logRpcLocalDevToStderr, rpcNetworkFailureHint } from './preflight/rpc-network.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';
@@ -203,25 +212,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) {
@@ -236,6 +235,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'])
@@ -265,28 +269,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) {
@@ -641,6 +652,11 @@ function emitProgress(envelope) {
 }
 export async function main() {
     console.log(`[main] jinn-client starting on ${NETWORK_CHAIN}`);
+    // Issue #420: initialise the rotating daemon file logger early so lifecycle
+    // events (tapped in `observability/emit-event.ts`) accumulate durable,
+    // pre-redacted log lines for the one-click debug report. Constructing the
+    // singleton here also runs the startup age-based cleanup of stale rotations.
+    getFileLogger();
     // ── Daemon API bearer token (jinn-mono-pr64 hardening) ───────────────────
     //
     // Cost-mutating API routes (`POST /v1/artifacts/acquire`, `POST /artifacts`)
@@ -681,6 +697,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({
@@ -734,11 +759,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();
@@ -790,11 +860,6 @@ 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.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
@@ -836,9 +901,7 @@ export async function main() {
                     // requestDaemonRestart so the operator is never stranded.
                     preSpawnCleanup: async () => {
                         await setupApiServer.close().catch(() => undefined);
-                        if (captureReceiver) {
-                            await captureReceiver.shutdown().catch(() => undefined);
-                        }
+                        await closeCaptureReceiver();
                     },
                 }),
             },
@@ -871,6 +934,14 @@ export async function main() {
                     config.operator = operator;
                 },
             },
+            // Issue #420: one-click operator debug report. The bundle assembler
+            // reads the live resolved `config` so the download reflects env
+            // overrides + defaults, not just the on-disk config file.
+            debugReport: {
+                store: sharedStore,
+                config,
+                configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
+            },
             captures: {
                 captures: capturesStore,
                 publishCapture: async (sessionId) => {
@@ -894,7 +965,6 @@ export async function main() {
                 configReader: () => ({
                     rpcUrl: config.rpcUrl,
                     defaultRpcUrl: CHAIN_CONFIG.rpcUrl,
-                    solverNets: config.solverNets,
                     joinedSolverNets: config.joinedSolverNets,
                 }),
             },
@@ -1017,22 +1087,15 @@ 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.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.
@@ -1094,29 +1157,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,
@@ -1327,7 +1391,7 @@ export async function main() {
                     return Number.isFinite(n) && n > 0 ? n : 15_000;
                 })();
                 if (isHaltedOnFunding && haltAddress && haltRequired !== null) {
-                    const publicClient = createJinnPublicClient(config.rpcUrl, NETWORK_CHAIN);
+                    const publicClient = createJinnPublicClient(config.rpcUrls, NETWORK_CHAIN);
                     const schedulePoll = () => {
                         fundingPollHandle = setTimeout(async () => {
                             // Guard: if the signal was already fired, stop polling.
@@ -1425,36 +1489,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);
-    // 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 masterWallet = createJinnWalletClient(config.rpcUrls, NETWORK_CHAIN, masterAccount);
     const evictionRecovery = config.stakingMode === 'standard' &&
         serviceId !== null &&
         stakingAddress &&
@@ -1513,7 +1550,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,
@@ -1529,12 +1566,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 }
                     : {}),
@@ -1551,10 +1594,10 @@ 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.
@@ -1565,10 +1608,10 @@ export async function main() {
         distributorAddress: JINN_MVI_CONFIG.distributor,
         ethereumRpcUrl: config.ethereumRpcUrl,
     });
-    const l1ClientsForJinnClaim = shouldWireJinnClaimL1 && 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;
     const jinnClaimLoopConfig = buildJinnClaimLoopConfig({
@@ -1688,6 +1731,7 @@ export async function main() {
         hermesPath: config.hermesPath,
         hermesModel: config.hermesModel,
         hermesProvider: config.hermesProvider,
+        hermesBaseUrl: config.hermesBaseUrl,
         hermesDoctorTimeoutMs: config.hermesDoctorTimeoutMs,
         codexPath: config.codexPath,
         codexDoctorTimeoutMs: config.codexDoctorTimeoutMs,
@@ -2029,6 +2073,8 @@ export async function main() {
                 agentEoa: agentEoaAddress,
                 safeAddress,
                 agentPrivateKey,
+                ipfsGatewayUrl: config.ipfsGatewayUrl,
+                ...(sharedDiscoveryApi ? { discoveryApi: sharedDiscoveryApi } : {}),
             },
             logger: {
                 info: (message) => console.log(message),
@@ -2096,6 +2142,21 @@ 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 aiUnits = buildAiUnitsConfig(config, process.env);
+    if (aiUnits) {
+        // Surface the resolved AI-units cap so an operator inspecting logs can
+        // distinguish the baked-in default (100/2800) from a deliberate
+        // `JINN_AI_UNITS_CEILING_OVERRIDE` raise (e.g. 10000/280000 in CI).
+        // Source reflects the actual outcome: a malformed override falls back
+        // to default and emits its own warn from resolveReferenceCeiling.
+        const overrideSet = typeof process.env['JINN_AI_UNITS_CEILING_OVERRIDE'] === 'string' &&
+            process.env['JINN_AI_UNITS_CEILING_OVERRIDE'].trim() !== '';
+        const matchesDefault = aiUnits.capPerBlock === REFERENCE_CEILING.units_per_block &&
+            aiUnits.capPerWeek === REFERENCE_CEILING.units_per_week;
+        const source = overrideSet && !matchesDefault ? 'env' : 'default';
+        console.log(`[ai-units] cap=${aiUnits.capPerBlock}/${aiUnits.capPerWeek} per (block, week) source=${source}`);
+    }
     const daemon = new Daemon({
         adapter,
         runner,
@@ -2112,6 +2173,8 @@ export async function main() {
         creatorSafeAddress: safeAddress,
         corpusFactory,
         harnessReadinessRegistry,
+        spendCap,
+        aiUnits,
         status: {
             earningDir: config.earningDir,
             rpcUrl: config.rpcUrl,
@@ -2121,6 +2184,11 @@ export async function main() {
             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,
@@ -2132,6 +2200,8 @@ export async function main() {
             engine: config.engine,
             config,
             configPath: CONFIG_PATH ?? DEFAULT_CONFIG_PATH,
+            spendCaps: spendCap?.caps,
+            aiUnits,
         },
         rewardClaim: config.rewardClaimIntervalMs > 0
             ? {
@@ -2196,6 +2266,7 @@ export async function main() {
             CHAIN_CONFIG.distributorAddress
             ? {
                 intervalMs: config.evictionCheckIntervalMs,
+                reStakeThrottleMs: config.checkpointIntervalMs,
                 store: earningStore,
                 chain: NETWORK_CHAIN,
                 readContract: (opts) => publicClient.readContract(opts),
@@ -2244,10 +2315,32 @@ export async function main() {
             }
             : 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.
+    // Deployment-readiness gate (#958). In a deployment context (JINN_STATE_DIR
+    // set or a container/compose auth context) this fails loud and exits when a
+    // hard check fails (writable-volume, state-on-volume, agent-cli-non-root).
+    // Outside a deployment context it only logs advisories — a plain local
+    // `jinn run` is NEVER newly gated here. Runs before the pidfile gate so an
+    // unfit environment refuses before we touch the pidfile.
+    await applyDeploymentReadinessGate({
+        stateDir: config.stateDir,
+        earningDir: config.earningDir,
+        relayerUrl: undefined,
+        runtimeMode: config.runtimeMode,
+    }, {
+        env: process.env,
+        getuid: typeof process.getuid === 'function' ? process.getuid.bind(process) : undefined,
+        detectAuthContext,
+        fetch,
+    });
     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);
@@ -2285,6 +2378,8 @@ export async function main() {
                 catch {
                     /* ignore */
                 }
+                // Issue #420: flush + close the rotating daemon file logger.
+                closeFileLogger();
             }
             console.log('[main] Shutdown complete.');
             process.exit(exitCode);